Ticket #6210: 6210-03192019.diff

src/bp-core/admin/bp-core-admin-schema.php

@@ -535 +535 @@
          */
         do_action( 'bp_core_install_emails' );
 }
+
+/**
+ * Install database tables for the Invitations API
+ *
+ * @since 5.0.0
+ *
+ * @uses bp_core_set_charset()
+ * @uses bp_core_get_table_prefix()
+ * @uses dbDelta()
+ */
+function bp_core_install_invitations() {
+        $sql             = array();
+        $charset_collate = $GLOBALS['wpdb']->get_charset_collate();
+        $bp_prefix       = bp_core_get_table_prefix();
+        $sql[] = "CREATE TABLE {$bp_prefix}bp_invitations (
+                id bigint(20) NOT NULL AUTO_INCREMENT PRIMARY KEY,
+                user_id bigint(20) NOT NULL,
+                inviter_id bigint(20) NOT NULL,
+                invitee_email varchar(100) DEFAULT NULL,
+                class varchar(120) NOT NULL,
+                item_id bigint(20) NOT NULL,
+                secondary_item_id bigint(20) DEFAULT NULL,
+                type varchar(12) NOT NULL DEFAULT 'invite',
+                content longtext DEFAULT '',
+                date_modified datetime NOT NULL,
+                invite_sent tinyint(1) NOT NULL DEFAULT '0',
+                accepted tinyint(1) NOT NULL DEFAULT '0',
+                KEY user_id (user_id),
+                KEY inviter_id (inviter_id),
+                KEY invitee_email (invitee_email),
+                KEY class (class),
+                KEY item_id (item_id),
+                KEY secondary_item_id (secondary_item_id),
+                KEY type (type),
+                KEY invite_sent (invite_sent),
+                KEY accepted (accepted)
+                ) {$charset_collate};";
+        dbDelta( $sql );
+
+        // @TODO: Migrate invitations here
+
+        /**
+         * Fires after BuddyPress adds the invitations table.
+         *
+         * @since 5.0.0
+         */
+        do_action( 'bp_core_install_invitations' );
+}

src/bp-core/bp-core-functions.php

@@ -3479 +3479 @@
                         /* translators: do not remove {} brackets or translate its contents. */
                         'post_title'   => __( '[{{{site.name}}}] You have an invitation to the group: "{{group.name}}"', 'buddypress' ),
                         /* translators: do not remove {} brackets or translate its contents. */
-                        'post_content' => __( "<a href=\"{{{inviter.url}}}\">{{inviter.name}}</a> has invited you to join the group: &quot;{{group.name}}&quot;.\n<a href=\"{{{invites.url}}}\">Go here to accept your invitation</a> or <a href=\"{{{group.url}}}\">visit the group</a> to learn more.", 'buddypress' ),
+                        'post_content' => __( "<a href=\"{{{inviter.url}}}\">{{inviter.name}}</a> has invited you to join the group: &quot;{{group.name}}&quot;.\n{{invite.message}}\n<a href=\"{{{invites.url}}}\">Go here to accept your invitation</a> or <a href=\"{{{group.url}}}\">visit the group</a> to learn more.", 'buddypress' ),
                         /* translators: do not remove {} brackets or translate its contents. */
                         'post_excerpt' => __( "{{inviter.name}} has invited you to join the group: \"{{group.name}}\".\n\nTo accept your invitation, visit: {{{invites.url}}}\n\nTo learn more about the group, visit: {{{group.url}}}.\nTo view {{inviter.name}}'s profile, visit: {{{inviter.url}}}", 'buddypress' ),
                 ),
@@ -3495 +3495 @@
                         /* translators: do not remove {} brackets or translate its contents. */
                         'post_title'   => __( '[{{{site.name}}}] Membership request for group: {{group.name}}', 'buddypress' ),
                         /* translators: do not remove {} brackets or translate its contents. */
-                        'post_content' => __( "<a href=\"{{{profile.url}}}\">{{requesting-user.name}}</a> wants to join the group &quot;{{group.name}}&quot;. As you are an administrator of this group, you must either accept or reject the membership request.\n\n<a href=\"{{{group-requests.url}}}\">Go here to manage this</a> and all other pending requests.", 'buddypress' ),
+                        'post_content' => __( "<a href=\"{{{profile.url}}}\">{{requesting-user.name}}</a> wants to join the group &quot;{{group.name}}&quot;.\n {{request.message}}\n As you are an administrator of this group, you must either accept or reject the membership request.\n\n<a href=\"{{{group-requests.url}}}\">Go here to manage this</a> and all other pending requests.", 'buddypress' ),
                         /* translators: do not remove {} brackets or translate its contents. */
                         'post_excerpt' => __( "{{requesting-user.name}} wants to join the group \"{{group.name}}\". As you are the administrator of this group, you must either accept or reject the membership request.\n\nTo manage this and all other pending requests, visit: {{{group-requests.url}}}\n\nTo view {{requesting-user.name}}'s profile, visit: {{{profile.url}}}", 'buddypress' ),
                 ),

new file src/bp-core/bp-core-invitations-cache.php

@@ +1 @@
+<?php
+/**
+ * BuddyPress Invitation Caching Functions.
+ *
+ * Caching functions handle the clearing of cached objects and pages on specific
+ * actions throughout BuddyPress.
+ *
+ * @package BuddyPress
+ * @subpackage InvitationsCache
+ * @since 5.0.0
+ */
+
+/**
+ * Resets all incremented bp_invitations caches.
+ *
+ * @since 5.0.0
+ */
+function bp_invitations_reset_cache_incrementor() {
+        bp_core_reset_incrementor( 'bp_invitations' );
+}
+add_action( 'bp_invitation_after_save', 'bp_invitations_reset_cache_incrementor' );
+add_action( 'bp_invitation_after_delete', 'bp_invitations_reset_cache_incrementor' );

src/bp-core/bp-core-update.php

@@ -211 +211 @@
                 bp_update_option( 'bp-active-components', $default_components );
                 bp_core_add_page_mappings( $default_components, 'delete' );
                 bp_core_install_emails();
+                bp_core_install_invitations();
 
         // Upgrades.
         } else {
@@ -268 +269 @@
                 if ( $raw_db_version < 11105 ) {
                         bp_update_to_2_7();
                 }
+
+                // Version 5.0.0.
+                if ( $raw_db_version < 11300 ) {
+                        bp_update_to_5_0();
+                }
         }
 
         /* All done! *************************************************************/
@@ -542 +548 @@
         bp_add_option( '_bp_ignore_deprecated_code', false );
 }
 
+/**
+ * 5.0.0 update routine.
+ *
+ * - Create the invitations table.
+ * - Migrate requests and invitations to the new table.
+ *
+ * @since 2.7.0
+ */
+function bp_update_to_5_0() {
+        bp_core_install_invitations();
+
+        bp_groups_migrate_invitations();
+}
+
 /**
  * Updates the component field for new_members type.
  *

new file src/bp-core/classes/class-bp-invitation-manager.php

@@ +1 @@
+<?php
+/**
+ * Core invitations class.
+ *
+ * @package BuddyPress
+ * @subpackage Core
+ * @since 5.0.0
+ */
+
+// Exit if accessed directly.
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * BP Invitations class.
+ *
+ * Extend it to manage your class's invitations.
+ * Your extension class, must, at a minimum, provide the
+ * run_send_action() and run_acceptance_action() methods.
+ *
+ * @since 5.0.0
+ */
+abstract class BP_Invitation_Manager {
+
+        /**
+         * The name of the related class.
+         *
+         * @since 5.0.0
+         * @access public
+         * @var string
+         */
+        protected $class_name;
+
+        /**
+         * Construct parameters.
+         *
+         * @since 5.0.0
+         *
+         * @param array|string $args {
+         * }
+         */
+        public function __construct( $args = array() ) {
+                $this->class_name = get_class( $this );
+        }
+
+        /**
+         * Get the invitations table name.
+         *
+         * @since 5.0.0
+         * @access public
+         * @return string
+         */
+        public static function get_table_name() {
+                return buddypress()->table_prefix . 'bp_invitations';
+        }
+
+        /** Create ********************************************************************/
+
+        /**
+         * Add an invitation to a specific user, from a specific user, related to a
+         * specific class.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args {
+         *     Array of arguments describing the invitation. All are optional.
+         *         @type int    $user_id ID of the invited user.
+         *         @type int    $inviter_id ID of the user who created the invitation.
+         *         @type string $invitee_email Email address of the invited user.
+         *         @type int    $item_id ID associated with the invitation and class.
+         *         @type int    $secondary_item_id secondary ID associated with the
+         *                              invitation and class.
+         *         @type string $type @TODO.
+         *         @type string $content Extra information provided by the requester
+         *                              or inviter.
+         *         @type string $date_modified Date the invitation was last modified.
+         *         @type int    $send_invite Should the invitation also be sent, or is it a
+         *                       draft invite?
+         * }
+         * @return int|bool ID of the newly created invitation on success, false
+         *         on failure.
+         */
+        public function add_invitation( $args = array() ) {
+
+                $r = bp_parse_args( $args, array(
+                        'user_id'           => 0,
+                        'invitee_email'         => '',
+                        'inviter_id'            => 0,
+                        'item_id'           => 0,
+                        'secondary_item_id' => 0,
+                        'type'                          => 'invite',
+                        'content'                       => '',
+                        'date_modified'     => bp_core_current_time(),
+                        'send_invite'       => 0,
+                        'accepted'          => 0
+                ), 'add_invitation' );
+
+                // Invitations must have an invitee and inviter.
+                if ( ! ( ( $r['user_id'] || $r['invitee_email'] ) && $r['inviter_id'] ) ) {
+                        return false;
+                }
+
+                /**
+                 * Is this user allowed to extend invitations in this situation?
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param array $r Describes the invitation to be added.
+                 */
+                if ( ! $this->allow_invitation( $r ) ) {
+                        return false;
+                }
+
+                // Avoid creating duplicate invitations.
+                $invite_id = $this->invitation_exists( array(
+                        'user_id'           => $r['user_id'],
+                        'invitee_email'     => $r['invitee_email'],
+                        'inviter_id'        => $r['inviter_id'],
+                        'item_id'           => $r['item_id'],
+                        'secondary_item_id' => $r['secondary_item_id'],
+                ) );
+
+                if ( ! $invite_id ) {
+                        // Set up the new invitation as a draft.
+                        $invitation                    = new BP_Invitation;
+                        $invitation->user_id           = $r['user_id'];
+                        $invitation->inviter_id        = $r['inviter_id'];
+                        $invitation->invitee_email     = $r['invitee_email'];
+                        $invitation->class             = $this->class_name;
+                        $invitation->item_id           = $r['item_id'];
+                        $invitation->secondary_item_id = $r['secondary_item_id'];
+                        $invitation->type              = $r['type'];
+                        $invitation->content           = $r['content'];
+                        $invitation->date_modified     = $r['date_modified'];
+                        $invitation->invite_sent       = 0;
+                        $invitation->accepted          = 0;
+
+                        $invite_id = $invitation->save();
+                }
+
+                // "Send" the invite if necessary.
+                if ( $invite_id && $r['send_invite'] ) {
+                                $sent = $this->send_invitation_by_id( $invite_id );
+                        if ( ! $sent ) {
+                                return false;
+                        }
+                }
+
+                return $invite_id;
+        }
+
+        /**
+         * Send an invitation notification.
+         *
+         * @since 5.0.0
+         * @access public
+         *
+         * @param int $invitation_id ID of invitation to send.
+         *
+         * @return int|bool The number of rows updated, or false on error.
+         */
+        public function send_invitation_by_id( $invitation_id = 0 ) {
+                $updated = false;
+
+                $invitation = new BP_Invitation( $invitation_id );
+
+                if ( ! $invitation->id ) {
+                        return false;
+                }
+
+                /**
+                 * Fires before an invitation is sent.
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param BP_Invitation object $invitation Invitation about to be sent.
+                 */
+                do_action( 'bp_invitations_send_invitation_by_id_before_send', $invitation );
+
+                /*
+                 * Before sending an invitation, check for outstanding requests to the same item.
+                 * A sent invitation + a request = acceptance.
+                 */
+                $request_args = array(
+                        'user_id'           => $invitation->user_id,
+                        'invitee_email'     => $invitation->invitee_email,
+                        'item_id'           => $invitation->item_id,
+                        'secondary_item_id' => $invitation->secondary_item_id,
+                );
+                $request = $this->request_exists( $request_args );
+
+                if ( ! empty( $request ) ) {
+                        // Accept the request.
+                        return $this->accept_request( $request_args );
+                }
+
+                // Perform the send action.
+                $this->run_send_action( $invitation );
+
+                $updated = BP_Invitation::mark_sent( $invitation->id );
+
+                return $updated;
+        }
+
+        /**
+         * Add a request to an item for a specific user, related to a
+         * specific class.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args {
+         *     Array of arguments describing the invitation. All are optional.
+         *         @type int    $user_id ID of the invited user.
+         *         @type int    $inviter_id ID of the user who created the invitation.
+         *         @type string $class Name of the invitations class.
+         *         @type int    $item_id ID associated with the invitation and class.
+         *         @type int    $secondary_item_id secondary ID associated with the
+         *                              invitation and class.
+         *         @type string $type @TODO.
+         *         @type string $content Extra information provided by the requester
+         *                              or inviter.
+         *         @type string $date_modified Date the invitation was last modified.
+         *         @type int    $invite_sent Has the invitation been sent, or is it a
+         *                       draft invite?
+         * }
+         * @return int|bool ID of the newly created invitation on success, false
+         *         on failure.
+         */
+        public function add_request( $args = array() ) {
+
+                $r = bp_parse_args( $args, array(
+                        'user_id'           => 0,
+                        'inviter_id'        => 0,
+                        'invitee_email'     => '',
+                        'item_id'           => 0,
+                        'secondary_item_id' => 0,
+                        'type'              => 'request',
+                        'content'           => '',
+                        'date_modified'     => bp_core_current_time(),
+                        'invite_sent'       => 0,
+                        'accepted'          => 0
+                ), 'add_request' );
+
+                // If there is no invitee, bail.
+                if ( ! ( $r['user_id'] || $r['invitee_email'] ) ) {
+                                return false;
+                }
+
+                /**
+                 * Is this user allowed to make a request in this situation?
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param array $r Describes the invitation to be added.
+                 */
+                if ( ! $this->allow_request( $r ) ) {
+                        return false;
+                }
+
+                /*
+                 * Avoid creating duplicate requests.
+                 */
+                $base_args = array(
+                        'user_id'           => $r['user_id'],
+                        'invitee_email'     => $r['invitee_email'],
+                        'item_id'           => $r['item_id'],
+                        'secondary_item_id' => $r['secondary_item_id'],
+                );
+                if ( $this->request_exists( $base_args ) ) {
+                        return false;
+                }
+
+                /*
+                 * Check for outstanding invitations to the same item.
+                 * A request + a sent invite = acceptance.
+                 */
+                $invite_args = array_merge( $base_args, array( 'invite_sent' => 'sent' ) );
+                $invite = $this->invitation_exists( $invite_args );
+
+                if ( $invite ) {
+                        // Accept the invite.
+                        return $this->accept_invitation( $base_args );
+                } else {
+                        // Set up the new request.
+                        $request                    = new BP_Invitation;
+                        $request->user_id           = $r['user_id'];
+                        $request->inviter_id        = $r['inviter_id'];
+                        $request->invitee_email     = $r['invitee_email'];
+                        $request->class             = $this->class_name;
+                        $request->item_id           = $r['item_id'];
+                        $request->secondary_item_id = $r['secondary_item_id'];
+                        $request->type              = $r['type'];
+                        $request->content           = $r['content'];
+                        $request->date_modified     = $r['date_modified'];
+                        $request->invite_sent       = $r['invite_sent'];
+                        $request->accepted          = $r['accepted'];
+
+                        // Save the new invitation.
+                        return $request->save();
+                }
+        }
+
+        /**
+         * Send a request notification.
+         *
+         * @since 5.0.0
+         * @access public
+         *
+         * @param int $request_id ID of request to send.
+         *
+         * @return int|bool The number of rows updated, or false on error.
+         */
+        public function send_request_notification_by_id( $request_id = 0 ) {
+                $updated = false;
+
+                $request = new BP_Invitation( $request_id );
+
+                if ( ! $request->id ) {
+                        return false;
+                }
+
+                // Different uses may need different actions on sending. Plugins can hook in here to perform their own tasks.
+                do_action( 'bp_invitations_send_request_notification_by_id_before_send', $request_id, $request );
+
+                /*
+                 * Before sending notifications, check for outstanding invitations to the same item.
+                 * A sent invitation + a request = acceptance.
+                 */
+                $args = array(
+                        'user_id'           => $request->user_id,
+                        'invitee_email'     => $request->invitee_email,
+                        'item_id'           => $request->item_id,
+                        'secondary_item_id' => $request->secondary_item_id,
+                        'invite_sent'       => 'sent'
+                );
+                $invites = $this->invitation_exists( $args );
+
+                if ( ! empty( $invites ) ) {
+                        // Accept the request.
+                        return $this->accept_invitation( $args );
+                }
+
+                // Perform the send action.
+                $this->run_send_action( $request );
+
+                $updated = BP_Invitation::mark_sent( $request->id );
+
+                return $updated;
+        }
+
+        /** Retrieve ******************************************************************/
+
+        /**
+         * Get a specific invitation by its ID.
+         *
+         * @since 5.0.0
+         *
+         * @param int $id ID of the invitation.
+         * @return BP_Invitation object
+         */
+        public function get_by_id( $id = 0 ) {
+                return new BP_Invitation( $id );
+        }
+
+        /**
+         * Get invitations, based on provided filter parameters.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of accepted parameters.
+         *
+         * @return array Located invitations.
+         */
+        public function get_invitations( $args = array() ) {
+                // Default to returning invitations, not requests.
+                if ( empty( $args['type'] ) ) {
+                        $args['type'] = 'invite';
+                }
+                // Use the class_name property value.
+                $args['class'] = $this->class_name;
+
+                return BP_Invitation::get( $args );
+        }
+
+        /**
+         * Get requests, based on provided filter parameters.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of accepted parameters.
+         *
+         * @return array Located invitations.
+         */
+        public function get_requests( $args = array() ) {
+                // Set request-specific parameters.
+                $args['type']        = 'request';
+                $args['inviter_id']  = false;
+                $args['invite_sent'] = 'all';
+
+                // Use the class_name property value.
+                $args['class'] = $this->class_name;
+
+                return BP_Invitation::get( $args );
+        }
+
+        /**
+         * Check whether an invitation exists matching the passed arguments.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of accepted parameters.
+         *
+         * @return bool|int ID of first found invitation or false if none found.
+         */
+        public function invitation_exists( $args = array() ) {
+                $is_invited = false;
+
+                $args['fields'] = 'ids';
+                $invites = $this->get_invitations( $args );
+                if ( $invites ) {
+                        $is_invited = current( $invites );
+                }
+                return $is_invited;
+        }
+
+        /**
+         * Check whether a request exists matching the passed arguments.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of accepted parameters.
+         *
+         * @return bool|int ID of existing request or false if none found.
+         */
+        public function request_exists( $args = array() ) {
+                $has_request = false;
+
+                $args['fields'] = 'ids';
+                $requests = $this->get_requests( $args );
+                if ( $requests ) {
+                        $has_request = current( $requests );
+                }
+                return $has_request;
+        }
+
+        /** Update ********************************************************************/
+
+        /**
+         * Accept invitation, based on provided filter parameters.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of
+         *      accepted update/where arguments.
+         *
+         * @param array $update_args Associative array of fields to update,
+         *              and the values to update them to. Of the format
+         *              array( 'user_id' => 4 )
+         *
+         * @return int|bool Number of rows updated on success, false on failure.
+         */
+         public function accept_invitation( $args = array() ) {
+
+                /*
+                 * Some basic info is required to accept an invitation,
+                 * because we'll need to mark all similar invitations and requests.
+                 * The following, except the optional 'secondary_item_id', are required.
+                 */
+                $r = bp_parse_args( $args, array(
+                        'user_id'           => 0,
+                        'invitee_email'     => '',
+                        'item_id'           => null,
+                        'secondary_item_id' => null,
+                        'invite_sent'       => 'sent',
+                ), 'accept_invitation' );
+                $r['class'] = $this->class_name;
+
+                if ( ! ( ( $r['user_id'] || $r['invitee_email'] ) && $r['class'] && $r['item_id'] ) ) {
+                        return false;
+                }
+
+                $success = $this->run_acceptance_action( 'invite', $r );
+                if ( $success ) {
+                        // Mark invitations & requests to this item for this user.
+                        $this->mark_accepted( $r );
+
+                        // Allow plugins an opportunity to act on the change.
+                        do_action( 'bp_invitations_accepted_invite', $r );
+                }
+                return $success;
+        }
+
+        /**
+         * Accept invitation, based on provided filter parameters.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of
+         *      accepted update/where arguments.
+         *
+         * @param array $update_args Associative array of fields to update,
+         *              and the values to update them to. Of the format
+         *              array( 'user_id' => 4 )
+         *
+         * @return bool Number of rows updated on success, false on failure.
+         */
+         public function accept_request( $args = array() ) {
+                /*
+                 * Some basic info is required to accept an invitation,
+                 * because we'll need to accept all similar invitations and requests.
+                 * The following, except the optional 'secondary_item_id', are required.
+                 */
+                $r = bp_parse_args( $args, array(
+                        'user_id'           => 0,
+                        'item_id'           => null,
+                        'secondary_item_id' => null,
+                ), 'accept_request' );
+                $r['class'] = $this->class_name;
+
+                if ( ! ( $r['user_id'] && $r['class'] && $r['item_id'] ) ) {
+                        return false;
+                }
+
+                $success = $this->run_acceptance_action( 'request', $r );
+                if ( $success ) {
+                        // Update/Delete all related invitations & requests to this item for this user.
+                        $this->mark_accepted( $r );
+
+                        // Allow plugins an opportunity to act on the change.
+                        do_action( 'bp_invitations_accepted_request', $r );
+                }
+                return $success;
+        }
+
+        /**
+         * Update invitation, based on provided filter parameters.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of
+         *      accepted update/where arguments.
+         *
+         * @param array $update_args Associative array of fields to update,
+         *              and the values to update them to. Of the format
+         *              array( 'user_id' => 4 )
+         * @param array $where_args Associative array of columns/values, to
+         *              determine which invitations should be updated. Formatted as
+         *              array( 'item_id' => 7 )
+         * @return int|bool Number of rows updated on success, false on failure.
+         */
+        public function update_invitation( $update_args = array(), $where_args = array() ) {
+                $update_args['class'] = $this->class_name;
+                return BP_Invitation::update( $update_args, $where_args );
+        }
+
+
+        /**
+         * This is where custom actions are added (in child classes)
+         * to run when an invitation or request needs to be "sent."
+         *
+         * @since 5.0.0
+         *
+         * @param BP_Invitation $invitation The invitation to send.
+         * @return bool True on success, false on failure.
+         */
+        abstract public function run_send_action( BP_Invitation $invitation );
+
+        /**
+         * Mark invitations as sent that are found by user_id, inviter_id,
+         * invitee_email, class name, optional item id,
+         * optional secondary item id.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args {
+         *     Associative array of arguments. All arguments but $page and
+         *     $per_page can be treated as filter values for get_where_sql()
+         *     and get_query_clauses(). All items are optional.
+         *     @type int|array    $user_id ID of user being queried. Can be an
+         *                        array of user IDs.
+         *     @type int|array    $inviter_id ID of user who created the
+         *                        invitation. Can be an array of user IDs.
+         *                        Special cases
+         *     @type string|array $invitee_email Email address of invited users
+         *                                    being queried. Can be an array of addresses.
+         *     @type string|array $class Name of the class to
+         *                        filter by. Can be an array of class names.
+         *     @type int|array    $item_id ID of associated item. Can be an array
+         *                        of multiple item IDs.
+         *     @type int|array    $secondary_item_id ID of secondary associated
+         *                        item. Can be an array of multiple IDs.
+         * }
+         */
+        public function mark_sent( $args ) {
+                $args['class'] = $this->class_name;
+                return BP_Invitation::mark_sent_by_data( $args );
+        }
+
+        /**
+         * This is where custom actions are added (in child classes)
+         * to run when an invitation or request is accepted.
+         *
+         * @since 5.0.0
+         *
+         * @param int $id The ID of the invitation to mark as sent.
+         * @return bool True on success, false on failure.
+         */
+        abstract public function run_acceptance_action( $type = 'invite', $r  );
+
+        /**
+         * Mark invitation as accepted by invitation ID.
+         *
+         * @since 5.0.0
+         *
+         * @param int $id The ID of the invitation to mark as sent.
+         * @return bool True on success, false on failure.
+         */
+        public function mark_accepted_by_id( $id ) {
+                return BP_Invitation::mark_accepted( $id );
+        }
+
+        /**
+         * Mark invitations as sent that are found by user_id, inviter_id,
+         * invitee_email, class name, optional item id,
+         * optional secondary item id.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::mark_accepted_by_data()
+         *      for a description of arguments.
+         */
+        public function mark_accepted( $args ) {
+                $args['class'] = $this->class_name;
+                return BP_Invitation::mark_accepted_by_data( $args );
+        }
+
+        /** Delete ********************************************************************/
+
+        /**
+         * Delete an invitation or invitations by query data.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::delete for a description of arguments.
+         * @return int|false Number of rows deleted on success, false on failure.
+         */
+        public function delete( $args ) {
+                if ( empty( $args['type'] ) ) {
+                        $args['type'] = 'invite';
+                }
+                $args['class'] = $this->class_name;
+                return BP_Invitation::delete( $args );
+        }
+
+        /**
+         * Delete a request or requests by query data.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::delete for a description of arguments.
+         *
+         * @return int|false Number of rows deleted on success, false on failure.
+         */
+        public function delete_requests( $args ) {
+                $args['type'] = 'request';
+                return $this->delete( $args );
+        }
+
+        /**
+         * Delete all invitations by class.
+         *
+         * Used when clearing out invitations for an entire class. Possibly used
+         * when deactivating a component related to a class that created invitations.
+         *
+         * @since 5.0.0
+         *
+         * @return int|false Number of rows deleted on success, false on failure.
+         */
+        public function delete_all() {
+                return BP_Invitation::delete( array(
+                        'class' => $this->class_name,
+                ) );
+        }
+
+        /**
+         * This is where custom actions are added (in child classes)
+         * to determine whether an invitation should be allowed.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args The parameters describing the invitation.
+         * @return bool True if allowed, false to end process.
+         */
+        public function allow_invitation( $args ) {
+                return true;
+        }
+
+        /**
+         * This is where custom actions are added (in child classes)
+         * to determine whether a request should be allowed.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args The parameters describing the request.
+         * @return bool True if allowed, false to end process.
+         */
+        public function allow_request( $args ) {
+                return true;
+        }
+
+}

new file src/bp-core/classes/class-bp-invitation.php

@@ +1 @@
+<?php
+
+/**
+ * BuddyPress Invitation Class
+ *
+ * @package BuddyPress
+ * @subpackage Invitations
+ *
+ * @since 5.0.0
+ */
+
+// Exit if accessed directly.
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * BuddyPress Invitations.
+ *
+ * Use this class to create, access, edit, or delete BuddyPress Invitations.
+ *
+ * @since 5.0.0
+ */
+class BP_Invitation {
+
+        /**
+         * The invitation ID.
+         *
+         * @since 5.0.0
+         * @access public
+         * @var int
+         */
+        public $id;
+
+        /**
+         * The ID of the invited user.
+         *
+         * @since 5.0.0
+         * @access public
+         * @var int
+         */
+        public $user_id;
+
+        /**
+         * The ID of the user who created the invitation.
+         *
+         * @since 5.0.0
+         * @access public
+         * @var int
+         */
+        public $inviter_id;
+
+        /**
+         * The email address of the invited user.
+         * Used when extending an invitation to someone who does not belong to the site.
+         *
+         * @since 5.0.0
+         * @access public
+         * @var string
+         */
+        public $invitee_email;
+
+        /**
+         * The name of the related class.
+         *
+         * @since 5.0.0
+         * @access public
+         * @var string
+         */
+        public $class;
+
+        /**
+         * The ID associated with the invitation and component.
+         * Example: the group ID if a group invitation
+         *
+         * @since 5.0.0
+         * @access public
+         * @var int
+         */
+        public $item_id;
+
+        /**
+         * The secondary ID associated with the invitation and component.
+         * Example: a taxonomy term ID if invited to a site's category-specific RSS feed
+         *
+         * @since 5.0.0
+         * @access public
+         * @var int
+         */
+        public $secondary_item_id = null;
+
+
+        /**
+         * Invite or request.
+         *
+         * @since 5.0.0
+         * @access public
+         * @var string
+         */
+        public $type;
+
+        /**
+         * Extra information provided by the requester or inviter.
+         *
+         * @since 5.0.0
+         * @access public
+         * @var string
+         */
+        public $content;
+
+        /**
+         * The date the invitation was last modified.
+         *
+         * @since 5.0.0
+         * @access public
+         * @var string
+         */
+        public $date_modified;
+
+        /**
+         * Has the invitation been sent, or is it a draft invite?
+         *
+         * @since 5.0.0
+         * @access public
+         * @var bool
+         */
+        public $invite_sent;
+
+        /**
+         * Has the invitation been accepted by the invitee?
+         *
+         * @since 5.0.0
+         * @access public
+         * @var bool
+         */
+        public $accepted;
+
+
+        /** Public Methods ****************************************************/
+
+        /**
+         * Constructor method.
+         *
+         * @since 5.0.0
+         *
+         * @param int $id Optional. Provide an ID to access an existing
+         *        invitation item.
+         */
+        public function __construct( $id = 0 ) {
+                if ( ! empty( $id ) ) {
+                        $this->id = (int) $id;
+                        $this->populate();
+                }
+        }
+
+        /**
+         * Update or insert invitation details into the database.
+         *
+         * @since 5.0.0
+         *
+         * @global wpdb $wpdb WordPress database object.
+         *
+         * @return bool True on success, false on failure.
+         */
+        public function save() {
+
+                // Return value
+                $retval = false;
+
+                // Default data and format
+                $data = array(
+                        'user_id'           => $this->user_id,
+                        'inviter_id'        => $this->inviter_id,
+                        'invitee_email'     => $this->invitee_email,
+                        'class'             => sanitize_key( $this->class ),
+                        'item_id'           => $this->item_id,
+                        'secondary_item_id' => $this->secondary_item_id,
+                        'type'              => $this->type,
+                        'content'           => $this->content,
+                        'date_modified'     => $this->date_modified,
+                        'invite_sent'       => $this->invite_sent,
+                        'accepted'          => $this->accepted,
+                );
+                $data_format = array( '%d', '%d', '%s', '%s', '%d', '%d', '%s', '%s', '%s', '%d', '%d' );
+
+                /**
+                 * Fires before an invitation is saved.
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param BP_Invitation object $this Characteristics of the invitation to be saved.
+                 */
+                do_action_ref_array( 'bp_invitation_before_save', array( &$this ) );
+
+                // Update
+                if ( ! empty( $this->id ) ) {
+                        $result = self::_update( $data, array( 'ID' => $this->id ), $data_format, array( '%d' ) );
+                // Insert
+                } else {
+                        $result = self::_insert( $data, $data_format );
+                }
+
+                // Set the invitation ID if successful
+                if ( ! empty( $result ) && ! is_wp_error( $result ) ) {
+                        global $wpdb;
+
+                        $this->id = $wpdb->insert_id;
+                        $retval   = $wpdb->insert_id;
+                }
+
+                /**
+                 * Fires after an invitation is saved.
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param BP_Invitation object $this Characteristics of the invitation just saved.
+                 */
+                do_action_ref_array( 'bp_invitation_after_save', array( &$this ) );
+
+                // Return the result
+                return $retval;
+        }
+
+        /**
+         * Fetch data for an existing invitation from the database.
+         *
+         * @since 5.0.0
+         *
+         * @global BuddyPress $bp The one true BuddyPress instance.
+         * @global wpdb $wpdb WordPress database object.
+         */
+        public function populate() {
+                global $wpdb;
+                $invites_table_name = BP_Invitation_Manager::get_table_name();
+
+                // Check cache for invitation data.
+                $invitation = wp_cache_get( $this->id, 'bp_invitations' );
+
+                // Cache missed, so query the DB.
+                if ( false === $invitation ) {
+                        $invitation = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM {$invites_table_name} WHERE id = %d", $this->id ) );
+                        wp_cache_set( $this->id, $invitation,'bp_invitations' );
+                }
+
+                // No invitation found so set the ID and bail.
+                if ( empty( $invitation ) || is_wp_error( $invitation ) ) {
+                        $this->id = 0;
+                        return;
+                }
+
+                $this->user_id           = (int) $invitation->user_id;
+                $this->inviter_id        = (int) $invitation->inviter_id;
+                $this->invitee_email     = $invitation->invitee_email;
+                $this->class             = sanitize_key( $invitation->class );
+                $this->item_id           = (int) $invitation->item_id;
+                $this->secondary_item_id = (int) $invitation->secondary_item_id;
+                $this->type              = $invitation->type;
+                $this->content           = $invitation->content;
+                $this->date_modified     = $invitation->date_modified;
+                $this->invite_sent       = (int) $invitation->invite_sent;
+                $this->accepted          = (int) $invitation->accepted;
+
+        }
+
+        /** Protected Static Methods ******************************************/
+
+        /**
+         * Create an invitation entry.
+         *
+         * @since 5.0.0
+         *
+         * @param array $data {
+         *     Array of invitation data, passed to {@link wpdb::insert()}.
+         *         @type int $user_id ID of the invited user.
+         *         @type int $inviter_id ID of the user who created the invitation.
+         *         @type string $invitee_email Email address of the invited user.
+         *         @type string $class Name of the related class.
+         *         @type int item_id ID associated with the invitation and component.
+         *         @type int secondary_item_id secondary ID associated with the
+         *                       invitation and component.
+         *         @type string content Extra information provided by the requester
+         *                       or inviter.
+         *         @type string date_modified Date the invitation was last modified.
+         *         @type int invite_sent Has the invitation been sent, or is it a
+         *                       draft invite?
+         * }
+         * @param array $data_format See {@link wpdb::insert()}.
+         * @return int|false The number of rows inserted, or false on error.
+         */
+        protected static function _insert( $data = array(), $data_format = array() ) {
+                global $wpdb;
+                return $wpdb->insert( BP_Invitation_Manager::get_table_name(), $data, $data_format );
+        }
+
+        /**
+         * Update invitations.
+         *
+         * @since 5.0.0
+         *
+         * @see wpdb::update() for further description of paramater formats.
+         *
+         * @param array $data Array of invitation data to update, passed to
+         *        {@link wpdb::update()}. Accepts any property of a
+         *        BP_Invitation object.
+         * @param array $where The WHERE params as passed to wpdb::update().
+         *        Typically consists of array( 'ID' => $id ) to specify the ID
+         *        of the item being updated. See {@link wpdb::update()}.
+         * @param array $data_format See {@link wpdb::insert()}.
+         * @param array $where_format See {@link wpdb::insert()}.
+         * @return int|false The number of rows updated, or false on error.
+         */
+        protected static function _update( $data = array(), $where = array(), $data_format = array(), $where_format = array() ) {
+                global $wpdb;
+                return $wpdb->update( BP_Invitation_Manager::get_table_name(), $data, $where, $data_format, $where_format );
+        }
+
+        /**
+         * Delete invitations.
+         *
+         * @since 5.0.0
+         *
+         * @see wpdb::update() for further description of paramater formats.
+         *
+         * @param array $where Array of WHERE clauses to filter by, passed to
+         *        {@link wpdb::delete()}. Accepts any property of a
+         *        BP_Invitation object.
+         * @param array $where_format See {@link wpdb::insert()}.
+         * @return int|false The number of rows updated, or false on error.
+         */
+        protected static function _delete( $where = array(), $where_format = array() ) {
+                global $wpdb;
+                return $wpdb->delete( BP_Invitation_Manager::get_table_name(), $where, $where_format );
+        }
+
+        /**
+         * Assemble the WHERE clause of a get() SQL statement.
+         *
+         * Used by BP_Invitation::get() to create its WHERE
+         * clause.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args See {@link BP_Invitation::get()}
+         *        for more details.
+         * @return string WHERE clause.
+         */
+        protected static function get_where_sql( $args = array() ) {
+                global $wpdb;
+
+                $where_conditions = array();
+                $where            = '';
+
+                // id
+                if ( ! empty( $args['id'] ) ) {
+                        $id_in = implode( ',', wp_parse_id_list( $args['id'] ) );
+                        $where_conditions['id'] = "id IN ({$id_in})";
+                }
+
+                // user_id
+                if ( ! empty( $args['user_id'] ) ) {
+                        $user_id_in = implode( ',', wp_parse_id_list( $args['user_id'] ) );
+                        $where_conditions['user_id'] = "user_id IN ({$user_id_in})";
+                }
+
+                // inviter_id. 0 can be meaningful, in the case of requests.
+                if ( ! empty( $args['inviter_id'] ) || 0 === $args['inviter_id'] ) {
+                        $inviter_id_in = implode( ',', wp_parse_id_list( $args['inviter_id'] ) );
+                        $where_conditions['inviter_id'] = "inviter_id IN ({$inviter_id_in})";
+                }
+
+                // invitee_email
+                if ( ! empty( $args['invitee_email'] ) ) {
+                        if ( ! is_array( $args['invitee_email'] ) ) {
+                                $invitee_emails = explode( ',', $args['invitee_email'] );
+                        } else {
+                                $invitee_emails = $args['invitee_email'];
+                        }
+
+                        $email_clean = array();
+                        foreach ( $invitee_emails as $email ) {
+                                $email_clean[] = $wpdb->prepare( '%s', $email );
+                        }
+
+                        $invitee_email_in = implode( ',', $email_clean );
+                        $where_conditions['invitee_email'] = "invitee_email IN ({$invitee_email_in})";
+                }
+
+                // class
+                if ( ! empty( $args['class'] ) ) {
+                        if ( ! is_array( $args['class'] ) ) {
+                                $class_names = explode( ',', $args['class'] );
+                        } else {
+                                $class_names = $args['class'];
+                        }
+
+                        $cn_clean = array();
+                        foreach ( $class_names as $cn ) {
+                                $cn_clean[] = $wpdb->prepare( '%s', sanitize_key( $cn ) );
+                        }
+
+                        $cn_in = implode( ',', $cn_clean );
+                        $where_conditions['class'] = "class IN ({$cn_in})";
+                }
+
+                // item_id
+                if ( ! empty( $args['item_id'] ) ) {
+                        $item_id_in = implode( ',', wp_parse_id_list( $args['item_id'] ) );
+                        $where_conditions['item_id'] = "item_id IN ({$item_id_in})";
+                }
+
+                // secondary_item_id
+                if ( ! empty( $args['secondary_item_id'] ) ) {
+                        $secondary_item_id_in = implode( ',', wp_parse_id_list( $args['secondary_item_id'] ) );
+                        $where_conditions['secondary_item_id'] = "secondary_item_id IN ({$secondary_item_id_in})";
+                }
+
+                // type
+                if ( ! empty( $args['type'] ) && 'all' !== $args['type'] ) {
+                        if ( 'invite' == $args['type'] || 'request' == $args['type'] ) {
+                                $type_clean = $wpdb->prepare( '%s', $args['type'] );
+                                $where_conditions['type'] = "type = {$type_clean}";
+                        }
+                }
+
+                // invite_sent
+                // Only create a where statement if something less than "all" has been
+                // specifically requested.
+                if ( ! empty( $args['invite_sent'] ) && 'all' !== $args['invite_sent'] ) {
+                        if ( $args['invite_sent'] == 'draft' ) {
+                                $where_conditions['invite_sent'] = "invite_sent = 0";
+                        } else if ( $args['invite_sent'] == 'sent' ) {
+                                $where_conditions['invite_sent'] = "invite_sent = 1";
+                        }
+                }
+
+                // accepted
+                if ( ! empty( $args['accepted'] ) && 'all' !== $args['accepted'] ) {
+                        if ( $args['accepted'] == 'pending' ) {
+                                $where_conditions['accepted'] = "accepted = 0";
+                        } else if ( $args['accepted'] == 'accepted' ) {
+                                $where_conditions['accepted'] = "accepted = 1";
+                        }
+                }
+
+                // search_terms
+                if ( ! empty( $args['search_terms'] ) ) {
+                        $search_terms_like = '%' . bp_esc_like( $args['search_terms'] ) . '%';
+                        $where_conditions['search_terms'] = $wpdb->prepare( "( class LIKE %s )", $search_terms_like, $search_terms_like );
+                }
+
+                // Custom WHERE
+                if ( ! empty( $where_conditions ) ) {
+                        $where = 'WHERE ' . implode( ' AND ', $where_conditions );
+                }
+
+                return $where;
+        }
+
+        /**
+         * Assemble the ORDER BY clause of a get() SQL statement.
+         *
+         * Used by BP_Invitation::get() to create its ORDER BY
+         * clause.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args See {@link BP_Invitation::get()}
+         *        for more details.
+         * @return string ORDER BY clause.
+         */
+        protected static function get_order_by_sql( $args = array() ) {
+
+                // Setup local variable
+                $conditions = array();
+                $retval     = '';
+
+                // Order by
+                if ( ! empty( $args['order_by'] ) ) {
+                        $order_by               = implode( ', ', (array) $args['order_by'] );
+                        $conditions['order_by'] = "{$order_by}";
+                }
+
+                // Sort order direction
+                if ( ! empty( $args['sort_order'] ) ) {
+                        $sort_order               = bp_esc_sql_order( $args['sort_order'] );
+                        $conditions['sort_order'] = "{$sort_order}";
+                }
+
+                // Custom ORDER BY
+                if ( ! empty( $conditions ) ) {
+                        $retval = 'ORDER BY ' . implode( ' ', $conditions );
+                }
+
+                return $retval;
+        }
+
+        /**
+         * Assemble the LIMIT clause of a get() SQL statement.
+         *
+         * Used by BP_Invitation::get() to create its LIMIT clause.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args See {@link BP_Invitation::get()}
+         *        for more details.
+         * @return string LIMIT clause.
+         */
+        protected static function get_paged_sql( $args = array() ) {
+                global $wpdb;
+
+                // Setup local variable
+                $retval = '';
+
+                // Custom LIMIT
+                if ( ! empty( $args['page'] ) && ! empty( $args['per_page'] ) ) {
+                        $page     = absint( $args['page']     );
+                        $per_page = absint( $args['per_page'] );
+                        $offset   = $per_page * ( $page - 1 );
+                        $retval   = $wpdb->prepare( "LIMIT %d, %d", $offset, $per_page );
+                }
+
+                return $retval;
+        }
+
+        /**
+         * Assemble query clauses, based on arguments, to pass to $wpdb methods.
+         *
+         * The insert(), update(), and delete() methods of {@link wpdb} expect
+         * arguments of the following forms:
+         *
+         * - associative arrays whose key/value pairs are column => value, to
+         *   be used in WHERE, SET, or VALUES clauses
+         * - arrays of "formats", which tell $wpdb->prepare() which type of
+         *   value to expect when sanitizing (eg, array( '%s', '%d' ))
+         *
+         * This utility method can be used to assemble both kinds of params,
+         * out of a single set of associative array arguments, such as:
+         *
+         *     $args = array(
+         *         'user_id' => 4,
+         *         'class'   => 'BP_Groups_Invitation_Manager',
+         *     );
+         *
+         * This will be converted to:
+         *
+         *     array(
+         *         'data' => array(
+         *             'user_id' => 4,
+         *             'class'   => 'BP_Groups_Invitation_Manager',
+         *         ),
+         *         'format' => array(
+         *             '%d',
+         *             '%s',
+         *         ),
+         *     )
+         *
+         * which can easily be passed as arguments to the $wpdb methods.
+         *
+         * @since 5.0.0
+         *
+         * @param $args Associative array of filter arguments.
+         *        See {@BP_Invitation::get()} for a breakdown.
+         * @return array Associative array of 'data' and 'format' args.
+         */
+        protected static function get_query_clauses( $args = array() ) {
+                $where_clauses = array(
+                        'data'   => array(),
+                        'format' => array(),
+                );
+
+                // id
+                if ( ! empty( $args['id'] ) ) {
+                        $where_clauses['data']['id'] = absint( $args['id'] );
+                        $where_clauses['format'][] = '%d';
+                }
+
+                // user_id
+                if ( ! empty( $args['user_id'] ) ) {
+                        $where_clauses['data']['user_id'] = absint( $args['user_id'] );
+                        $where_clauses['format'][] = '%d';
+                }
+
+                // inviter_id
+                if ( ! empty( $args['inviter_id'] ) ) {
+                        $where_clauses['data']['inviter_id'] = absint( $args['inviter_id'] );
+                        $where_clauses['format'][] = '%d';
+                }
+
+                // invitee_email
+                if ( ! empty( $args['invitee_email'] ) ) {
+                        $where_clauses['data']['invitee_email'] = $args['invitee_email'];
+                        $where_clauses['format'][] = '%s';
+                }
+
+                // class
+                if ( ! empty( $args['class'] ) ) {
+                        $where_clauses['data']['class'] = $args['class'];
+                        $where_clauses['format'][] = '%s';
+                }
+
+                // item_id
+                if ( ! empty( $args['item_id'] ) ) {
+                        $where_clauses['data']['item_id'] = absint( $args['item_id'] );
+                        $where_clauses['format'][] = '%d';
+                }
+
+                // secondary_item_id
+                if ( ! empty( $args['secondary_item_id'] ) ) {
+                        $where_clauses['data']['secondary_item_id'] = absint( $args['secondary_item_id'] );
+                        $where_clauses['format'][] = '%d';
+                }
+
+                // type
+                if ( ! empty( $args['type'] ) && 'all' !== $args['type'] ) {
+                        if ( 'invite' == $args['type'] || 'request' == $args['type'] ) {
+                                $where_clauses['data']['type'] = $args['type'];
+                                $where_clauses['format'][] = '%s';
+                        }
+                }
+
+                // invite_sent
+                // Only create a where statement if something less than "all" has been
+                // specifically requested.
+                if ( isset( $args['invite_sent'] ) && 'all' !== $args['invite_sent'] ) {
+                        if ( $args['invite_sent'] == 'draft' ) {
+                                $where_clauses['data']['invite_sent'] = 0;
+                                $where_clauses['format'][] = '%d';
+                        } else if ( $args['invite_sent'] == 'sent' ) {
+                                $where_clauses['data']['invite_sent'] = 1;
+                                $where_clauses['format'][] = '%d';
+                        }
+                }
+
+                // accepted
+                if ( ! empty( $args['accepted'] ) && 'all' !== $args['accepted'] ) {
+                        if ( $args['accepted'] == 'pending' ) {
+                                $where_clauses['data']['accepted'] = 0;
+                                $where_clauses['format'][] = '%d';
+                        } else if ( $args['accepted'] == 'accepted' ) {
+                                $where_clauses['data']['accepted'] = 1;
+                                $where_clauses['format'][] = '%d';
+                        }
+                }
+
+                return $where_clauses;
+        }
+
+        /** Public Static Methods *********************************************/
+
+        /**
+         * Get invitations, based on provided filter parameters.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args {
+         *     Associative array of arguments. All arguments but $page and
+         *     $per_page can be treated as filter values for get_where_sql()
+         *     and get_query_clauses(). All items are optional.
+         *     @type int|array    $id                ID of invitation being updated.
+         *                                           Can be an array of IDs.
+         *     @type int|array    $user_id           ID of user being queried. Can be an
+         *                                           Can be an array of IDs.
+         *     @type int|array    $inviter_id        ID of user who created the
+         *                                           invitation. Can be an array of IDs.
+         *     @type string|array $invitee_email     Email address of invited users
+         *                                                       being queried. Can be an array of
+         *                                           addresses.
+         *     @type string|array $class             Name of the class to filter by.
+         *                                           Can be an array of class names.
+         *     @type int|array    $item_id           ID of associated item.
+         *                                           Can be an array of multiple item IDs.
+         *     @type int|array    $secondary_item_id ID of secondary associated item.
+         *                                           Can be an array of multiple IDs.
+         *     @type string|array $type              Type of item. An "invite" is sent
+         *                                           from one user to another.
+         *                                           A "request" is submitted by a
+         *                                           user and no inviter is required.
+         *                                           'all' returns all. Default: 'all'.
+         *     @type string       $invite_sent       Limit to draft, sent or all
+         *                                           'draft' limits to unsent invites,
+         *                                           'sent' returns only sent invites,
+         *                                           'all' returns all. Default: 'all'.
+         *     @type bool         $accepted          Limit to accepted or
+         *                                           not-yet-accepted invitations.
+         *                                           'accepted' returns accepted invites,
+         *                                           'pending' returns pending invites,
+         *                                           'all' returns all. Default: 'pending'
+         *     @type string       $search_terms      Term to match against class field.
+         *     @type string       $order_by          Database column to order by.
+         *     @type string       $sort_order        Either 'ASC' or 'DESC'.
+         *     @type string       $order_by          Field to order results by.
+         *     @type string       $sort_order        ASC or DESC.
+         *     @type int          $page              Number of the current page of results.
+         *                                           Default: false (no pagination,
+         *                                           all items).
+         *     @type int          $per_page          Number of items to show per page.
+         *                                           Default: false (no pagination,
+         *                                           all items).
+         *     @type string       $fields            Which fields to return. Specify 'item_ids' to fetch a list of Item_IDs.
+         *                                           Specify 'ids' to fetch a list of Invitation IDs.
+         *                                           Default: 'all' (return BP_Invitation objects).
+         * }
+         *
+         * @return array BP_Invitation objects | IDs of found invit.
+         */
+        public static function get( $args = array() ) {
+                global $wpdb;
+                $invites_table_name = BP_Invitation_Manager::get_table_name();
+
+                // Parse the arguments
+                $r  = bp_parse_args( $args, array(
+                        'id'                => false,
+                        'user_id'           => false,
+                        'inviter_id'        => false,
+                        'invitee_email'     => false,
+                        'class'             => false,
+                        'item_id'           => false,
+                        'secondary_item_id' => false,
+                        'type'              => 'all',
+                        'invite_sent'       => 'all',
+                        'accepted'          => 'pending',
+                        'search_terms'      => '',
+                        'order_by'          => false,
+                        'sort_order'        => false,
+                        'page'              => false,
+                        'per_page'          => false,
+                        'fields'            => 'all',
+                ), 'bp_invitations_invitation_get' );
+
+                $sql = array(
+                        'select'     => "SELECT",
+                        'fields'     => '',
+                        'from'       => "FROM {$invites_table_name} i",
+                        'where'      => '',
+                        'orderby'    => '',
+                        'pagination' => '',
+                );
+
+                if ( 'item_ids' === $r['fields'] ) {
+                        $sql['fields'] = "DISTINCT i.item_id";
+                } else if ( 'user_ids' === $r['fields'] ) {
+                        $sql['fields'] = "DISTINCT i.user_id";
+                } else {
+                        $sql['fields'] = 'DISTINCT i.id';
+                }
+
+                // WHERE
+                $sql['where'] = self::get_where_sql( array(
+                        'id'                => $r['id'],
+                        'user_id'           => $r['user_id'],
+                        'inviter_id'            => $r['inviter_id'],
+                        'invitee_email'     => $r['invitee_email'],
+                        'class'             => $r['class'],
+                        'item_id'           => $r['item_id'],
+                        'secondary_item_id' => $r['secondary_item_id'],
+                        'type'              => $r['type'],
+                        'invite_sent'       => $r['invite_sent'],
+                        'accepted'          => $r['accepted'],
+                        'search_terms'      => $r['search_terms'],
+                ) );
+
+                // ORDER BY
+                $sql['orderby'] = self::get_order_by_sql( array(
+                        'order_by'   => $r['order_by'],
+                        'sort_order' => $r['sort_order']
+                ) );
+
+                // LIMIT %d, %d
+                $sql['pagination'] = self::get_paged_sql( array(
+                        'page'     => $r['page'],
+                        'per_page' => $r['per_page'],
+                ) );
+
+                $paged_invites_sql = "{$sql['select']} {$sql['fields']} {$sql['from']} {$sql['where']} {$sql['orderby']} {$sql['pagination']}";
+
+                /**
+                 * Filters the pagination SQL statement.
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param string $value Concatenated SQL statement.
+                 * @param array  $sql   Array of SQL parts before concatenation.
+                 * @param array  $r     Array of parsed arguments for the get method.
+                 */
+                $paged_invites_sql = apply_filters( 'bp_invitations_get_paged_invitations_sql', $paged_invites_sql, $sql, $r );
+
+                $cached = bp_core_get_incremented_cache( $paged_invites_sql, 'bp_invitations' );
+                if ( false === $cached ) {
+                        $paged_invite_ids = $wpdb->get_col( $paged_invites_sql );
+                        bp_core_set_incremented_cache( $paged_invites_sql, 'bp_invitations', $paged_invite_ids );
+                } else {
+                        $paged_invite_ids = $cached;
+                }
+
+                // Special return format cases.
+                if ( 'ids' === $r['fields'] || 'item_ids' === $r['fields'] || 'user_ids' === $r['fields'] ) {
+                        // We only want the field that was found.
+                        return array_map( 'intval', $paged_invite_ids );
+                }
+
+                $uncached_ids = bp_get_non_cached_ids( $paged_invite_ids, 'bp_invitations' );
+                if ( $uncached_ids ) {
+                        $ids_sql = implode( ',', array_map( 'intval', $uncached_ids ) );
+                        $data_objects = $wpdb->get_results( "SELECT i.* FROM {$invites_table_name} i WHERE i.id IN ({$ids_sql})" );
+                        foreach ( $data_objects as $data_object ) {
+                                wp_cache_set( $data_object->id, $data_object, 'bp_invitations' );
+                        }
+                }
+
+                $paged_invites = array();
+                foreach ( $paged_invite_ids as $paged_invite_id ) {
+                        $paged_invites[] = new BP_Invitation( $paged_invite_id );
+                }
+
+                return $paged_invites;
+        }
+
+        /**
+         * Get a count of total invitations matching a set of arguments.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of
+         *      arguments.
+         *
+         * @param array $args See {@link BP_Invitation::get()}.
+         * @return int Count of located items.
+         */
+        public static function get_total_count( $args ) {
+                global $wpdb;
+                $invites_table_name = BP_Invitation_Manager::get_table_name();
+
+                // Build the query
+                $select_sql = "SELECT COUNT(*)";
+                $from_sql   = "FROM {$invites_table_name}";
+                $where_sql  = self::get_where_sql( $args );
+                $sql        = "{$select_sql} {$from_sql} {$where_sql}";
+
+                // Return the queried results
+                return $wpdb->get_var( $sql );
+        }
+
+        /**
+         * Update invitations.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of
+         *      accepted update/where arguments.
+         *
+         * @param array $update_args Associative array of fields to update,
+         *        and the values to update them to. Of the format
+         *            array( 'user_id' => 4, 'class' => 'BP_Groups_Invitation_Manager', )
+         * @param array $where_args Associative array of columns/values, to
+         *        determine which rows should be updated. Of the format
+         *            array( 'item_id' => 7, 'class' => 'BP_Groups_Invitation_Manager', )
+         * @return int|bool Number of rows updated on success, false on failure.
+         */
+        public static function update( $update_args = array(), $where_args = array() ) {
+                $update = self::get_query_clauses( $update_args );
+                $where  = self::get_query_clauses( $where_args  );
+
+                /**
+                 * Fires before an invitation is updated.
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param array $where_args  Associative array of columns/values describing
+                 *                           invitations about to be deleted.
+                 * @param array $update_args Array of new values.
+                 */
+                do_action( 'bp_invitation_before_update', $where_args, $update_args );
+
+                $retval = self::_update( $update['data'], $where['data'], $update['format'], $where['format'] );
+
+                return $retval;
+        }
+
+        /**
+         * Delete invitations.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::get() for a description of
+         *      accepted where arguments.
+         *
+         * @param array $args Associative array of columns/values, to determine
+         *        which rows should be deleted.  Of the format
+         *            array( 'item_id' => 7, 'class' => 'BP_Groups_Invitation_Manager', )
+         * @return int|bool Number of rows deleted on success, false on failure.
+         */
+        public static function delete( $args = array() ) {
+                $where = self::get_query_clauses( $args );
+
+                /**
+                 * Fires before an invitation is deleted.
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param array $args Characteristics of the invitations to be deleted.
+                 */
+                do_action( 'bp_invitation_before_delete', $args );
+
+                $retval = self::_delete( $where['data'], $where['format'] );
+
+                /**
+                 * Fires after an invitation is deleted.
+                 *
+                 * @since 5.0.0
+                 *
+                 * @param array $args Characteristics of the invitations just deleted.
+                 */
+                do_action( 'bp_invitation_after_delete', $args );
+
+                return $retval;
+        }
+
+        /** Convenience methods ***********************************************/
+
+        /**
+         * Delete a single invitation by ID.
+         *
+         * @since 5.0.0
+         *
+         * @see BP_Invitation::delete() for explanation of
+         *      return value.
+         *
+         * @param int $id ID of the invitation item to be deleted.
+         * @return bool True on success, false on failure.
+         */
+        public static function delete_by_id( $id ) {
+                return self::delete( array(
+                        'id' => $id,
+                ) );
+        }
+
+        /** Sent status ***********************************************************/
+
+        /**
+         * Mark specific invitations as sent by invitation ID.
+         *
+         * @since 5.0.0
+         *
+         * @param int $id The ID of the invitation to mark as sent.
+         */
+        public static function mark_sent( $id = 0 ) {
+
+                if ( ! $id ) {
+                        return false;
+                }
+
+                // Values to be updated
+                $update_args = array(
+                        'invite_sent' => 'sent',
+                );
+
+                // WHERE clauses
+                $where_args = array(
+                        'id' => $id,
+                );
+
+                return self::update( $update_args, $where_args );
+        }
+
+        /**
+         * Mark invitations as sent that are found by user_id, inviter_id, item id, and optional
+         * secondary item id, and class name.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args See BP_Invitation::update().
+         */
+        public static function mark_sent_by_data( $args ) {
+
+                // Values to be updated
+                $update_args = array(
+                        'invite_sent' => 'sent',
+                );
+
+                return self::update( $update_args, $args );
+        }
+
+        /** Accepted status ***********************************************************/
+
+        /**
+         * Mark specific invitations as accepted by invitation ID.
+         *
+         * @since 5.0.0
+         *
+         * @param int $id The ID of the invitation to mark as sent.
+         */
+        public static function mark_accepted( $id = 0 ) {
+
+                if ( ! $id ) {
+                        return false;
+                }
+
+                // Values to be updated
+                $update_args = array(
+                        'accepted' => 'accepted',
+                );
+
+                // WHERE clauses
+                $where_args = array(
+                        'id' => $id,
+                );
+
+                return self::update( $update_args, $where_args );
+        }
+
+        /**
+         * Mark invitations as accepted that are found by user_id, inviter_id,
+         * item id, and optional secondary item id, and class name.
+         *
+         * @since 5.0.0
+         *
+         * @param array $args See BP_Invitation::update().
+         */
+        public static function mark_accepted_by_data( $args ) {
+
+                // Values to be updated
+                $update_args = array(
+                        'accepted' => 'accepted',
+                );
+
+                return self::update( $update_args, $args );
+        }
+
+}

src/bp-groups/actions/leave-group.php

@@ -58 +58 @@
         /** This filter is documented in bp-groups/bp-groups-actions.php */
         bp_core_load_template( apply_filters( 'groups_template_group_home', 'groups/single/home' ) );
 }
-add_action( 'bp_actions', 'groups_action_leave_group' );
- No newline at end of file
+add_action( 'bp_actions', 'groups_action_leave_group' );
+
+/**
+ * Clean up requests/invites when a member leaves a group.
+ *
+ * @since 5.0.0
+ */
+function groups_action_clean_up_invites_requests( $user_id, $group_id ) {
+        $invites_class = new BP_Groups_Invitation_Manager();
+        // Remove invitations/requests where the deleted user is the receiver.
+        $invites_class->delete( array(
+                'user_id' => $user_id,
+                'item_id' => $group_id,
+                'type'    => 'all'
+        ) );
+        // Remove invitations where the deleted user is the sender.
+        $invites_class->delete( array(
+                'inviter_id' => $user_id,
+                'item_id'    => $group_id,
+        ) );
+}
+add_action( 'bp_groups_member_after_delete', 'groups_action_clean_up_invites_requests', 10, 2 );

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 saving a group invitation or request.
+ * The save action is called when inserting a new record or using the save() method
+ * to update an existing record.
+ *
+ * @since 5.0.0
+ *
+ * @param BP_Invitation object $invitation Characteristics of the invitation just saved.
+ */
+function bp_groups_clear_user_group_cache_on_invitation_save( BP_Invitation $invitation ) {
+        if ( sanitize_key( 'BP_Groups_Invitation_Manager' ) !== $invitation->class ) {
+                return;
+        }
+
+        wp_cache_delete( $invitation->id, 'bp_groups_invitations_as_memberships' );
+}
+add_action( 'bp_invitation_after_save', 'bp_groups_clear_user_group_cache_on_invitation_save', 10, 2 );
+
+/**
+ * Clear caches on invitation deletion or update.
+ * This also catches changes like sending an invite or marking one as accepted.
+ *
+ * @since 5.0.0
+ *
+ * @param array $args Associative array of columns/values describing invitations about to be deleted.
+ */
+function bp_groups_clear_user_group_cache_on_invitation_change( $args ) {
+        // Will the delete request act on invitations?
+        if ( empty( $args['class'] ) || 'BP_Groups_Invitation_Manager' !== $args['class'] ) {
+                return;
+        }
+
+        $args['fields' ] = 'ids';
+        $affected_invitation_ids = groups_get_invites( $args );
+        foreach ( $affected_invitation_ids as $invitation_id ) {
+                wp_cache_delete( $invitation_id, 'bp_groups_invitations_as_memberships' );
+        }
+}
+add_action( 'bp_invitation_before_delete', 'bp_groups_clear_user_group_cache_on_invitation_change' );
+add_action( 'bp_invitation_before_update', 'bp_groups_clear_user_group_cache_on_invitation_change' );
+
 /**
  * Clear group memberships cache on miscellaneous actions not covered by the 'after_save' hook.
  *
@@ -269 +310 @@
         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

@@ -949 +949 @@
 
         $user_id = intval( $user_id );
 
+        // Standard memberships
         $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 );
@@ -965 +966 @@
                 }
         }
 
+        // Prime the invitations- and requests-as-memberships cache
+        $invitation_ids = array();
+        if ( true !== $r['is_confirmed'] || false !== $r['invite_sent'] ) {
+                $invitation_ids = groups_get_invites( array(
+                        'user_id'     => $user_id,
+                        'invite_sent' => 'all',
+                        'type'        => 'all',
+                        'fields'      => 'ids'
+                ) );
+
+                // Prime the invitations cache.
+                $uncached_invitation_ids = bp_get_non_cached_ids( $invitation_ids, 'bp_groups_invitations_as_memberships' );
+
+                $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( $uncached_invitation->id, $invitation, 'bp_groups_invitations_as_memberships' );
+                }
+
+        }
+
+
         // Assemble filter array for use in `wp_list_filter()`.
         $filters = wp_array_slice_assoc( $r, array( 'is_confirmed', 'is_banned', 'is_admin', 'is_mod', 'invite_sent' ) );
         foreach ( $filters as $filter_name => $filter_value ) {
@@ -1006 +1046 @@
                 $groups[ $group_id ] = $membership;
         }
 
+        // Populate group invitations array from cache, and normalize.
+        foreach ( $invitation_ids as $invitation_id ) {
+                $invitation = wp_cache_get( $invitation_id, 'bp_groups_invitations_as_memberships' );
+
+                // Sanity check.
+                if ( ! isset( $invitation->group_id ) ) {
+                        continue;
+                }
+
+                // Integer values.
+                foreach ( $int_keys as $index ) {
+                        $invitation->{$index} = intval( $invitation->{$index} );
+                }
+
+                // Boolean values.
+                foreach ( $bool_keys as $index ) {
+                        $invitation->{$index} = (bool) $invitation->{$index};
+                }
+
+                foreach ( $filters as $filter_name => $filter_value ) {
+                        if ( ! isset( $invitation->{$filter_name} ) || $filter_value != $invitation->{$filter_name} ) {
+                                continue 2;
+                        }
+                }
+
+                $group_id = (int) $invitation->group_id;
+
+                $groups[ $group_id ] = $invitation;
+        }
+
         // By default, results are ordered by membership id.
         if ( 'group_id' === $r['orderby'] ) {
                 ksort( $groups );
@@ -1209 +1279 @@
  * Check whether a user has an outstanding invitation to a group.
  *
  * @since 2.6.0
+ * @since 5.0.0 Added $type parameter.
  *
- * @param int $user_id ID of the user.
- * @param int $group_id ID of the group.
+ * @param int    $user_id  ID of the user.
+ * @param int    $group_id ID of the group.
+ * @param string $type     If 'sent', results are limited to those invitations
+ *                         that have actually been sent (non-draft).
+ *                         Possible values: 'sent', 'draft', or 'all' Default: 'sent'.
  * @return int|bool ID of the membership if the user is invited, otherwise false.
  */
-function groups_is_user_invited( $user_id, $group_id ) {
-        $is_invited = false;
-
-        $user_groups = bp_get_user_groups( $user_id, array(
-                'invite_sent' => true,
-                'is_confirmed' => false,
-        ) );
-
-        if ( isset( $user_groups[ $group_id ] ) ) {
-                $is_invited = $user_groups[ $group_id ]->id;
-        }
-
-        return $is_invited;
+function groups_is_user_invited( $user_id, $group_id, $type = 'sent' ) {
+        return groups_check_has_invite_from_user( $user_id, $group_id, false, $type );
 }
 
 /**
@@ -1239 +1302 @@
  * @return int|bool ID of the membership if the user is pending, otherwise false.
  */
 function groups_is_user_pending( $user_id, $group_id ) {
-        $is_pending = false;
-
-        $user_groups = bp_get_user_groups( $user_id, array(
-                'invite_sent' => false,
-                'is_confirmed' => false,
-        ) );
-
-        if ( isset( $user_groups[ $group_id ] ) ) {
-                $is_pending = $user_groups[ $group_id ]->id;
+        if ( empty( $user_id ) || empty( $group_id ) ) {
+                return false;
         }
 
-        return $is_pending;
+        $args = array(
+                'user_id'     => $user_id,
+                'item_id'     => $group_id,
+        );
+        $invites_class = new BP_Groups_Invitation_Manager();
+
+        return $invites_class->request_exists( $args );
 }
 
 /**
@@ -1362 +1424 @@
 /** Group Invitations *********************************************************/
 
 /**
- * Get IDs of users with outstanding invites to a given group from a specified user.
+ * Get group objects for groups that a user is currently invited to.
  *
  * @since 1.0.0
  *
- * @param int               $user_id ID of the inviting user.
+ * @param int               $user_id ID of the invited user.
  * @param int|bool          $limit   Limit to restrict to.
  * @param int|bool          $page    Optional. Page offset of results to return.
  * @param string|array|bool $exclude Array of comma-separated list of group IDs
  *                                   to exclude from results.
- * @return array $value IDs of users who have been invited to the group by the
- *                      user but have not yet accepted.
+ * @return array {
+ *     @type array $groups Array of groups returned by paginated query.
+ *     @type int   $total  Count of groups matching query.
+ * }
  */
 function groups_get_invites_for_user( $user_id = 0, $limit = false, $page = false, $exclude = false ) {
-
-        if ( empty( $user_id ) )
+        if ( empty( $user_id ) ) {
                 $user_id = bp_loggedin_user_id();
+        }
+
+        $group_ids = groups_get_invited_to_group_ids( $user_id );
+
+        // Remove excluded groups.
+        if ( $exclude ) {
+                $group_ids = array_diff( $group_ids, wp_parse_id_list( $exclude ) );
+        }
+
+        // Avoid passing an empty array.
+        if ( ! $group_ids ) {
+                $group_ids = array( 0 );
+        }
+
+        // Get a filtered list of groups.
+        $args = array(
+                'include'     => $group_ids,
+                'show_hidden' => true,
+                'per_page'    => $limit,
+                'page'        => $page,
+        );
+        $groups = groups_get_groups( $args );
 
-        return BP_Groups_Member::get_invites( $user_id, $limit, $page, $exclude );
+        return array( 'groups' => $groups['groups'], 'total' => groups_get_invite_count_for_user( $user_id ) );
 }
 
 /**
@@ -1395 +1480 @@
                 $user_id = bp_loggedin_user_id();
         }
 
-        return BP_Groups_Member::get_invite_count_for_user( $user_id );
+        return count( groups_get_invited_to_group_ids( $user_id ) );
+}
+
+/**
+ * Get an array of group IDs to which a user is invited.
+ *
+ * @since 5.0.0
+ *
+ * @param int $user_id The user ID.
+ *
+ * @return array Array of group IDs.
+ */
+ function groups_get_invited_to_group_ids( $user_id = 0 ) {
+        if ( empty( $user_id ) ) {
+                $user_id = bp_loggedin_user_id();
+        }
+
+        $group_ids = groups_get_invites( array(
+                'user_id'     => $user_id,
+                'invite_sent' => 'sent',
+                'fields'      => 'item_ids'
+        ) );
+
+        return array_unique( $group_ids );
 }
 
 /**
@@ -1411 +1519 @@
  *                                 ID of the logged-in user.
  *     @type string $date_modified Optional. Modified date for the invitation.
  *                                 Default: current date/time.
- *     @type bool   $is_confirmed  Optional. Whether the invitation should be
- *                                 marked confirmed. Default: false.
+ *     @type string $content       Optional. Message to invitee.
+ *     @type bool   $send_invite   Optional. Whether the invitation should be
+ *                                 sent now. Default: false.
  * }
  * @return bool True on success, false on failure.
  */
 function groups_invite_user( $args = '' ) {
 
-        $args = bp_parse_args( $args, array(
+        $r = bp_parse_args( $args, array(
                 'user_id'       => false,
                 'group_id'      => false,
                 'inviter_id'    => bp_loggedin_user_id(),
                 'date_modified' => bp_core_current_time(),
-                'is_confirmed'  => 0
+                'content'       => '',
+                'send_invite'   => 0
         ), 'groups_invite_user' );
-        extract( $args, EXTR_SKIP );
 
-        if ( ! $user_id || ! $group_id || ! $inviter_id ) {
-                return false;
-        }
-
-        // If the user has already requested membership, accept the request.
-        if ( $membership_id = groups_check_for_membership_request( $user_id, $group_id ) ) {
-                groups_accept_membership_request( $membership_id, $user_id, $group_id );
+        $inv_args = array(
+                'user_id'       => $r['user_id'],
+                'item_id'       => $r['group_id'],
+                'inviter_id'    => $r['inviter_id'],
+                'date_modified' => $r['date_modified'],
+                'content'       => $r['content'],
+                'send_invite'   => $r['send_invite']
+        );
 
-        // Otherwise, create a new invitation.
-        } elseif ( ! groups_is_user_member( $user_id, $group_id ) && ! groups_check_user_has_invite( $user_id, $group_id, 'all' ) ) {
-                $invite                = new BP_Groups_Member;
-                $invite->group_id      = $group_id;
-                $invite->user_id       = $user_id;
-                $invite->date_modified = $date_modified;
-                $invite->inviter_id    = $inviter_id;
-                $invite->is_confirmed  = $is_confirmed;
+        // Create the unsent invitataion.
+        $invites_class = new BP_Groups_Invitation_Manager();
+        $created       = $invites_class->add_invitation( $inv_args );
 
-                if ( !$invite->save() )
-                        return false;
-
-                /**
-                 * Fires after the creation of a new group invite.
-                 *
-                 * @since 1.0.0
-                 *
-                 * @param array $args Array of parsed arguments for the group invite.
-                 */
-                do_action( 'groups_invite_user', $args );
-        }
+        /**
+         * Fires after the creation of a new group invite.
+         *
+         * @since 1.0.0
+         *
+         * @param array    $r       Array of parsed arguments for the group invite.
+         * @param int|bool $created The ID of the invitation or false if it couldn't be created.
+         */
+        do_action( 'groups_invite_user', $r, $created );
 
-        return true;
+        return $created;
 }
 
 /**
  * Uninvite a user from a group.
  *
- * Functionally, this is equivalent to removing a user from a group.
- *
  * @since 1.0.0
  *
  * @param int $user_id  ID of the user.
  * @param int $group_id ID of the group.
+ * @param int $inviter_id ID of the inviter.
  * @return bool True on success, false on failure.
  */
-function groups_uninvite_user( $user_id, $group_id ) {
-
-        if ( ! BP_Groups_Member::delete_invite( $user_id, $group_id ) )
+function groups_uninvite_user( $user_id, $group_id, $inviter_id = false ) {
+        if ( empty( $user_id ) || empty( $group_id ) ) {
                 return false;
+        }
 
-        /**
-         * Fires after uninviting a user from a group.
-         *
-         * @since 1.0.0
-         *
-         * @param int $group_id ID of the group being uninvited from.
-         * @param int $user_id  ID of the user being uninvited.
-         */
-        do_action( 'groups_uninvite_user', $group_id, $user_id );
+        $invites_class = new BP_Groups_Invitation_Manager();
+        $success       = $invites_class->delete( array(
+                'user_id'    => $user_id,
+                'item_id'    => $group_id,
+                'inviter_id' => $inviter_id,
+        ) );
 
-        return true;
+        if ( $success ) {
+                /**
+                 * Fires after uninviting a user from a group.
+                 *
+                 * @since 1.0.0
+                 * @since 2.7.0 Added $inviter_id parameter
+                 *
+                 * @param int $group_id    ID of the group being uninvited from.
+                 * @param int $user_id     ID of the user being uninvited.
+                 * @param int $inviter_id  ID of the inviter.
+                 */
+                do_action( 'groups_uninvite_user', $group_id, $user_id, $inviter_id );
+        }
+
+        return $success;
 }
 
 /**
@@ -1501 +1613 @@
  * @return bool True when the user is a member of the group, otherwise false.
  */
 function groups_accept_invite( $user_id, $group_id ) {
+        $invites_class = new BP_Groups_Invitation_Manager();
+        $args = array(
+                'user_id'     => $user_id,
+                'item_id'     => $group_id,
+                'invite_sent' => 'sent',
+        );
 
-        // If the user is already a member (because BP at one point allowed two invitations to
-        // slip through), delete all existing invitations/requests and return true.
-        if ( groups_is_user_member( $user_id, $group_id ) ) {
-                if ( groups_check_user_has_invite( $user_id, $group_id ) ) {
-                        groups_delete_invite( $user_id, $group_id );
-                }
-
-                if ( groups_check_for_membership_request( $user_id, $group_id ) ) {
-                        groups_delete_membership_request( null, $user_id, $group_id );
-                }
-
-                return true;
-        }
-
-        $member = new BP_Groups_Member( $user_id, $group_id );
-
-        // Save the inviter ID so that we can pass it to the action below.
-        $inviter_id = $member->inviter_id;
-
-        $member->accept_invite();
-
-        if ( !$member->save() ) {
-                return false;
-        }
-
-        // Remove request to join.
-        if ( $member->check_for_membership_request( $user_id, $group_id ) ) {
-                $member->delete_request( $user_id, $group_id );
-        }
-
-        // Modify group meta.
-        groups_update_groupmeta( $group_id, 'last_activity', bp_core_current_time() );
-
-        /**
-         * 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', $user_id, $group_id, $inviter_id );
-
-        return true;
+        return $invites_class->accept_invitation( $args );
 }
 
 /**
  * Reject a group invitation.
  *
  * @since 1.0.0
+ * @since 5.0.0 The $inviter_id arg was added.
+ *
+ * @param int $user_id    ID of the user.
+ * @param int $group_id   ID of the group.
+ * @param int $inviter_id ID of the inviter.
  *
- * @param int $user_id  ID of the user.
- * @param int $group_id ID of the group.
  * @return bool True on success, false on failure.
  */
-function groups_reject_invite( $user_id, $group_id ) {
-        if ( ! BP_Groups_Member::delete_invite( $user_id, $group_id ) )
+function groups_reject_invite( $user_id, $group_id, $inviter_id = false ) {
+        if ( empty( $user_id ) || empty( $group_id ) ) {
                 return false;
+        }
+
+        $invites_class = new BP_Groups_Invitation_Manager();
+        $success       = $invites_class->delete( array(
+                'user_id'    => $user_id,
+                'item_id'    => $group_id,
+                'inviter_id' => $inviter_id,
+        ) );
 
         /**
          * Fires after a user rejects a group invitation.
          *
          * @since 1.0.0
+         * @since 5.0.0 The $inviter_id arg was added.
          *
          * @param int $user_id  ID of the user rejecting the invite.
          * @param int $group_id ID of the group being rejected.
+         * @param int $inviter_id ID of the inviter.
          */
-        do_action( 'groups_reject_invite', $user_id, $group_id );
+        do_action( 'groups_reject_invite', $user_id, $group_id, $inviter_id );
 
-        return true;
+        return $success;
 }
 
 /**
  * Delete a group invitation.
  *
  * @since 1.0.0
+ * @since 5.0.0 The $inviter_id arg was added.
  *
  * @param int $user_id  ID of the invited user.
  * @param int $group_id ID of the group.
+ * @param int $inviter_id ID of the inviter.
+ *
  * @return bool True on success, false on failure.
  */
-function groups_delete_invite( $user_id, $group_id ) {
-        if ( ! BP_Groups_Member::delete_invite( $user_id, $group_id ) )
+function groups_delete_invite( $user_id, $group_id, $inviter_id = false ) {
+        if ( empty( $user_id ) || empty( $group_id ) ) {
                 return false;
+        }
+
+        $invites_class = new BP_Groups_Invitation_Manager();
+        $success       = $invites_class->delete( array(
+                'user_id'    => $user_id,
+                'item_id'    => $group_id,
+                'inviter_id' => $inviter_id,
+        ) );
 
         /**
          * Fires after the deletion of a group invitation.
          *
          * @since 1.9.0
+         * @since 5.0.0 The $inviter_id arg was added.
          *
          * @param int $user_id  ID of the user whose invitation is being deleted.
          * @param int $group_id ID of the group whose invitation is being deleted.
+         * @param int $inviter_id ID of the inviter.
          */
-        do_action( 'groups_delete_invite', $user_id, $group_id );
+        do_action( 'groups_delete_invite', $user_id, $group_id, $inviter_id );
 
         return true;
 }
 
 /**
- * Send all pending invites by a single user to a specific group.
+ * Send some or all pending invites by a single user to a specific group.
  *
  * @since 1.0.0
+ * @since 5.0.0 Parameters changed to associative array.
  *
- * @param int $user_id  ID of the inviting user.
- * @param int $group_id ID of the group.
+ * @param array $args {
+ *     An array of optional arguments.
+ *     @type int    $user_id       ID of the invited user.
+ *     @type string $invitee_email Email address of the invited user, if not a member of the site.
+ *     @type string $group_id      ID of the group or an array of group IDs.
+ *     @type string $inviter_id    ID of the user extending the invitation.
+ *     @type bool   $force_resend  Whether to resend the email & notification if one has already been sent.
+ * }
  */
-function groups_send_invites( $user_id, $group_id ) {
+function groups_send_invites( $args = array() ) {
+        // Backward compatibility with old method of passing arguments.
+        if ( ! is_array( $args ) || func_num_args() > 1 ) {
+                _deprecated_argument( __METHOD__, '5.0.0', sprintf( __( 'Arguments passed to %1$s should be in an associative array. See the inline documentation at %2$s for more details.', 'buddypress' ), __METHOD__, __FILE__ ) );
 
-        if ( empty( $user_id ) )
-                $user_id = bp_loggedin_user_id();
+                $old_args_keys = array(
+                        0 => 'inviter_id',
+                        1 => 'group_id',
+                );
 
-        // Send friend invites.
-        $invited_users = groups_get_invites_for_group( $user_id, $group_id );
-        $group = groups_get_group( $group_id );
+                $args = bp_core_parse_args_array( $old_args_keys, func_get_args() );
+        }
 
-        for ( $i = 0, $count = count( $invited_users ); $i < $count; ++$i ) {
-                $member = new BP_Groups_Member( $invited_users[$i], $group_id );
+        $r = bp_parse_args( $args, array(
+                'user_id'       => false,
+                'invitee_email' => '',
+                'group_id'      => 0,
+                'inviter_id'    => bp_loggedin_user_id(),
+                'force_resend'  => false,
+        ), 'groups_send_invitation' );
 
-                // Skip if we've already sent an invite to this user.
-                if ( $member->invite_sent ) {
-                        continue;
-                }
+        /*
+         * We will generally only want to fetch unsent invitations.
+         * If force_resend is true, then we need to fetch both sent and draft invites.
+         */
+        if ( $r['force_resend'] ) {
+                $args['invite_sent'] = 'all';
+        } else {
+                $args['invite_sent'] = 'draft';
+        }
 
-                // Send the actual invite.
-                groups_notification_group_invites( $group, $member, $user_id );
+        $args = array(
+                'user_id'       => $r['user_id'],
+                'invitee_email' => $r['invitee_email'],
+                'item_id'       => $r['group_id'],
+                'inviter_id'    => $r['inviter_id'],
+        );
+        $invites = groups_get_invites( $args );
 
-                $member->invite_sent = 1;
-                $member->save();
+        $invited_users = array();
+
+        $invites_class = new BP_Groups_Invitation_Manager();
+        foreach ( $invites as $invite ) {
+                $invited_users[] = $invite->user_id;
+                $invites_class->send_invitation_by_id( $invite->id );
         }
 
         /**
@@ -1644 +1773 @@
          * @param array $invited_users Array of users being invited to the group.
          * @param int   $user_id       ID of the inviting user.
          */
-        do_action( 'groups_send_invites', $group_id, $invited_users, $user_id );
+        do_action( 'groups_send_invites', $r['group_id'], $invited_users, $r['inviter_id'] );
 }
 
 /**
- * Get IDs of users with outstanding invites to a given group from a specified user.
+ * Get IDs of users with outstanding invites to a given group.
  *
  * @since 1.0.0
  * @since 2.9.0 Added $sent as a parameter.
@@ -1666 +1795 @@
         return BP_Groups_Group::get_invites( $user_id, $group_id, $sent );
 }
 
+/**
+ * Get invitations to a given group filtered by arguments.
+ *
+ * @since 5.0.0
+ *
+ * @param int   $group_id ID of the group.
+ * @param array $args     Invitation arguments.
+ *                        See BP_Invitation::get() for list.
+ *
+ * @return array $invites     Matching BP_Invitation objects.
+ */
+function groups_get_invites( $args = array() ) {
+        $invites_class = new BP_Groups_Invitation_Manager();
+        return $invites_class->get_invitations( $args );
+}
+
 /**
  * Check to see whether a user has already been invited to a group.
  *
@@ -1679 +1824 @@
  * @param int    $group_id ID of potential group.
  * @param string $type     Optional. Use 'sent' to check for sent invites,
  *                         'all' to check for all. Default: 'sent'.
- * @return int|bool ID of the membership if found, otherwise false.
+ * @return int|bool ID of the first found membership if found, otherwise false.
  */
 function groups_check_user_has_invite( $user_id, $group_id, $type = 'sent' ) {
-        $invite = false;
+        return groups_check_has_invite_from_user( $user_id, $group_id, false, $type );
+}
+
+/**
+ * Check to see whether a user has already been invited to a group by a particular user.
+ *
+ * By default, the function checks for invitations that have been sent.
+ * Entering 'all' as the $type parameter will return unsent invitations as
+ * well (useful to make sure AJAX requests are not duplicated).
+ *
+ * @since 5.0.0
+ *
+ * @param int    $user_id    ID of potential group member.
+ * @param int    $group_id   ID of potential group.
+ * @param string $inviter_id Optional. Use 'sent' to check for sent invites,
+ *                           'all' to check for all. Default: 'sent'.
+ * @param string $type       Optional. Specify a user ID to limit to only invited from that user.
+ *                           Default: 'false'.
+ * @return int|bool ID of the first found membership if found, otherwise false.
+ */
+ function groups_check_has_invite_from_user( $user_id, $group_id, $inviter_id = false, $type = 'sent' ) {
+        if ( empty( $user_id ) || empty( $group_id ) ) {
+                return false;
+        }
 
         $args = array(
-                'is_confirmed' => false,
-                'is_banned'    => null,
-                'is_admin'     => null,
-                'is_mod'       => null,
+                'user_id'     => $user_id,
+                'item_id'     => $group_id,
+                'invite_sent' => 'sent',
         );
-
-        if ( 'sent' === $type ) {
-                $args['invite_sent'] = true;
+        if ( $inviter_id ) {
+                $args['inviter_id'] = $inviter_id;
         }
-
-        $user_groups = bp_get_user_groups( $user_id, $args );
-
-        if ( isset( $user_groups[ $group_id ] ) && 0 !== $user_groups[ $group_id ]->inviter_id ) {
-                $invite = $user_groups[ $group_id ]->id;
+        if ( $type === 'draft' || $type === 'all' ) {
+                $args['invite_sent'] = $type;
         }
 
-        return $invite;
+        $invites_class = new BP_Groups_Invitation_Manager();
+
+        return $invites_class->invitation_exists( $args );
 }
 
 /**
@@ -1878 +2043 @@
  *
  * @since 1.0.0
  *
- * @param int $requesting_user_id ID of the user requesting membership.
- * @param int $group_id           ID of the group.
+ * @param array|string $args {
+ *     Array of arguments.
+ *     @type int    $user_id       ID of the user being invited.
+ *     @type int    $group_id      ID of the group to which the user is being invited.
+ *     @type string $content       Optional. Message to invitee.
+ *     @type string $date_modified Optional. Modified date for the invitation.
+ *                                 Default: current date/time.
+ * }
  * @return bool True on success, false on failure.
  */
-function groups_send_membership_request( $requesting_user_id, $group_id ) {
-
-        // Prevent duplicate requests.
-        if ( groups_check_for_membership_request( $requesting_user_id, $group_id ) )
-                return false;
+function groups_send_membership_request( $args = array() ) {
+        // Backward compatibility with old method of passing arguments.
+        if ( ! is_array( $args ) || func_num_args() > 1 ) {
+                _deprecated_argument( __METHOD__, '5.0.0', sprintf( __( 'Arguments passed to %1$s should be in an associative array. See the inline documentation at %2$s for more details.', 'buddypress' ), __METHOD__, __FILE__ ) );
 
-        // Check if the user is already a member or is banned.
-        if ( groups_is_user_member( $requesting_user_id, $group_id ) || groups_is_user_banned( $requesting_user_id, $group_id ) )
-                return false;
+                $old_args_keys = array(
+                        0 => 'user_id',
+                        1 => 'group_id',
+                );
 
-        // Check if the user is already invited - if so, simply accept invite.
-        if ( groups_check_user_has_invite( $requesting_user_id, $group_id ) ) {
-                groups_accept_invite( $requesting_user_id, $group_id );
-                return true;
+                $args = bp_core_parse_args_array( $old_args_keys, func_get_args() );
         }
 
-        $requesting_user                = new BP_Groups_Member;
-        $requesting_user->group_id      = $group_id;
-        $requesting_user->user_id       = $requesting_user_id;
-        $requesting_user->inviter_id    = 0;
-        $requesting_user->is_admin      = 0;
-        $requesting_user->user_title    = '';
-        $requesting_user->date_modified = bp_core_current_time();
-        $requesting_user->is_confirmed  = 0;
-        $requesting_user->comments      = isset( $_POST['group-request-membership-comments'] ) ? $_POST['group-request-membership-comments'] : '';
+        $r = bp_parse_args( $args, array(
+                'user_id'       => false,
+                'group_id'      => false,
+                'content'       => '',
+                'date_modified' => bp_core_current_time(),
+        ), 'groups_send_membership_request' );
 
-        if ( $requesting_user->save() ) {
-                $admins = groups_get_group_admins( $group_id );
+        $inv_args = array(
+                'user_id'       => $r['user_id'],
+                'item_id'       => $r['group_id'],
+                'content'       => $r['content'],
+                'date_modified' => $r['date_modified'],
+        );
 
-                // Saved okay, now send the email notification.
-                for ( $i = 0, $count = count( $admins ); $i < $count; ++$i )
-                        groups_notification_new_membership_request( $requesting_user_id, $admins[$i]->user_id, $group_id, $requesting_user->id );
+        $invites_class = new BP_Groups_Invitation_Manager();
+        $request_id = $invites_class->add_request( $inv_args );
+
+        // If a new request was created, send the emails.
+        if ( $request_id && is_int( $request_id ) ) {
+                $invites_class->send_request_notification_by_id( $request_id );
+                $admins = groups_get_group_admins( $r['group_id'] );
 
                 /**
                  * Fires after the creation of a new membership request.
@@ -1923 +2096 @@
                  * @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.
-                 * @param int   $requesting_user->id ID of the membership.
+                 * @param int   $request_id          ID of the request.
                  */
-                do_action( 'groups_membership_requested', $requesting_user_id, $admins, $group_id, $requesting_user->id );
+                do_action( 'groups_membership_requested', $r['user_id'], $admins, $r['group_id'], $request_id );
 
-                return true;
+                return $request_id;
         }
 
         return false;
@@ -1937 +2110 @@
  * Accept a pending group membership request.
  *
  * @since 1.0.0
+ * @since 5.0.0 Deprecated $membership_id argument.
  *
- * @param int $membership_id ID of the membership object.
- * @param int $user_id       Optional. ID of the user who requested membership.
+ * @param int $membership_id Deprecated 5.0.0.
+ * @param int $user_id       Required. ID of the user who requested membership.
  *                           Provide this value along with $group_id to override
  *                           $membership_id.
- * @param int $group_id      Optional. ID of the group to which membership is being
+ * @param int $group_id      Required. ID of the group to which membership is being
  *                           requested. Provide this value along with $user_id to
  *                           override $membership_id.
  * @return bool True on success, false on failure.
  */
 function groups_accept_membership_request( $membership_id, $user_id = 0, $group_id = 0 ) {
 
-        if ( !empty( $user_id ) && !empty( $group_id ) ) {
-                $membership = new BP_Groups_Member( $user_id, $group_id );
-        } else {
-                $membership = new BP_Groups_Member( false, false, $membership_id );
+        if ( ! empty( $membership_id ) ) {
+                _deprecated_argument( __METHOD__, '5.0.0', sprintf( __( 'Argument `membership_id` passed to %1$s  is deprecated. See the inline documentation at %2$s for more details.', 'buddypress' ), __METHOD__, __FILE__ ) );
         }
 
-        $membership->accept_request();
-
-        if ( !$membership->save() ) {
+        if ( ! $user_id || ! $group_id ) {
                 return false;
         }
 
-        // Check if the user has an outstanding invite, if so delete it.
-        if ( groups_check_user_has_invite( $membership->user_id, $membership->group_id ) ) {
-                groups_delete_invite( $membership->user_id, $membership->group_id );
-        }
-
-        /**
-         * 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', $membership->user_id, $membership->group_id, true );
+        $invites_class = new BP_Groups_Invitation_Manager();
+        $args = array(
+                'user_id' => $user_id,
+                'item_id' => $group_id,
+        );
 
-        return true;
+        return $invites_class->accept_request( $args );
 }
 
 /**
@@ -1985 +2145 @@
  *
  * @since 1.0.0
  *
- * @param int $membership_id ID of the membership object.
+ * @param int $membership_id Deprecated 5.0.0.
  * @param int $user_id       Optional. ID of the user who requested membership.
  *                           Provide this value along with $group_id to override
  *                           $membership_id.
@@ -1995 +2155 @@
  * @return bool True on success, false on failure.
  */
 function groups_reject_membership_request( $membership_id, $user_id = 0, $group_id = 0 ) {
-        if ( !$membership = groups_delete_membership_request( $membership_id, $user_id, $group_id ) ) {
+
+        if ( ! empty( $membership_id ) ){
+                _deprecated_argument( __METHOD__, '5.0.0', sprintf( __( 'Argument `membership_id` passed to %1$s  is deprecated. See the inline documentation at %2$s for more details.', 'buddypress' ), __METHOD__, __FILE__ ) );
+        }
+
+        if ( ! groups_delete_membership_request( false, $user_id, $group_id ) ) {
                 return false;
         }
 
@@ -2008 +2173 @@
          * @param int  $group_id ID of the group that was rejected membership to.
          * @param bool $value    If membership was accepted.
          */
-        do_action( 'groups_membership_rejected', $membership->user_id, $membership->group_id, false );
+        do_action( 'groups_membership_rejected', $user_id, $group_id, false );
 
         return true;
 }
@@ -2018 +2183 @@
  *
  * @since 1.2.0
  *
- * @param int $membership_id ID of the membership object.
+ * @param int $membership_id Deprecated 5.0.0.
  * @param int $user_id       Optional. ID of the user who requested membership.
  *                           Provide this value along with $group_id to override
  *                           $membership_id.
@@ -2028 +2193 @@
  * @return false|BP_Groups_Member True on success, false on failure.
  */
 function groups_delete_membership_request( $membership_id, $user_id = 0, $group_id = 0 ) {
-        if ( !empty( $user_id ) && !empty( $group_id ) )
-                $membership = new BP_Groups_Member( $user_id, $group_id );
-        else
-                $membership = new BP_Groups_Member( false, false, $membership_id );
+        if ( ! empty( $membership_id ) ){
+                _deprecated_argument( __METHOD__, '5.0.0', sprintf( __( 'Argument `membership_id` passed to %1$s  is deprecated. See the inline documentation at %2$s for more details.', 'buddypress' ), __METHOD__, __FILE__ ) );
+        }
 
-        if ( ! BP_Groups_Member::delete_request( $membership->user_id, $membership->group_id ) )
+        if ( empty( $user_id ) || empty( $group_id ) ) {
                 return false;
+        }
+
+        $invites_class = new BP_Groups_Invitation_Manager();
+        $success       = $invites_class->delete_requests( array(
+                'user_id' => $user_id,
+                'item_id' => $group_id
+        ) );
+
+        return $success;
+}
 
-        return $membership;
+/**
+ * Get group membership requests filtered by arguments.
+ *
+ * @since 5.0.0
+ *
+ * @param int   $group_id ID of the group.
+ * @param array $args     Invitation arguments.
+ *                        See BP_Invitation::get() for list.
+ *
+ * @return array $requests Matching BP_Invitation objects.
+ */
+function groups_get_requests( $args = array() ) {
+        $invites_class = new BP_Groups_Invitation_Manager();
+        return $invites_class->get_requests( $args );
 }
 
 /**
@@ -2046 +2233 @@
  *
  * @param int $user_id  ID of the user.
  * @param int $group_id ID of the group.
- * @return int|bool ID of the membership if found, otherwise false.
+ * @return int|bool ID of the request if found, otherwise false.
  */
 function groups_check_for_membership_request( $user_id, $group_id ) {
-        $request = false;
+        if ( empty( $user_id ) || empty( $group_id ) ) {
+                return false;
+        }
 
-        $user_groups = bp_get_user_groups( $user_id, array(
-                'is_confirmed' => false,
-                'is_banned'    => false,
-                'is_admin'     => null,
-                'is_mod'       => null
+        $args = array(
+                'user_id' => $user_id,
+                'item_id' => $group_id,
+        );
+        $invites_class = new BP_Groups_Invitation_Manager();
+
+        return $invites_class->request_exists( $args );
+}
+
+ /**
+  * Get an array of group IDs to which a user has requested membership.
+  *
+  * @since 5.0.0
+  *
+  * @param int $user_id The user ID.
+  *
+  * @return array Array of group IDs.
+  */
+ function groups_get_membership_requested_group_ids( $user_id = 0 ) {
+        if ( ! $user_id ) {
+                $user_id = bp_loggedin_user_id();
+        }
+
+        $group_ids     = groups_get_requests( array(
+                'user_id' => $user_id,
+                'fields'  => 'item_ids'
         ) );
 
-        if ( isset( $user_groups[ $group_id ] ) && 0 === $user_groups[ $group_id ]->inviter_id ) {
-                $request = $user_groups[ $group_id ]->id;
-        }
+        return $group_ids;
+}
+
+ /**
+  * Get an array of group IDs to which a user has requested membership.
+  *
+  * @since 5.0.0
+  *
+  * @param int $user_id The user ID.
+  *
+  * @return array Array of group IDs.
+  */
+ function groups_get_membership_requested_user_ids( $group_id = 0 ) {
+        if ( ! $group_id ) {
+                $group_id = bp_get_current_group_id();
+        }
+
+        $requests      = groups_get_requests( array(
+                'item_id' => $group_id,
+                'fields'  => 'user_ids'
+        ) );
 
-        return $request;
+        //@TODO-6210: What about those who make a request by email only (not yet site members)?
+        return $requests;
 }
 
 /**
@@ -2073 +2302 @@
  * @param int $group_id ID of the group.
  * @return bool True on success, false on failure.
  */
-function groups_accept_all_pending_membership_requests( $group_id ) {
-        $user_ids = BP_Groups_Member::get_all_membership_request_user_ids( $group_id );
+function groups_accept_all_pending_membership_requests( $group_id = 0 ) {
+        if ( ! $group_id ) {
+                $group_id = bp_get_current_group_id();
+        }
 
-        if ( !$user_ids )
+        $user_ids = groups_get_membership_requested_user_ids( $group_id );
+
+        if ( ! $user_ids ) {
                 return false;
+        }
 
-        foreach ( (array) $user_ids as $user_id )
+        foreach ( (array) $user_ids as $user_id ) {
                 groups_accept_membership_request( false, $user_id, $group_id );
+        }
 
         /**
          * Fires after the acceptance of all pending membership requests to a group.
@@ -2756 +2991 @@
                 );
         }
 
-        $requests = BP_Groups_Member::get_user_memberships( $user->ID, array(
-                'type'     => 'pending_request',
+        $requests = groups_get_requests( array(
+                'user_id'  => $user->ID,
                 'page'     => $page,
                 'per_page' => $number,
         ) );
 
         foreach ( $requests as $request ) {
-                $group = groups_get_group( $request->group_id );
+                $group = groups_get_group( $request->item_id );
 
                 $item_data = array(
                         array(
@@ -2822 +3057 @@
                 );
         }
 
-        $invitations = BP_Groups_Member::get_user_memberships( $user->ID, array(
-                'type'     => 'pending_sent_invitation',
-                'page'     => $page,
-                'per_page' => $number,
+        $invitations = groups_get_invites( array(
+                'inviter_id'  => $user->ID,
+                'page'        => $page,
+                'per_page'    => $number,
         ) );
 
         foreach ( $invitations as $invitation ) {
-                $group = groups_get_group( $invitation->group_id );
+                $group = groups_get_group( $invitation->item_id );
 
                 $item_data = array(
                         array(
@@ -2892 +3127 @@
                 );
         }
 
-        $invitations = BP_Groups_Member::get_user_memberships( $user->ID, array(
-                'type'     => 'pending_received_invitation',
+        $invitations = groups_get_invites( array(
+                'user_id'  => $user->ID,
                 'page'     => $page,
                 'per_page' => $number,
         ) );
 
         foreach ( $invitations as $invitation ) {
-                $group = groups_get_group( $invitation->group_id );
+                $group = groups_get_group( $invitation->item_id );
 
                 $item_data = array(
                         array(
@@ -2936 +3171 @@
                 'done' => $done,
         );
 }
+
+/**
+ * Migrate invitations and requests from pre-5.0 group_members table to invitations table.
+ *
+ * @since 5.0.0
+ */
+function bp_groups_migrate_invitations() {
+        global $wpdb;
+        $bp = buddypress();
+
+        $records = $wpdb->get_results( "SELECT id, group_id, user_id, inviter_id, date_modified, comments, invite_sent FROM {$bp->groups->table_name_members} WHERE is_confirmed = 0 AND is_banned = 0" );
+
+        $processed = array();
+        foreach ( $records as $record ) {
+                $invitation = new BP_Invitation;
+                $invitation->user_id           = $record->user_id;
+                $invitation->inviter_id        = $record->inviter_id;
+                $invitation->invitee_email     = '';
+                $invitation->class             = 'BP_Groups_Invitation_Manager';
+                $invitation->item_id           = $record->group_id;
+                $invitation->secondary_item_id = 0;
+                $invitation->type              = ( 0 === (int) $record->inviter_id ) ? 'request' : 'invite';
+                $invitation->content           = $record->comments;
+                $invitation->date_modified     = $record->date_modified;
+                $invitation->invite_sent       = $record->invite_sent;
+                $invitation->accepted          = 0;
+
+                $invite_id = $invitation->save();
+                $processed[] = (int) $record->id;
+        }
+
+        $ids_to_delete = implode( ',', $processed );
+        var_dump( $wpdb->query( "DELETE FROM {$bp->groups->table_name_members} WHERE ID IN ($ids_to_delete)" ) );
+}

src/bp-groups/bp-groups-notifications.php

@@ -143 +143 @@
                 'notification_type' => 'groups-membership-request',
         );
 
+        $request_message = '';
+        $requests = groups_get_requests( $args = array(
+                'user_id'    => $requesting_user_id,
+                'item_id'    => $group_id,
+        ) );
+        if ( $requests ) {
+                $request_message = current( $requests )->content;
+        }
+
         $group = groups_get_group( $group_id );
         $args  = array(
                 'tokens' => array(
@@ -151 +160 @@
                         'group.name'           => $group->name,
                         'group.id'             => $group_id,
                         'group-requests.url'   => esc_url( bp_get_group_permalink( $group ) . 'admin/membership-requests' ),
-                        'membership.id'        => $membership_id,
                         'profile.url'          => esc_url( bp_core_get_user_domain( $requesting_user_id ) ),
                         'requesting-user.id'   => $requesting_user_id,
                         'requesting-user.name' => bp_core_get_user_displayname( $requesting_user_id ),
+                        'request.message'      => $request_message,
                         'unsubscribe'          => esc_url( bp_email_get_unsubscribe_link( $unsubscribe_args ) ),
                 ),
         );
@@ -289 +298 @@
  *
  * @since 1.0.0
  *
- * @param BP_Groups_Group  $group           Group object.
- * @param BP_Groups_Member $member          Member object.
- * @param int              $inviter_user_id ID of the user who sent the invite.
+ * @param BP_Groups_Group      $group           Group object.
+ * @param BP_Groups_Member|int $member          Member object or invited_user_id.
+ * @param int                  $inviter_user_id ID of the user who sent the invite.
  */
 function groups_notification_group_invites( &$group, &$member, $inviter_user_id ) {
 
-        // Bail if member has already been invited.
-        if ( ! empty( $member->invite_sent ) ) {
-                return;
-        }
-
         // @todo $inviter_ud may be used for caching, test without it
         $inviter_ud      = bp_core_get_core_userdata( $inviter_user_id );
-        $invited_user_id = $member->user_id;
+
+        if ( $member instanceof BP_Groups_Member ) {
+                $invited_user_id = $member->user_id;
+        } else if ( is_int( $member ) ) {
+                $invited_user_id = $member;
+        }
 
         // Trigger a BuddyPress Notification.
         if ( bp_is_active( 'notifications' ) ) {
@@ -326 +335 @@
                 'notification_type' => 'groups-invitation',
         );
 
+        $invite_message = '';
+        $invitations = groups_get_invites( $args = array(
+                'user_id'    => $invited_user_id,
+                'item_id'    => $group->id,
+                'inviter_id' => $inviter_user_id,
+        ) );
+        if ( $invitations ) {
+                $invite_message = current( $invitations )->content;
+        }
+
         $args         = array(
                 'tokens' => array(
-                        'group'        => $group,
-                        'group.url'    => bp_get_group_permalink( $group ),
-                        'group.name'   => $group->name,
-                        'inviter.name' => bp_core_get_userlink( $inviter_user_id, true, false, true ),
-                        'inviter.url'  => bp_core_get_user_domain( $inviter_user_id ),
-                        'inviter.id'   => $inviter_user_id,
-                        'invites.url'  => esc_url( $invited_link . '/invites/' ),
-                        'unsubscribe'  => esc_url( bp_email_get_unsubscribe_link( $unsubscribe_args ) ),
+                        'group'          => $group,
+                        'group.url'      => bp_get_group_permalink( $group ),
+                        'group.name'     => $group->name,
+                        'inviter.name'   => bp_core_get_userlink( $inviter_user_id, true, false, true ),
+                        'inviter.url'    => bp_core_get_user_domain( $inviter_user_id ),
+                        'inviter.id'     => $inviter_user_id,
+                        'invites.url'    => esc_url( $invited_link . '/invites/' ),
+                        'invite.message' => $invite_message,
+                        'unsubscribe'    => esc_url( bp_email_get_unsubscribe_link( $unsubscribe_args ) ),
                 ),
         );
+
         bp_send_email( 'groups-invitation', (int) $invited_user_id, $args );
 }
 

src/bp-groups/bp-groups-template.php

@@ -5430 +5430 @@
         function bp_get_group_request_reject_link() {
                 global $requests_template;
 
+                $link = add_query_arg( array(
+                        '_wpnonce' => wp_create_nonce( 'groups_reject_membership_request' ),
+                        'user_id'  => $requests_template->request->user_id,
+                        'action'   => 'reject'
+                ), trailingslashit( bp_get_group_permalink( groups_get_current_group() ) ) . 'admin/membership-requests/' );
+
                 /**
                  * Filters the URL to use to reject a membership request.
                  *
@@ -5437 +5443 @@
                  *
                  * @param string $value URL to use to reject a membership request.
                  */
-                return apply_filters( 'bp_get_group_request_reject_link', wp_nonce_url( trailingslashit( bp_get_group_permalink( groups_get_current_group() ) . 'admin/membership-requests/reject/' . $requests_template->request->membership_id ), 'groups_reject_membership_request' ) );
+                return apply_filters( 'bp_get_group_request_reject_link', $link );
         }
 
 /**
@@ -5454 +5460 @@
         function bp_get_group_request_accept_link() {
                 global $requests_template;
 
+                $link = add_query_arg( array(
+                        '_wpnonce' => wp_create_nonce( 'groups_accept_membership_request' ),
+                        'user_id'  => $requests_template->request->user_id,
+                        'action'   => 'accept'
+                ), trailingslashit( bp_get_group_permalink( groups_get_current_group() ) ) . 'admin/membership-requests/' );
+
                 /**
                  * Filters the URL to use to accept a membership request.
                  *
@@ -5461 +5473 @@
                  *
                  * @param string $value URL to use to accept a membership request.
                  */
-                return apply_filters( 'bp_get_group_request_accept_link', wp_nonce_url( trailingslashit( bp_get_group_permalink( groups_get_current_group() ) . 'admin/membership-requests/accept/' . $requests_template->request->membership_id ), 'groups_accept_membership_request' ) );
+                return apply_filters( 'bp_get_group_request_accept_link', $link );
         }
 
 /**

src/bp-groups/classes/class-bp-group-member-query.php

@@ -231 +231 @@
                 $sql['orderby'] = "ORDER BY date_modified";
                 $sql['order']   = 'first_joined' === $this->query_vars['type'] ? 'ASC' : 'DESC';
 
-                $this->group_member_ids = $wpdb->get_col( "{$sql['select']} {$sql['where']} {$sql['orderby']} {$sql['order']}" );
+                $group_member_ids = $wpdb->get_col( "{$sql['select']} {$sql['where']} {$sql['orderby']} {$sql['order']}" );
+
+                $invited_member_ids = array();
+
+                // If appropriate, fetch invitations and add them to the results.
+                if ( ! $is_confirmed || ! is_null( $this->query_vars['invite_sent'] ) || ! is_null( $this->query_vars['inviter_id'] ) ) {
+                        $invite_args = array(
+                                'item_id' => $this->query_vars['group_id'],
+                                'fields'  => 'user_ids',
+                                'type'    => 'all',
+                        );
+
+                        if ( ! is_null( $this->query_vars['invite_sent'] ) ) {
+                                $invite_args['invite_sent'] = ! empty( $this->query_vars['invite_sent'] ) ? 'sent' : 'draft';
+                        }
+
+                        // If inviter_id.
+                        if ( ! is_null( $this->query_vars['inviter_id'] ) ) {
+                                $inviter_id = $this->query_vars['inviter_id'];
+
+                                // Empty: inviter_id = 0. (pass false, 0, or empty array).
+                                if ( empty( $inviter_id ) ) {
+                                        $invite_args['type'] = 'request';
+
+                                /*
+                                * The string 'any' matches any non-zero value (inviter_id != 0).
+                                * These are invitations, not requests.
+                                */
+                                } elseif ( 'any' === $inviter_id ) {
+                                        $invite_args['type'] = 'invite';
+
+                                // Assume that a list of inviter IDs has been passed.
+                                } else {
+                                        $invite_args['type'] = 'invite';
+                                        // Parse and sanitize.
+                                        $inviter_ids = wp_parse_id_list( $inviter_id );
+                                        if ( ! empty( $inviter_ids ) ) {
+                                                $invite_args['inviter_id'] = $inviter_ids;
+                                        }
+                                }
+                        }
+
+                        /*
+                         * If first_joined is the "type" of query, sort the oldest
+                         * requests and invitations to the top.
+                         */
+                        if ( 'first_joined' === $this->query_vars['type'] ) {
+                                $invite_args['order_by']   = 'date_modified';
+                                $invite_args['sort_order'] = 'ASC';
+                        }
+
+                        $invited_member_ids = groups_get_invites( $invite_args );
+                }
+
+                $this->group_member_ids = array_merge( $group_member_ids, $invited_member_ids );
 
                 /**
                  * Filters the member IDs for the current group member query.
@@ -330 +384 @@
                         }
                 }
 
+                // Add accurate invitation info from the invitations table.
+                $invites = groups_get_invites( array(
+                        'user_id' => $user_ids_sql,
+                        'item_id' => $this->query_vars['group_id'],
+                        'type'    => 'all',
+                ) );
+                foreach ( $invites as $invite ) {
+                        if ( isset( $this->results[ $invite->user_id ] ) ) {
+                                $this->results[ $invite->user_id ]->comments      = $invite->content;
+                                $this->results[ $invite->user_id ]->is_confirmed  = 0;
+                                $this->results[ $invite->user_id ]->invitation_id = $invite->id;
+                                $this->results[ $invite->user_id ]->invite_sent   = (int) $invite->invite_sent;
+                                $this->results[ $invite->user_id ]->inviter_id    = $invite->inviter_id;
+
+                                // Backfill properties that are not being set above.
+                                if ( ! isset( $this->results[ $invite->user_id ]->user_id ) ) {
+                                        $this->results[ $invite->user_id ]->user_id = $invite->user_id;
+                                }
+                                if ( ! isset( $this->results[ $invite->user_id ]->is_admin ) ) {
+                                        $this->results[ $invite->user_id ]->is_admin = 0;
+                                }
+                                if ( ! isset( $this->results[ $invite->user_id ]->is_mod ) ) {
+                                        $this->results[ $invite->user_id ]->is_mod = 0;
+                                }
+                                if ( ! isset( $this->results[ $invite->user_id ]->is_banned ) ) {
+                                        $this->results[ $invite->user_id ]->is_banned = 0;
+                                }
+                                if ( ! isset( $this->results[ $invite->user_id ]->date_modified ) ) {
+                                        $this->results[ $invite->user_id ]->date_modified = $invite->date_modified;
+                                }
+                                if ( ! isset( $this->results[ $invite->user_id ]->user_title ) ) {
+                                        $this->results[ $invite->user_id ]->user_title = '';
+                                }
+                                if ( ! isset( $this->results[ $invite->user_id ]->membership_id ) ) {
+                                        $this->results[ $invite->user_id ]->membership_id = 0;
+                                }
+                        }
+                }
+
                 // Don't filter other BP_User_Query objects on the same page.
                 remove_action( 'bp_user_query_populate_extras', array( $this, 'populate_group_member_extras' ), 10 );
         }

src/bp-groups/classes/class-bp-groups-group.php

@@ -771 +771 @@
          *                  yet accepted.
          */
         public static function get_invites( $user_id, $group_id, $sent = null ) {
-                global $wpdb;
-
-                $bp  = buddypress();
-                $sql = $wpdb->prepare( "SELECT user_id FROM {$bp->groups->table_name_members} WHERE group_id = %d and is_confirmed = 0 AND inviter_id = %d", $group_id, $user_id );
-
-                // Query for a specific invite sent status.
-                if ( ! is_null( $sent ) ) {
-                        $sql .= $wpdb->prepare( ' AND invite_sent = %d', $sent );
+                if ( 0 === $sent ) {
+                        $sent_arg = 'draft';
+                } else if ( 1 === $sent ) {
+                        $sent_arg = 'sent';
+                } else {
+                        $sent_arg = 'all';
                 }
 
-                return $wpdb->get_col( $sql );
+                return groups_get_invites( array(
+                        'item_id'     => $group_id,
+                        'inviter_id'  => $user_id,
+                        'invite_sent' => $sent_arg,
+                        'fields'      => 'user_ids',
+                ) );
         }
 
         /**
@@ -959 +962 @@
          * }
          */
         public static function get_membership_requests( $group_id, $limit = null, $page = null ) {
-                global $wpdb;
-
-                if ( !empty( $limit ) && !empty( $page ) ) {
-                        $pag_sql = $wpdb->prepare( " LIMIT %d, %d", intval( ( $page - 1 ) * $limit), intval( $limit ) );
+                $args = array(
+                        'item_id' => $group_id
+                );
+                if ( $limit ) {
+                        $args['per_page'] = $limit;
                 }
+                if ( $page ) {
+                        $args['page'] = $page;
+                }
 
-                $bp = buddypress();
-
-                $paged_requests = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM {$bp->groups->table_name_members} WHERE group_id = %d AND is_confirmed = 0 AND inviter_id = 0{$pag_sql}", $group_id ) );
-                $total_requests = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(id) FROM {$bp->groups->table_name_members} WHERE group_id = %d AND is_confirmed = 0 AND inviter_id = 0", $group_id ) );
+                $requests = groups_get_requests( $args );
+                $total    = count( groups_get_membership_requested_user_ids( $group_id ) );
 
-                return array( 'requests' => $paged_requests, 'total' => $total_requests );
+                return array( 'requests' => $requests, 'total' => $total );
         }
 
         /**
@@ -1635 +1640 @@
          *                  failure.
          */
         public static function delete_all_invites( $group_id ) {
-                global $wpdb;
+                if ( empty( $group_id ) ) {
+                        return false;
+                }
 
-                $bp = buddypress();
+                $invites_class = new BP_Groups_Invitation_Manager();
 
-                return $wpdb->query( $wpdb->prepare( "DELETE FROM {$bp->groups->table_name_members} WHERE group_id = %d AND invite_sent = 1", $group_id ) );
+                return $invites_class->delete( array(
+                        'item_id' => $group_id,
+                ) );
         }
 
         /**

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

@@ +1 @@
+<?php
+/**
+ * Group invitations class.
+ *
+ * @package BuddyPress
+ * @subpackage Core
+ * @since 5.0.0
+ */
+
+// Exit if accessed directly.
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * Group invitations class.
+ *
+ * An extension of the core Invitations class that adapts the
+ * core logic to accommodate group invitation behavior.
+ *
+ * @since 5.0.0
+ */
+class BP_Groups_Invitation_Manager extends BP_Invitation_Manager {
+        /**
+         * Construct parameters.
+         *
+         * @since 3.1.0
+         *
+         * @param array|string $args {
+
+         * }
+         */
+        public function __construct( $args = '' ) {
+                parent::__construct();
+        }
+
+        /**
+         * This is where custom actions are added to run when notifications of an
+         * invitation or request need to be generated & sent.
+         *
+         * @since 2.7.0
+         *
+         * @param int $id The ID of the invitation to mark as sent.
+         * @return bool True on success, false on failure.
+         */
+        public function run_send_action( BP_Invitation $invitation ) {
+                // Notify group admins of the pending request
+                if ( 'request' === $invitation->type ) {
+                        $admins = groups_get_group_admins( $invitation->item_id );
+
+                        foreach ( $admins as $admin ) {
+                                groups_notification_new_membership_request( $invitation->user_id, $admin->user_id, $invitation->item_id, $invitation->id );
+                        }
+                        return true;
+
+                // Notify the invitee of the invitation.
+                } else {
+                        $group = groups_get_group( $invitation->item_id );
+                        groups_notification_group_invites( $group, $invitation->user_id, $invitation->inviter_id );
+                        return true;
+                }
+        }
+
+        /**
+         * This is where custom actions are added to run when an invitation
+         * or request is accepted.
+         *
+         * @since 2.7.0
+         *
+         * @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  ) {
+                // If the user is already a member (because BP at one point allowed two invitations to
+                // slip through), return early.
+                if ( groups_is_user_member( $r['user_id'], $r['item_id'] ) ) {
+                        return true;
+                }
+
+                // Create the new membership
+                $member = new BP_Groups_Member( $r['user_id'], $r['item_id'] );
+
+                if ( 'request' === $type ) {
+                        $member->accept_request();
+                } else {
+                        $member->accept_invite();
+                }
+
+                if ( ! $member->save() ) {
+                        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 {
+                        // Get an inviter_id from the invitation.
+                        $invites = groups_get_invites( $r );
+                        $inviter_id = 0;
+                        if ( $invites ) {
+                                $inviter_id = current( $invites )->inviter_id;
+                        }
+
+                        /**
+                         * 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'], $inviter_id );
+                }
+
+                // Modify group meta.
+                groups_update_groupmeta( $r['item_id'], 'last_activity', bp_core_current_time() );
+
+                return true;
+        }
+
+        /**
+         * With group invitations, we don't need to keep the old record, so we delete rather than
+         * mark invitations as "accepted."
+         *
+         * @since 2.7.0
+         *
+         * @see BP_Invitation::mark_accepted_by_data()
+         *      for a description of arguments.
+         */
+        public function mark_accepted( $args ) {
+                // Delete all existing invitations/requests to this group for this user.
+                $this->delete( array(
+                        'user_id' => $args['user_id'],
+                        'item_id' => $args['item_id'],
+                        'type'    => 'all'
+                ) );
+        }
+
+        /**
+         * Should this invitation be created?
+         *
+         * @since 5.0.0
+         */
+        public function allow_invitation( $args ) {
+                // Does the inviter have this capability?
+                if ( ! bp_user_can( $args['inviter_id'], 'groups_send_invitation', array( 'group_id' => $args['item_id'] ) ) ) {
+                        return false;
+                }
+
+                // Is the invited user eligible to receive an invitation?
+                if ( ! bp_user_can( $args['user_id'], 'groups_receive_invitation', array( 'group_id' => $args['item_id'] ) ) ) {
+                        return false;
+                }
+
+                // Prevent duplicated invitations.
+                if ( groups_check_has_invite_from_user( $args['user_id'], $args['item_id'], $args['inviter_id'], 'all' ) ) {
+                        return false;
+                }
+
+                return true;
+        }
+
+        /**
+         * Should this request be created?
+         *
+         * @since 5.0.0
+         */
+        public function allow_request( $args ) {
+                // Does the requester have this capability? (Also checks for duplicates.)
+                if ( ! bp_user_can( $args['user_id'], 'groups_request_membership', array( 'group_id' => $args['item_id'] ) ) ) {
+                        return false;
+                }
+
+                return true;
+        }
+}

src/bp-groups/classes/class-bp-groups-member.php

@@ -767 +767 @@
         }
 
         /**
-         * Get a user's outstanding group invitations.
+         * Get group objects for groups that a user is currently invited to.
          *
          * @since 1.6.0
          *
@@ -784 +784 @@
          * }
          */
         public static function get_invites( $user_id, $limit = false, $page = false, $exclude = false ) {
-                global $wpdb;
-
-                $pag_sql = ( !empty( $limit ) && !empty( $page ) ) ? $wpdb->prepare( " LIMIT %d, %d", intval( ( $page - 1 ) * $limit), intval( $limit ) ) : '';
-
-                if ( !empty( $exclude ) ) {
-                        $exclude     = implode( ',', wp_parse_id_list( $exclude ) );
-                        $exclude_sql = " AND g.id NOT IN ({$exclude})";
-                } else {
-                        $exclude_sql = '';
-                }
-
-                $bp = buddypress();
-
-                $paged_groups = $wpdb->get_results( $wpdb->prepare( "SELECT g.*, gm1.meta_value as total_member_count, gm2.meta_value as last_activity FROM {$bp->groups->table_name_groupmeta} gm1, {$bp->groups->table_name_groupmeta} gm2, {$bp->groups->table_name_members} m, {$bp->groups->table_name} g WHERE g.id = m.group_id AND g.id = gm1.group_id AND g.id = gm2.group_id AND gm2.meta_key = 'last_activity' AND gm1.meta_key = 'total_member_count' AND m.is_confirmed = 0 AND m.inviter_id != 0 AND m.invite_sent = 1 AND m.user_id = %d {$exclude_sql} ORDER BY m.date_modified ASC {$pag_sql}", $user_id ) );
-
-                return array( 'groups' => $paged_groups, 'total' => self::get_invite_count_for_user( $user_id ) );
+                return groups_get_invites_for_user( $user_id, $limit, $page, $exclude );
         }
 
         /**
@@ -811 +796 @@
          * @return int
          */
         public static function get_invite_count_for_user( $user_id = 0 ) {
-                global $wpdb;
-
-                $bp = buddypress();
-
-                $count = wp_cache_get( $user_id, 'bp_group_invite_count' );
-
-                if ( false === $count ) {
-                        $count = (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(DISTINCT m.group_id) FROM {$bp->groups->table_name_members} m, {$bp->groups->table_name} g WHERE m.group_id = g.id AND m.is_confirmed = 0 AND m.inviter_id != 0 AND m.invite_sent = 1 AND m.user_id = %d", $user_id ) );
-                        wp_cache_set( $user_id, $count, 'bp_group_invite_count' );
-                }
-
-                return $count;
+                return groups_get_invite_count_for_user( $user_id );
         }
 
         /**
@@ -859 +833 @@
                         'where'  => '',
                         'limits' => '',
                 );
-
+//@TODO 6210.
                 switch ( $r['type'] ) {
-                        case 'pending_request' :
-                                $sql['where'] = $wpdb->prepare( "user_id = %d AND is_confirmed = 0 AND inviter_id = 0", $user_id );
-                        break;
-
-                        case 'pending_received_invitation' :
-                                $sql['where'] = $wpdb->prepare( "user_id = %d AND is_confirmed = 0 AND inviter_id != 0", $user_id );
-                        break;
-
-                        case 'pending_sent_invitation' :
-                                $sql['where'] = $wpdb->prepare( "inviter_id = %d AND is_confirmed = 0", $user_id );
-                        break;
-
                         case 'membership' :
                         default :
                                 $sql['where'] = $wpdb->prepare( "user_id = %d AND is_confirmed = 1", $user_id );
@@ -912 +874 @@
          * @return int|null The ID of the invitation if found; null if not found.
          */
         public static function check_has_invite( $user_id, $group_id, $type = 'sent' ) {
-                global $wpdb;
-
-                if ( empty( $user_id ) )
-                        return false;
-
-                $bp  = buddypress();
-                $sql = "SELECT id FROM {$bp->groups->table_name_members} WHERE user_id = %d AND group_id = %d AND is_confirmed = 0 AND inviter_id != 0";
-
-                if ( 'sent' == $type )
-                        $sql .= " AND invite_sent = 1";
-
-                $query = $wpdb->get_var( $wpdb->prepare( $sql, $user_id, $group_id ) );
-
-                return is_numeric( $query ) ? (int) $query : $query;
+                return groups_is_user_invited( $user_id, $group_id, $type );
         }
 
         /**
@@ -937 +886 @@
          *
          * @param  int $user_id  ID of the user.
          * @param  int $group_id ID of the group.
+         * @param  int $inviter_id ID of the inviter. Specify if you want to delete
+         *                         a specific invite. Leave false if you want to
+         *                         delete all invites to this group.
          * @return int Number of records deleted.
          */
-        public static function delete_invite( $user_id, $group_id ) {
-                global $wpdb;
-
-                if ( empty( $user_id ) ) {
-                        return false;
-                }
-
+        public static function delete_invite( $user_id, $group_id, $inviter_id = false ) {
                 /**
                  * Fires before a group invitation is deleted.
                  *
                  * @since 2.6.0
+                 * @since 5.0.0 Added $inviter_id
                  *
                  * @param int $user_id  ID of the user.
                  * @param int $group_id ID of the group.
+                 * @param  int $inviter_id ID of the inviter.
                  */
-                do_action( 'bp_groups_member_before_delete_invite', $user_id, $group_id );
-
-                $table_name = buddypress()->groups->table_name_members;
-
-                $sql = "DELETE FROM {$table_name}
-                                WHERE user_id = %d
-                                        AND group_id = %d
-                                        AND is_confirmed = 0
-                                        AND inviter_id != 0";
-
-                $prepared = $wpdb->prepare( $sql, $user_id, $group_id );
+                do_action( 'bp_groups_member_before_delete_invite', $user_id, $group_id, $inviter_id );
 
-                return $wpdb->query( $prepared );
+                return groups_delete_invite( $user_id, $group_id, $inviter_id );
         }
 
         /**
@@ -979 +917 @@
          * @return int Number of records deleted.
          */
         public static function delete_request( $user_id, $group_id ) {
-                global $wpdb;
-
-                if ( empty( $user_id ) )
-                        return false;
-
-                $bp = buddypress();
-
-                return $wpdb->query( $wpdb->prepare( "DELETE FROM {$bp->groups->table_name_members} WHERE user_id = %d AND group_id = %d AND is_confirmed = 0 AND inviter_id = 0 AND invite_sent = 0", $user_id, $group_id ) );
+                return groups_delete_membership_request( false, $user_id, $group_id );
         }
 
         /**
@@ -1104 +1035 @@
          * @return int Database ID of the membership if found; int 0 on failure.
          */
         public static function check_for_membership_request( $user_id, $group_id ) {
-                global $wpdb;
-
-                if ( empty( $user_id ) )
-                        return false;
-
-                $bp = buddypress();
-
-                return $wpdb->query( $wpdb->prepare( "SELECT id FROM {$bp->groups->table_name_members} WHERE user_id = %d AND group_id = %d AND is_confirmed = 0 AND is_banned = 0 AND inviter_id = 0", $user_id, $group_id ) );
+                return groups_is_user_pending( $user_id, $group_id );
         }
 
         /**
@@ -1292 +1216 @@
          * @return array IDs of users with outstanding membership requests.
          */
         public static function get_all_membership_request_user_ids( $group_id ) {
-                global $wpdb;
-
-                $bp = buddypress();
-
-                return array_map( 'intval', $wpdb->get_col( $wpdb->prepare( "SELECT user_id FROM {$bp->groups->table_name_members} WHERE group_id = %d AND is_confirmed = 0 AND inviter_id = 0", $group_id ) ) );
+                return groups_get_membership_requested_user_ids( $group_id );
         }
 
         /**

src/bp-groups/screens/single/admin/membership-requests.php

@@ -23 +23 @@
                 return false;
         }
 
-        $request_action = (string) bp_action_variable( 1 );
-        $membership_id  = (int) bp_action_variable( 2 );
+        $request_action = isset( $_GET['action'] ) ? $_GET['action'] : false;
+        $user_id        = isset( $_GET['user_id'] ) ? (int) $_GET['user_id'] : false;
+        $group_id       = bp_get_current_group_id();
 
-        if ( !empty( $request_action ) && !empty( $membership_id ) ) {
-                if ( 'accept' == $request_action && is_numeric( $membership_id ) ) {
+        if ( $request_action && $user_id && $group_id ) {
+                if ( 'accept' === $request_action ) {
 
                         // Check the nonce first.
-                        if ( !check_admin_referer( 'groups_accept_membership_request' ) )
+                        if ( ! check_admin_referer( 'groups_accept_membership_request' ) ) {
                                 return false;
+                        }
 
                         // Accept the membership request.
-                        if ( !groups_accept_membership_request( $membership_id ) )
+                        if ( ! groups_accept_membership_request( false, $user_id, $group_id ) ) {
                                 bp_core_add_message( __( 'There was an error accepting the membership request. Please try again.', 'buddypress' ), 'error' );
-                        else
+                        } else {
                                 bp_core_add_message( __( 'Group membership request accepted', 'buddypress' ) );
+                        }
 
-                } elseif ( 'reject' == $request_action && is_numeric( $membership_id ) ) {
+                } elseif ( 'reject' === $request_action ) {
                         /* Check the nonce first. */
-                        if ( !check_admin_referer( 'groups_reject_membership_request' ) )
+                        if ( ! check_admin_referer( 'groups_reject_membership_request' ) ) {
                                 return false;
+                        }
 
                         // Reject the membership request.
-                        if ( !groups_reject_membership_request( $membership_id ) )
+                        if ( ! groups_reject_membership_request( false, $user_id, $group_id ) ) {
                                 bp_core_add_message( __( 'There was an error rejecting the membership request. Please try again.', 'buddypress' ), 'error' );
-                        else
+                        } else {
                                 bp_core_add_message( __( 'Group membership request rejected', 'buddypress' ) );
+                        }
                 }
 
+                // Was the member added to the group?
+                $membership_id = groups_is_user_member( $user_id, $group_id );
+
                 /**
                  * Fires before the redirect if a group membership request has been handled.
                  *
@@ -58 +66 @@
                  *
                  * @param int    $id             ID of the group that was edited.
                  * @param string $request_action Membership request action being performed.
-                 * @param int    $membership_id  The key of the action_variables array that you want.
+                 * @param int    $membership_id  The membership ID of the new user; false if rejected.
+                 * @param int    $user_id        The ID of the requesting user.
+                 * @param int    $group_id       The ID of the requested group.
                  */
-                do_action( 'groups_group_request_managed', $bp->groups->current_group->id, $request_action, $membership_id );
+                do_action( 'groups_group_request_managed', $bp->groups->current_group->id, $request_action, $membership_id, $user_id, $group_id );
                 bp_core_redirect( bp_get_group_permalink( groups_get_current_group() ) . 'admin/membership-requests/' );
         }
 
@@ -82 +92 @@
          */
         bp_core_load_template( apply_filters( 'groups_template_group_admin_requests', 'groups/single/home' ) );
 }
-add_action( 'bp_screens', 'groups_screen_group_admin_requests' );
- No newline at end of file
+add_action( 'bp_screens', 'groups_screen_group_admin_requests' );

src/class-buddypress.php

@@ -487 +487 @@
                 require( $this->plugin_dir . 'bp-core/bp-core-moderation.php'       );
                 require( $this->plugin_dir . 'bp-core/bp-core-loader.php'           );
                 require( $this->plugin_dir . 'bp-core/bp-core-customizer-email.php' );
+                require( $this->plugin_dir . 'bp-core/bp-core-invitations-cache.php' );
 
                 // Maybe load deprecated functionality (this double negative is proof positive!)
                 if ( ! bp_get_option( '_bp_ignore_deprecated_code', ! $this->load_deprecated ) ) {
@@ -568 +569 @@
                         'BP_Walker_Category_Checklist' => 'core',
                         'BP_Walker_Nav_Menu_Checklist' => 'core',
                         'BP_Walker_Nav_Menu'           => 'core',
+                        'BP_Invitation_Manager'        => 'core',
+                        'BP_Invitation'                => 'core',
 
                         'BP_Core_Friends_Widget' => 'friends',
 

new file tests/phpunit/assets/invitations-extensions.php

@@ +1 @@
+<?php
+/**
+ * The following implementations of BP_Attachment act as dummy plugins
+ * for our unit tests
+ */
+class BPTest_Invitation_Manager_Extension extends BP_Invitation_Manager {
+        public function __construct( $args = array() ) {
+                parent::__construct( $args );
+        }
+
+        public function run_send_action( BP_Invitation $invitation ) {
+                return true;
+        }
+
+        public function run_acceptance_action( $type = 'invite', $r  ) {
+                return true;
+        }
+}

new file tests/phpunit/testcases/core/invitations.php

@@ +1 @@
+<?php
+
+include_once BP_TESTS_DIR . 'assets/invitations-extensions.php';
+
+/**
+ * @group core
+ * @group invitations
+ */
+ class BP_Tests_Invitations extends BP_UnitTestCase {
+                public function test_bp_invitations_add_invitation_vanilla() {
+                $old_current_user = get_current_user_id();
+
+                $u1 = $this->factory->user->create();
+                $u2 = $this->factory->user->create();
+                $u3 = $this->factory->user->create();
+                $this->set_current_user( $u1 );
+
+                $invites_class = new BPTest_Invitation_Manager_Extension();
+
+                // Create a couple of invitations.
+                $invite_args = array(
+                        'user_id'           => $u3,
+                        'inviter_id'            => $u1,
+                        'item_id'           => 1,
+                        'send_invite'       => 'sent',
+                );
+                $i1 = $invites_class->add_invitation( $invite_args );
+                $invite_args['inviter_id'] = $u2;
+                $i2 = $invites_class->add_invitation( $invite_args );
+
+                $get_invites = array(
+                        'user_id'        => $u3,
+                        'fields'         => 'ids',
+                );
+                $invites = $invites_class->get_invitations( $get_invites );
+                $this->assertEqualSets( array( $i1, $i2 ), $invites );
+
+                $this->set_current_user( $old_current_user );
+        }
+
+        public function test_bp_invitations_add_invitation_avoid_duplicates() {
+                $old_current_user = get_current_user_id();
+
+                $u1 = $this->factory->user->create();
+                $u2 = $this->factory->user->create();
+                $this->set_current_user( $u1 );
+
+                $invites_class = new BPTest_Invitation_Manager_Extension();
+
+                // Create an invitation.
+                $invite_args = array(
+                        'user_id'           => $u2,
+                        'inviter_id'            => $u1,
+                        'item_id'           => 1,
+                        'send_invite'       => 'sent',
+                );
+                $i1 = $invites_class->add_invitation( $invite_args );
+                // Attempt to create a duplicate.
+                $this->assertFalse( $invites_class->add_invitation( $invite_args ) );
+
+                $this->set_current_user( $old_current_user );
+        }
+
+        public function test_bp_invitations_add_invitation_invite_plus_request_should_accept() {
+                $old_current_user = get_current_user_id();
+
+                $u1 = $this->factory->user->create();
+                $u2 = $this->factory->user->create();
+                $u3 = $this->factory->user->create();
+                $this->set_current_user( $u1 );
+
+                $invites_class = new BPTest_Invitation_Manager_Extension();
+
+                // Create an invitation.
+                $invite_args = array(
+                        'user_id'           => $u3,
+                        'inviter_id'            => $u1,
+                        'item_id'           => 1,
+                        'send_invite'       => 'sent',
+                );
+                $i1 = $invites_class->add_invitation( $invite_args );
+
+                // Create a request.
+                $request_args = array(
+                        'user_id'           => $u3,
+                        'item_id'           => 1,
+                );
+                $r1 = $invites_class->add_request( $request_args );
+
+                $get_invites = array(
+                        'user_id'          => $u3,
+                        'accepted'         => 'accepted'
+                );
+                $invites = $invites_class->get_invitations( $get_invites );
+                $this->assertEqualSets( array( $i1 ), wp_list_pluck( $invites, 'id' ) );
+
+                $this->set_current_user( $old_current_user );
+        }
+
+        public function test_bp_invitations_add_invitation_unsent_invite_plus_request_should_not_accept() {
+                $old_current_user = get_current_user_id();
+
+                $u1 = $this->factory->user->create();
+                $u2 = $this->factory->user->create();
+                $u3 = $this->factory->user->create();
+                $this->set_current_user( $u1 );
+
+                $invites_class = new BPTest_Invitation_Manager_Extension();
+
+                // Create an invitation.
+                $invite_args = array(
+                        'user_id'           => $u3,
+                        'inviter_id'            => $u1,
+                        'item_id'           => 1,
+                        'send_invite'       => 0,
+                );
+                $i1 = $invites_class->add_invitation( $invite_args );
+
+                // Create a request.
+                $request_args = array(
+                        'user_id'           => $u3,
+                        'item_id'           => 1,
+                );
+                $r1 = $invites_class->add_request( $request_args );
+
+                $get_invites = array(
+                        'user_id'          => $u3,
+                        'accepted'         => 'accepted'
+                );
+                $invites = $invites_class->get_invitations( $get_invites );
+                $this->assertEqualSets( array(), wp_list_pluck( $invites, 'id' ) );
+
+                $this->set_current_user( $old_current_user );
+        }
+
+        public function test_bp_invitations_add_invitation_unsent_invite_plus_request_then_send_invite_should_accept() {
+                $old_current_user = get_current_user_id();
+
+                $u1 = $this->factory->user->create();
+                $u2 = $this->factory->user->create();
+                $u3 = $this->factory->user->create();
+                $this->set_current_user( $u1 );
+
+                $invites_class = new BPTest_Invitation_Manager_Extension();
+
+                // Create an invitation.
+                $invite_args = array(
+                        'user_id'           => $u3,
+                        'inviter_id'            => $u1,
+                        'item_id'           => 1,
+                        'send_invite'       => 0,
+                );
+                $i1 = $invites_class->add_invitation( $invite_args );
+
+                // Create a request.
+                $request_args = array(
+                        'user_id'           => $u3,
+                        'item_id'           => 1,
+                );
+                $r1 = $invites_class->add_request( $request_args );
+
+                $invites_class->send_invitation_by_id( $i1 );
+
+                // Check that both the request and invitation are marked 'accepted'.
+                $get_invites = array(
+                        'user_id'          => $u3,
+                        'type'             => 'all',
+                        'accepted'         => 'accepted',
+                        'fields'           => 'ids'
+                );
+                $invites = $invites_class->get_invitations( $get_invites );
+                $this->assertEqualSets( array( $i1, $r1 ), $invites );
+
+                $this->set_current_user( $old_current_user );
+        }
+
+        public function test_bp_invitations_add_request_vanilla() {
+                $old_current_user = get_current_user_id();
+
+                $u1 = $this->factory->user->create();
+                $this->set_current_user( $u1 );
+
+                $invites_class = new BPTest_Invitation_Manager_Extension();
+
+                // Create a couple of requests.
+                $request_args = array(
+                        'user_id'           => $u1,
+                        'item_id'           => 7,
+                );
+                $r1 = $invites_class->add_request( $request_args );
+                $request_args['item_id'] = 4;
+                $r2 = $invites_class->add_request( $request_args );
+
+                $get_requests = array(
+                        'user_id'           => $u1,
+                        'fields'            => 'ids'
+                );
+                $requests = $invites_class->get_requests( $get_requests );
+                $this->assertEqualSets( array( $r1, $r2 ), $requests );
+
+                $this->set_current_user( $old_current_user );
+        }
+
+        public function test_bp_invitations_add_request_avoid_duplicates() {
+                $old_current_user = get_current_user_id();
+
+                $invites_class = new BPTest_Invitation_Manager_Extension();
+
+                $u1 = $this->factory->user->create();
+                $this->set_current_user( $u1 );
+
+                // Create a couple of requests.
+                $request_args = array(
+                        'user_id'           => $u1,
+                        'item_id'           => 7,
+                );
+                $r1 = $invites_class->add_request( $request_args );
+                // Attempt to create a duplicate.
+                $this->assertFalse( $invites_class->add_request( $request_args ) );
+
+                $this->set_current_user( $old_current_user );
+        }
+
+        public function test_bp_invitations_add_request_request_plus_sent_invite_should_accept() {
+                $old_current_user = get_current_user_id();
+
+                $u1 = $this->factory->user->create();
+                $u2 = $this->factory->user->create();
+                $this->set_current_user( $u1 );
+
+                $invites_class = new BPTest_Invitation_Manager_Extension();
+
+                // Create a request.
+                $request_args = array(
+                        'user_id'           => $u2,
+                        'item_id'           => 1,
+                );
+                $r1 = $invites_class->add_request( $request_args );
+
+                // Create an invitation.
+                $invite_args = array(
+                        'user_id'           => $u2,
+                        'inviter_id'            => $u1,
+                        'item_id'           => 1,
+                        'send_invite'       => 1,
+                );
+                $i1 = $invites_class->add_invitation( $invite_args );
+
+                // Check that both the request and invitation are marked 'accepted'.
+                $get_invites = array(
+                        'user_id'          => $u2,
+                        'type'             => 'all',
+                        'accepted'         => 'accepted',
+                        'fields'           => 'ids'
+                );
+                $invites = $invites_class->get_invitations( $get_invites );
+                $this->assertEqualSets( array( $r1, $i1 ), $invites );
+
+                $this->set_current_user( $old_current_user );
+        }
+
+}

tests/phpunit/testcases/groups/class-bp-groups-group.php

@@ -1372 +1372 @@
          */
         public function test_get_group_extras_invited() {
                 $u = self::factory()->user->create();
-                $g = self::factory()->group->create();
+                $u2 = self::factory()->user->create();
+                $g = self::factory()->group->create( array( 'creator_id' => $u2, 'status' => 'private' ) );
 
-                $invite                = new BP_Groups_Member;
-                $invite->group_id      = $g;
-                $invite->user_id       = $u;
-                $invite->date_modified = bp_core_current_time();
-                $invite->invite_sent   = true;
-                $invite->is_confirmed  = false;
-                $invite->save();
+                // Outstanding invitations should be left intact.
+                groups_invite_user( array(
+                        'user_id' => $u,
+                        'group_id' => $g,
+                        'inviter_id' => $u2,
+                        'send_invite' => 1,
+                ) );
 
                 $paged_groups = array();
                 $paged_groups[] = new stdClass;
@@ -1411 +1412 @@
          */
         public function test_get_group_extras_pending() {
                 $u = self::factory()->user->create();
-                $g = self::factory()->group->create();
+                $g = self::factory()->group->create( array( 'status' => 'private' ) );
 
-                $invite                = new BP_Groups_Member;
-                $invite->group_id      = $g;
-                $invite->user_id       = $u;
-                $invite->date_modified = bp_core_current_time();
-                $invite->invite_sent   = false;
-                $invite->is_confirmed  = false;
-                $invite->save();
+                // Create membership request
+                groups_send_membership_request( array(
+                        'user_id'       => $u,
+                        'group_id'      => $g,
+                ) );
 
                 $paged_groups = array();
                 $paged_groups[] = new stdClass;

tests/phpunit/testcases/groups/class-bp-groups-member.php

@@ -20 +20 @@
                 array_map( 'groups_delete_group', self::$group_ids );
         }
 
-        public static function invite_user_to_group( $user_id, $group_id, $inviter_id ) {
-                $invite                = new BP_Groups_Member;
-                $invite->group_id      = $group_id;
-                $invite->user_id       = $user_id;
-                $invite->date_modified = bp_core_current_time();
-                $invite->inviter_id    = $inviter_id;
-                $invite->is_confirmed  = 0;
-                $invite->invite_sent   = 1;
-
-                $invite->save();
-                return $invite->id;
-        }
-
-        public static function create_group_membership_request( $user_id, $group_id ) {
-                $request                = new BP_Groups_Member;
-                $request->group_id      = $group_id;
-                $request->user_id       = $user_id;
-                $request->date_modified = bp_core_current_time();
-                $request->inviter_id    = 0;
-                $request->is_confirmed  = 0;
-
-                $request->save();
-                return $request->id;
-        }
-
         public function test_get_recently_joined_with_filter() {
                 $g1 = self::factory()->group->create( array(
                         'name' => 'Tab',
@@ -133 +108 @@
         }
 
         public function test_get_invites_with_exclude() {
+                $u1 = self::factory()->user->create();
+                $u2 = self::factory()->user->create();
                 $g1 = self::factory()->group->create( array(
-                        'name' => 'RC Cola',
+                        'status' => 'private',
+                        'creator_id' => $u1
                 ) );
                 $g2 = self::factory()->group->create( array(
-                        'name' => 'Pepsi',
+                        'status' => 'private',
+                        'creator_id' => $u1
                 ) );
 
-                $u1 = self::factory()->user->create();
-                $u2 = self::factory()->user->create();
-                self::add_user_to_group( $u1, $g1 );
-                self::add_user_to_group( $u1, $g2 );
-                self::invite_user_to_group( $u2, $g1, $u1 );
-                self::invite_user_to_group( $u2, $g2, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g1,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g2,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
 
                 $groups = BP_Groups_Member::get_invites( $u2, false, false, array( 'awesome', $g1 ) );
 
@@ -282 +267 @@
                 ) );
 
                 // Membership requests should be removed.
-                self::create_group_membership_request( $u1, $g );
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g
+                ) );
+
                 groups_reject_membership_request( null, $u1, $g );
                 $u1_has_request = groups_check_for_membership_request( $u1, $g );
                 $this->assertEquals( 0, $u1_has_request );
@@ -325 +314 @@
                 ) );
 
                 // Outstanding invitations should be left intact.
-                self::invite_user_to_group( $u2, $g, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
                 groups_reject_membership_request( null, $u2, $g );
                 $u2_has_invite = groups_check_user_has_invite( $u2, $g );
                 $this->assertTrue( is_numeric( $u2_has_invite ) && $u2_has_invite > 0 );
@@ -343 +337 @@
                 ) );
 
                 // Membership requests should be removed.
-                self::create_group_membership_request( $u1, $g );
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g
+                ) );
                 groups_delete_membership_request( null, $u1, $g );
                 $u1_has_request = groups_check_for_membership_request( $u1, $g );
                 $this->assertEquals( 0, $u1_has_request );
@@ -386 +383 @@
                 ) );
 
                 // Outstanding invitations should be left intact.
-                self::invite_user_to_group( $u2, $g, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+
                 groups_delete_membership_request( null, $u2, $g );
                 $u2_has_invite = groups_check_user_has_invite( $u2, $g );
                 $this->assertTrue( is_numeric( $u2_has_invite ) && $u2_has_invite > 0 );
@@ -410 +413 @@
                 ) );
 
                 // The invitation should be removed.
-                self::invite_user_to_group( $u2, $g, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+
                 groups_reject_invite( $u2, $g );
                 $u2_has_invite = groups_check_user_has_invite( $u2, $g, 'all' );
                 $this->assertEquals( 0, $u2_has_invite );
@@ -450 +459 @@
                 ) );
 
                 // Membership requests should be left intact.
-                self::create_group_membership_request( $u1, $g );
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g
+                ) );
                 groups_reject_invite( $u1, $g );
                 $u1_has_request = groups_check_for_membership_request( $u1, $g );
                 $this->assertTrue( is_numeric( $u1_has_request ) && $u1_has_request > 0 );
@@ -474 +486 @@
                 ) );
 
                 // The invitation should be removed.
-                self::invite_user_to_group( $u2, $g, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+
                 groups_delete_invite( $u2, $g );
                 $u2_has_invite = groups_check_user_has_invite( $u2, $g, 'all' );
                 $this->assertEquals( 0, $u2_has_invite );
@@ -547 +565 @@
                 ) );
 
                 // Membership requests should be left intact.
-                self::create_group_membership_request( $u1, $g );
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g
+                ) );
                 groups_delete_invite( $u1, $g );
                 $u1_has_request = groups_check_for_membership_request( $u1, $g );
                 $this->assertTrue( is_numeric( $u1_has_request ) && $u1_has_request > 0 );
@@ -571 +592 @@
                 ) );
 
                 // The invitation should be removed.
-                self::invite_user_to_group( $u2, $g, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
                 groups_uninvite_user( $u2, $g );
                 $u2_has_invite = groups_check_user_has_invite( $u2, $g, 'all' );
                 $this->assertEquals( 0, $u2_has_invite );
@@ -612 +638 @@
                 ) );
 
                 // Membership requests should be left intact.
-                self::create_group_membership_request( $u1, $g );
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g
+                ) );
                 groups_uninvite_user( $u1, $g );
                 $u1_has_request = groups_check_for_membership_request( $u1, $g );
                 $this->assertTrue( is_numeric( $u1_has_request ) && $u1_has_request > 0 );
@@ -672 +701 @@
                 $m1 = new BP_Groups_Member( $u1, $g );
                 $m1->promote( 'admin' );
 
-                self::invite_user_to_group( $u2, $g, $u1 );
-
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
                 groups_join_group( $g, $u2 );
                 // Upon joining the group, outstanding invitations should be cleaned up.
                 $this->assertEquals( null, groups_check_user_has_invite( $u2, $g, 'any' ) );
@@ -686 +719 @@
         public function test_groups_join_group_cleanup_requests() {
                 $u1 = self::factory()->user->create();
                 $g = self::factory()->group->create();
-                self::create_group_membership_request( $u1, $g );
+
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g
+                ) );
 
                 groups_join_group( $g, $u1 );
                 // Upon joining the group, outstanding requests should be cleaned up.
@@ -825 +862 @@
         public function test_groups_get_invites_for_user() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
-                $g2 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
-                $g3 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
-
-                self::invite_user_to_group( $u2, $g1, $u1 );
-                self::invite_user_to_group( $u2, $g2, $u1 );
-                self::invite_user_to_group( $u2, $g3, $u1 );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
+                $g2 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
+                $g3 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g1,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g2,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g3,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
                 $groups = groups_get_invites_for_user( $u2 );
 
                 $this->assertEqualSets( array( $g1, $g2, $g3 ), wp_list_pluck( $groups['groups'], 'id' ) );
@@ -848 +899 @@
 
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
-                $g2 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
-                $g3 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
+                $g2 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
+                $g3 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
-                self::invite_user_to_group( $u2, $g1, $u1 );
-                self::invite_user_to_group( $u2, $g2, $u1 );
-                self::invite_user_to_group( $u2, $g3, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g1,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g2,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g3,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
 
                 $this->set_current_user( $u2 );
                 $groups = groups_get_invites_for_user();
@@ -871 +937 @@
         public function test_groups_get_invites_for_user_with_exclude() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
-                $g2 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
-                $g3 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
+                $g2 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
+                $g3 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
-                self::invite_user_to_group( $u2, $g1, $u1 );
-                self::invite_user_to_group( $u2, $g2, $u1 );
-                self::invite_user_to_group( $u2, $g3, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g1,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g2,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g3,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
 
                 $groups = groups_get_invites_for_user( $u2, false, false, array( $g2 ) );
                 $this->assertEqualSets( array( $g1, $g3 ), wp_list_pluck( $groups['groups'], 'id' ) );
@@ -891 +972 @@
         public function test_groups_get_invite_count_for_user() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
-                $g2 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
-                $g3 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
+                $g2 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
+                $g3 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
-                self::invite_user_to_group( $u2, $g1, $u1 );
-                self::invite_user_to_group( $u2, $g2, $u1 );
-                self::invite_user_to_group( $u2, $g3, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g1,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g2,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g3,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
 
                 $this->assertEquals( 3, groups_get_invite_count_for_user( $u2 ) );
         }
@@ -910 +1006 @@
         public function test_groups_get_invite_count_for_user_ignore_drafts() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create draft invitation.
                 groups_invite_user( array(
@@ -933 +1029 @@
         public function test_groups_invite_user() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create draft invitation
                 groups_invite_user( array(
@@ -957 +1053 @@
         public function test_groups_send_invites() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create draft invitation
                 groups_invite_user( array(
@@ -969 +1065 @@
                 ) );
 
                 // Send the invitation
-                groups_send_invites( $u1, $g1 );
+                groups_send_invites( array(
+                        'group_id'   => $g1,
+                        'inviter_id' => $u1,
+                ) );
 
                 // Check that the invitation has been sent.
                 $sent = groups_check_user_has_invite( $u2, $g1, $type = 'sent' );
@@ -977 +1076 @@
         }
 
         /**
-         * @group groups_accept_invite
+         * @group groups_send_invites
          * @group group_invitations
          * @group group_membership
+         * @expectedDeprecated groups_send_invites
          */
-        public function test_groups_accept_invite() {
+        public function test_groups_send_invites_deprecated_args() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create draft invitation
                 groups_invite_user( array(
@@ -998 +1098 @@
                 // Send the invitation
                 groups_send_invites( $u1, $g1 );
 
+                // Check that the invitation has been sent.
+                $sent = groups_check_user_has_invite( $u2, $g1, $type = 'sent' );
+                $this->assertTrue( is_numeric( $sent ) && $sent > 0 );
+        }
+
+        /**
+         * @group groups_accept_invite
+         * @group group_invitations
+         * @group group_membership
+         */
+        public function test_groups_accept_invite() {
+                $u1 = self::factory()->user->create();
+                $u2 = self::factory()->user->create();
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
+
+                // Create draft invitation
+                groups_invite_user( array(
+                        'user_id'       => $u2,
+                        'group_id'      => $g1,
+                        'inviter_id'    => $u1,
+                        'date_modified' => bp_core_current_time(),
+                        'is_confirmed'  => 0,
+                        'send_invite'   => 1
+                ) );
+
                 // Accept the invitation
                 groups_accept_invite( $u2, $g1 );
 
@@ -1017 +1142 @@
         public function test_groups_accept_invite_removes_membership_requests() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create draft invitation
                 groups_invite_user( array(
@@ -1029 +1154 @@
                 ) );
 
                 // Create membership request
-                groups_send_membership_request( $u2, $g1 );
+                $request_id = groups_send_membership_request( array(
+                        'user_id'       => $u2,
+                        'group_id'      => $g1,
+                ) );
+
                 $request = groups_check_for_membership_request( $u2, $g1 );
+
                 $this->assertTrue( is_numeric( $request ) && $request > 0 );
 
                 // Send the invitation
-                groups_send_invites( $u1, $g1 );
+                groups_send_invites( array(
+                        'group_id'   => $g1,
+                        'inviter_id' => $u1,
+                ) );
 
                 // Accept the invitation
                 groups_accept_invite( $u2, $g1 );
@@ -1052 +1185 @@
         public function test_groups_sent_invite_plus_request_equals_member() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create draft invitation
                 groups_invite_user( array(
@@ -1060 +1193 @@
                         'group_id'      => $g1,
                         'inviter_id'    => $u1,
                         'date_modified' => bp_core_current_time(),
-                        'is_confirmed'  => 0
+                        'is_confirmed'  => 0,
+                        'send_invite'   => 1
                 ) );
 
-                // Send the invitation
-                groups_send_invites( $u1, $g1 );
-
                 // Create membership request
-                groups_send_membership_request( $u2, $g1 );
+                groups_send_membership_request( array(
+                        'user_id' => $u2,
+                        'group_id' => $g1
+                ) );
 
                 // User should now be a group member
                 $member = groups_is_user_member( $u2, $g1 );
@@ -1083 +1217 @@
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
                 $u3 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
-                self::invite_user_to_group( $u2, $g1, $u1 );
-                self::invite_user_to_group( $u3, $g1, $u1 );
+                groups_invite_user( array(
+                        'user_id' => $u2,
+                        'group_id' => $g1,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
+                groups_invite_user( array(
+                        'user_id' => $u3,
+                        'group_id' => $g1,
+                        'inviter_id' => $u1,
+                        'send_invite' => 1,
+                ) );
 
                 groups_delete_all_group_invites( $g1 );
 
                 // Get group invitations of any type, from any user in the group.
-                $invitees = new BP_Group_Member_Query( array(
+
+                $invitees = groups_get_invites( array(
                         'group_id'     => $g1,
-                        'is_confirmed' => 0,
-                        'invite_sent'  => null,
-                        'inviter_id'   => 'any',
+                        'invite_sent'  => 'all',
                 ) );
 
-                $this->assertTrue( empty( $invitees->results ) );
+                $this->assertTrue( empty( $invitees ) );
         }
 
         /**
@@ -1129 +1272 @@
          */
         public function test_groups_send_invites_fail_on_empty_user_id() {
                 $u1 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create draft invitation with empty inviter_id
                 $invite_created = groups_invite_user( array(
@@ -1151 +1294 @@
         public function test_groups_send_invites_fail_on_empty_inviter_id() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create draft invitation with empty inviter_id
                 $invite_created = groups_invite_user( array(
@@ -1174 +1317 @@
         public function test_groups_get_invites_for_group_with_sent_parameter() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create draft invitation
                 groups_invite_user( array(
@@ -1182 +1325 @@
                         'group_id'      => $g1,
                         'inviter_id'    => $u1,
                         'date_modified' => bp_core_current_time(),
-                        'is_confirmed'  => 0
+                        'is_confirmed'  => 0,
+                        'send_invite'   => 1
                 ) );
 
-                // Send the invitation; this will set the 'invite_sent' value to 1.
-                groups_send_invites( $u1, $g1 );
-
                 // Default groups_get_invites_for_group() call
                 $i = groups_get_invites_for_group( $u1, $g1 );
                 $this->assertEqualSets( array( $u2 ), $i );
@@ -1208 +1349 @@
          */
         public function test_groups_send_membership_request() {
                 $u1 = self::factory()->user->create();
-                $g1 = self::factory()->group->create();
+                $g1 = self::factory()->group->create( array( 'status' => 'private' ) );
+
+                // Create membership request
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g1
+                ) );
+
+                $request = groups_check_for_membership_request( $u1, $g1 );
+                $this->assertTrue( is_numeric( $request ) && $request > 0 );
+        }
+
+        /**
+         * @group groups_send_membership_request
+         * @group group_membership_requests
+         * @group group_membership
+         * @expectedDeprecated groups_send_membership_request
+         */
+        public function test_groups_send_membership_request_deprecated_args() {
+                $u1 = self::factory()->user->create();
+                $g1 = self::factory()->group->create( array( 'status' => 'private' ) );
 
                 // Create membership request
                 groups_send_membership_request( $u1, $g1 );
@@ -1224 +1385 @@
          */
         public function test_groups_accept_membership_request_by_membership_id() {
                 $u1 = self::factory()->user->create();
-                $g1 = self::factory()->group->create();
+                $g1 = self::factory()->group->create( array( 'status' => 'private' ) );
 
                 // Create membership request
-                groups_send_membership_request( $u1, $g1 );
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g1
+                ) );
 
                 // Get group invitations of any type, from any user in the group.
                 $member = new BP_Groups_Member( $u1, $g1 );
 
-                groups_accept_membership_request( $member->id );
+                groups_accept_membership_request( false, $u1, $g1 );
 
                 // User should now be a group member.
                 $member = groups_is_user_member( $u1, $g1 );
@@ -1247 +1411 @@
          */
         public function test_groups_accept_membership_request_by_user_id_group_id() {
                 $u1 = self::factory()->user->create();
-                $g1 = self::factory()->group->create();
+                $g1 = self::factory()->group->create( array( 'status' => 'private' ) );
 
                 // Create membership request
-                groups_send_membership_request( $u1, $g1 );
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g1
+                ) );
 
                 groups_accept_membership_request( null, $u1, $g1 );
 
@@ -1268 +1435 @@
         public function test_groups_membership_request_plus_invite_equals_member() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g1 = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g1 = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // Create membership request
-                groups_send_membership_request( $u2, $g1 );
+                groups_send_membership_request( array(
+                        'user_id' => $u2,
+                        'group_id' => $g1
+                ) );
 
                 // Create draft invitation
                 groups_invite_user( array(
@@ -1279 +1449 @@
                         'group_id'      => $g1,
                         'inviter_id'    => $u1,
                         'date_modified' => bp_core_current_time(),
-                        'is_confirmed'  => 0
+                        'is_confirmed'  => 0,
+                        'send_invite'   => 1
                 ) );
 
-                // Send the invitation
-                groups_send_invites( $u1, $g1 );
-
                 // User should now be a group member
                 $member = groups_is_user_member( $u2, $g1 );
                 $this->assertTrue( is_numeric( $member ) && $member > 0 );
@@ -1299 +1467 @@
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
                 $u3 = self::factory()->user->create();
-                $g1 = self::factory()->group->create();
+                $g1 = self::factory()->group->create( array( 'status' => 'private' ) );
 
                 // Create membership request
-                groups_send_membership_request( $u1, $g1 );
-                groups_send_membership_request( $u2, $g1 );
-                groups_send_membership_request( $u3, $g1 );
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g1
+                ) );
+                groups_send_membership_request( array(
+                        'user_id' => $u2,
+                        'group_id' => $g1
+                ) );
+                groups_send_membership_request( array(
+                        'user_id' => $u3,
+                        'group_id' => $g1
+                ) );
 
                 groups_accept_all_pending_membership_requests( $g1 );
 
@@ -1402 +1579 @@
                 $this->assertSame( self::$group_ids[0], $memberships[0]->group_id );
         }
 
-        /**
-         * @ticket BP7859
-         */
-        public function test_get_user_memberships_type_pending_request() {
-                groups_join_group( self::$group_ids[0], self::$user_ids[0] );
-                groups_send_membership_request( self::$user_ids[0], self::$group_ids[1] );
-
-                $memberships = BP_Groups_Member::get_user_memberships( self::$user_ids[0], array(
-                        'type' => 'pending_request',
-                ) );
-
-                $this->assertCount( 1, $memberships );
-                $this->assertSame( self::$group_ids[1], $memberships[0]->group_id );
-        }
-
-        /**
-         * @ticket BP7859
-         */
-        public function test_get_user_memberships_type_pending_received_invitation() {
-                groups_join_group( self::$group_ids[0], self::$user_ids[0] );
-                groups_invite_user( array(
-                        'user_id'    => self::$user_ids[0],
-                        'group_id'   => self::$group_ids[1],
-                        'inviter_id' => self::$user_ids[1],
-                ) );
-
-                $memberships = BP_Groups_Member::get_user_memberships( self::$user_ids[0], array(
-                        'type' => 'pending_received_invitation',
-                ) );
-
-                $this->assertCount( 1, $memberships );
-                $this->assertSame( self::$group_ids[1], $memberships[0]->group_id );
-        }
-
-        /**
-         * @ticket BP7859
-         */
-        public function test_get_user_memberships_type_pending_sent_invitation() {
-                groups_join_group( self::$group_ids[0], self::$user_ids[0] );
-                groups_invite_user( array(
-                        'user_id'    => self::$user_ids[1],
-                        'group_id'   => self::$group_ids[1],
-                        'inviter_id' => self::$user_ids[0],
-                ) );
-
-                $memberships = BP_Groups_Member::get_user_memberships( self::$user_ids[0], array(
-                        'type' => 'pending_sent_invitation',
-                ) );
-
-                $this->assertCount( 1, $memberships );
-                $this->assertSame( self::$group_ids[1], $memberships[0]->group_id );
-        }
-
         /**
          * @ticket BP7476
          */

tests/phpunit/testcases/groups/functions.php

@@ -12 +12 @@
                 self::$user_ids  = $factory->user->create_many( 3 );
                 self::$group_ids = $factory->group->create_many( 2, array(
                         'creator_id' => self::$user_ids[2],
+                        'status'     => 'private'
                 ) );
         }
 
@@ -138 +139 @@
                 $this->set_current_user( $u2 );
 
                 $g = self::factory()->group->create();
-                groups_send_membership_request( $u1, $g );
+                groups_send_membership_request( array(
+                        'user_id'       => $u1,
+                        'group_id'      => $g,
+                ) );
 
                 groups_accept_membership_request( 0, $u1, $g );
 
@@ -262 +266 @@
                 $u2 = self::factory()->user->create();
                 $g = self::factory()->group->create( array( 'creator_id' => $u1 ) );
 
-                groups_send_membership_request( $u2, $g );
+                groups_send_membership_request( array(
+                        'user_id'       => $u2,
+                        'group_id'      => $g,
+                ) );
                 groups_accept_membership_request( 0, $u2, $g );
 
                 $this->assertEquals( 2, groups_get_groupmeta( $g, 'total_member_count' ) );
@@ -632 +639 @@
         public function test_get_invite_count_for_user() {
                 $u1 = self::factory()->user->create();
                 $u2 = self::factory()->user->create();
-                $g = self::factory()->group->create( array( 'creator_id' => $u1 ) );
+                $g = self::factory()->group->create( array( 'creator_id' => $u1, 'status' => 'private' ) );
 
                 // create invitation
                 groups_invite_user( array(
                         'user_id'    => $u2,
                         'group_id'   => $g,
                         'inviter_id' => $u1,
+                        'send_invite' => 1
                 ) );
 
-                // send the invite
-                // this function is imperative to set the 'invite_sent' flag in the DB
-                // why is this separated from groups_invite_user()?
-                // @see groups_screen_group_invite()
-                groups_send_invites( $u1, $g );
-
                 // assert invite count
                 $this->assertEquals( 1, groups_get_invite_count_for_user( $u2 ) );
 
@@ -890 +892 @@
          * @ticket BP7698
          */
         public function test_bp_groups_pending_requests_personal_data_exporter() {
-                groups_send_membership_request( self::$user_ids[0], self::$group_ids[0] );
+                groups_send_membership_request( array(
+                        'user_id'       => self::$user_ids[0],
+                        'group_id'      => self::$group_ids[0],
+                ) );
 
                 $test_user = new WP_User( self::$user_ids[0] );
 

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 ) ) {
@@ -541 +545 @@
                 $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],
+                ) );
 
                 // Populate cache.
                 $g1 = bp_get_user_groups( self::$user );
 
                 $m = new BP_Groups_Member( self::$user, self::$groups[2] );
 
-                groups_accept_membership_request( $m->id, self::$user, self::$groups[2] );
+                groups_accept_membership_request( false, self::$user, self::$groups[2] );
 
                 // For `wp_mail()`.
                 if ( is_null( $server_name ) ) {

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

@@ -21 +21 @@
                 ) );
                 self::$groups = $f->group->create_many( 3, array(
                         'creator_id' => self::$admin_user,
+                        'status'     => 'private'
                 ) );
 
                 $now = time();
@@ -173 +174 @@
                 $i = groups_invite_user( array(
                         'user_id' => self::$user,
                         'group_id' => self::$groups[1],
-                        'inviter_id' => 123,
+                        'inviter_id' => self::$admin_user,
+                        'send_invite' => 1,
                 ) );
 
-                // Send invite.
-                $m = new BP_Groups_Member( self::$user, self::$groups[1] );
-                $m->invite_sent = 1;
-                $m->save();
-
                 $this->assertNotEmpty( groups_is_user_invited( self::$user, self::$groups[1] ) );
         }
 
-        public function test_groups_is_user_pending_should_return_false_for_pending_member() {
+        public function test_groups_is_user_pending_should_return_false_for_invited_member() {
                 groups_invite_user( array(
                         'user_id' => self::$user,
                         'group_id' => self::$groups[1],
-                        'inviter_id' => 123,
+                        'send_invite' => 1
                 ) );
 
-                // Send invite.
-                $m = new BP_Groups_Member( self::$user, self::$groups[1] );
-                $m->invite_sent = 1;
-                $m->save();
-
                 $this->assertEquals( false, groups_is_user_pending( self::$user, self::$groups[1] ) );
         }
 
@@ -204 +196 @@
         }
 
         public function test_groups_is_user_pending_should_return_true_for_pending_member() {
-
-                $m                = new BP_Groups_Member;
-                $m->group_id      = self::$groups[1];
-                $m->user_id       = self::$user;
-                $m->inviter_id    = 0;
-                $m->is_admin      = 0;
-                $m->user_title    = '';
-                $m->date_modified = bp_core_current_time();
-                $m->is_confirmed  = 0;
-                $m->comments      = 'request';
-                $m->save();
+                groups_send_membership_request( array(
+                        'user_id' => self::$user,
+                        'group_id' => self::$groups[1],
+                ) );
 
                 $this->assertNotEmpty( groups_is_user_pending( self::$user, self::$groups[1] ) );
         }

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 );

tests/phpunit/testcases/groups/template/bpGroupStatusMessage.php

@@ -98 +98 @@
 
                 $this->set_current_user( $u );
 
-                groups_send_membership_request( $u, $g );
+                groups_send_membership_request( array(
+                        'user_id'  => $u,
+                        'group_id' => $g
+                ) );
 
                 if ( bp_has_groups( array( 'include' => array( $g ) ) ) ) {
                         while ( bp_groups() ) {
@@ -141 +144 @@
                 $GLOBALS['groups_template'] = new stdClass;
                 $GLOBALS['groups_template']->group = groups_get_group( $groups[0] );
 
-                groups_send_membership_request( $u, $groups[1] );
+                groups_send_membership_request( array(
+                        'user_id' => $u,
+                        'group_id' => $groups[1]
+                ) );
 
                 $group1 = groups_get_group( array(
                         'group_id' => $groups[1],

tests/phpunit/testcases/groups/user_can.php

@@ -108 +108 @@
                         'status'      => 'private'
                 ) );
                 $u1 = $this->factory->user->create();
-                groups_send_membership_request( $u1, $g1 );
+                groups_send_membership_request( array(
+                        'user_id' => $u1,
+                        'group_id' => $g1
+                ) );
 
                 $this->assertFalse( bp_user_can( $u1, 'groups_request_membership', array( 'group_id' => $g1 ) ) );
         }