Ticket #6482: 6482.01.patch

src/bp-activity/bp-activity-actions.php

@@ -833 +833 @@
         }
 }
 add_action( 'transition_post_status', 'bp_activity_catch_transition_post_type_status', 10, 3 );
+
+/**
+ * When a blog comment status transition occurs, update the relevant activity's status.
+ *
+ * @since BuddyPress (2.4.0)
+ *
+ * @param string $new_status New comment status.
+ * @param string $old_status Previous comment status.
+ * @param object $comment Comment data.
+ */
+function bp_activity_transition_post_type_comment_status( $new_status, $old_status, $comment ) {
+        $post_type = get_post_type( $comment->comment_post_ID );
+        if ( ! $post_type ) {
+                return;
+        }
+
+        // Get the post type tracking args.
+        $activity_post_object = bp_activity_get_post_type_tracking_args( $post_type );
+
+        // Bail if the activity action does not exist
+        if ( empty( $activity_post_object->comments_tracking->action_id ) ) {
+                return false;
+
+        // Set the $activity_comment_object
+        } else {
+                $activity_comment_object = $activity_post_object->comments_tracking;
+        }
+
+        /**
+         * Activity currently doesn't have any concept of a trash, or an unapproved/approved state.
+         *
+         * If a blog comment transitions to a "delete" or "hold" status, delete the activity item.
+         * If a blog comment transitions to trashed, or spammed, mark the activity as spam.
+         * If a blog comment transitions to approved (and the activity exists), mark the activity as ham.
+         * If a blog comment transitions to unapproved (and the activity exists), mark the activity as spam.
+         * Otherwise, record the comment into the activity stream.
+         */
+
+        // This clause handles delete/hold.
+        if ( in_array( $new_status, array( 'delete', 'hold' ) ) ) {
+                return bp_activity_post_type_remove_comment( $comment->comment_ID, $activity_post_object );
+
+        // These clauses handle trash, spam, and un-spams.
+        } elseif ( in_array( $new_status, array( 'trash', 'spam', 'unapproved' ) ) ) {
+                $action = 'spam_activity';
+        } elseif ( 'approved' == $new_status ) {
+                $action = 'ham_activity';
+        }
+
+        // Get the activity
+        if ( bp_disable_blogforum_comments() ) {
+                $activity_id = bp_activity_get_activity_id( array(
+                        'component'         => $activity_comment_object->component_id,
+                        'item_id'           => get_current_blog_id(),
+                        'secondary_item_id' => $comment->comment_ID,
+                        'type'              => $activity_comment_object->action_id,
+                ) );
+        } else {
+                $activity_id = get_comment_meta( $comment->comment_ID, 'bp_activity_comment_id', true );
+        }
+
+        // Check activity item exists
+        if ( empty( $activity_id ) ) {
+                // If no activity exists, but the comment has been approved, record it into the activity table.
+                if ( 'approved' == $new_status ) {
+                        return bp_activity_post_type_comment( $comment->comment_ID, true, $activity_post_object );
+                }
+
+                return;
+        }
+
+        // Create an activity object
+        $activity = new BP_Activity_Activity( $activity_id );
+        if ( empty( $activity->component ) ) {
+                return;
+        }
+
+        // Spam/ham the activity if it's not already in that state
+        if ( 'spam_activity' === $action && ! $activity->is_spam ) {
+                bp_activity_mark_as_spam( $activity );
+        } elseif ( 'ham_activity' == $action) {
+                bp_activity_mark_as_ham( $activity );
+        }
+
+        // Add "new_post_type_comment" to the whitelisted activity types, so that the activity's Akismet history is generated
+        $post_type_comment_action = $activity_comment_object->action_id;
+        $comment_akismet_history = create_function( '$t', '$t[] = $post_type_comment_action; return $t;' );
+        add_filter( 'bp_akismet_get_activity_types', $comment_akismet_history );
+
+        // Save the updated activity
+        $activity->save();
+
+        // Remove the "new_blog_comment" activity type whitelist so we don't break anything
+        remove_filter( 'bp_akismet_get_activity_types', $comment_akismet_history );
+}
+add_action( 'transition_comment_status', 'bp_activity_transition_post_type_comment_status', 10, 3 );

src/bp-activity/bp-activity-functions.php

@@ -425 +425 @@
                 return false;
         }
 
+        $activity_labels = array(
+                /* Post labels */
+                'bp_activity_admin_filter',
+                'bp_activity_front_filter',
+                'bp_activity_new_post',
+                'bp_activity_new_post_ms',
+                /* Comment labels */
+                'bp_activity_comments_admin_filter',
+                'bp_activity_comments_front_filter',
+                'bp_activity_new_comment',
+                'bp_activity_new_comment_ms'
+        );
+
         // Labels are loaded into the post type object.
-        foreach ( array( 'bp_activity_admin_filter', 'bp_activity_front_filter', 'bp_activity_new_post', 'bp_activity_new_post_ms' ) as $label_type ) {
+        foreach ( $activity_labels as $label_type ) {
                 if ( ! empty( $args[ $label_type ] ) ) {
                         $wp_post_types[ $post_type ]->labels->{$label_type} = $args[ $label_type ];
                         unset( $args[ $post_type ] );
@@ -453 +466 @@
                 return false;
         }
 
-        $post_type_object = get_post_type_object( $post_type );
+        $post_type_object           = get_post_type_object( $post_type );
+        $post_type_support_comments = post_type_supports( $post_type, 'comments' );
 
         $post_type_activity = array(
-                'component_id'      => buddypress()->activity->id,
-                'action_id'         => 'new_' . $post_type,
-                'format_callback'   => 'bp_activity_format_activity_action_custom_post_type_post',
-                'front_filter'      => $post_type_object->labels->name,
-                'contexts'          => array( 'activity' ),
-                'position'          => 0,
-                'singular'          => strtolower( $post_type_object->labels->singular_name ),
-                'activity_comment' => ! post_type_supports( $post_type, 'comments' ),
+                'component_id'            => buddypress()->activity->id,
+                'action_id'               => 'new_' . $post_type,
+                'format_callback'         => 'bp_activity_format_activity_action_custom_post_type_post',
+                'front_filter'            => $post_type_object->labels->name,
+                'contexts'                => array( 'activity' ),
+                'position'                => 0,
+                'singular'                => strtolower( $post_type_object->labels->singular_name ),
+                'activity_comment'        => ! $post_type_support_comments,
+                'comment_action_id'       => false,
+                'comment_format_callback' => 'bp_activity_format_activity_action_custom_post_type_comment',
         );
 
         if ( ! empty( $post_type_object->bp_activity ) ) {
@@ -496 +512 @@
                 $post_type_activity->new_post_type_action_ms = $post_type_object->labels->bp_activity_new_post_ms;
         }
 
+        // If the post type supports comments and has a comment action id, build the comments tracking args
+        if ( $post_type_support_comments && ! empty( $post_type_activity->comment_action_id ) ) {
+                // Init a new container for the activity action for comments
+                $post_type_activity->comments_tracking = new stdClass();
+
+                // Build the activity action for comments
+                $post_type_activity->comments_tracking->component_id = $post_type_activity->component_id;
+                $post_type_activity->comments_tracking->action_id    = $post_type_activity->comment_action_id;
+
+                // Try to get the comments admin filter from the post type labels.
+                if ( ! empty( $post_type_object->labels->bp_activity_comments_admin_filter ) ) {
+                        $post_type_activity->comments_tracking->admin_filter = $post_type_object->labels->bp_activity_comments_admin_filter;
+
+                // Fall back to a generic name.
+                } else {
+                        $post_type_activity->comments_tracking->admin_filter = _x( 'New item comment posted', 'Post Type generic comments activity admin filter', 'buddypress' );
+                }
+
+                $post_type_activity->comments_tracking->format_callback = $post_type_activity->comment_format_callback;
+
+                // Check for the comments front filter in the post type labels.
+                if ( ! empty( $post_type_object->labels->bp_activity_comments_front_filter ) ) {
+                        $post_type_activity->comments_tracking->front_filter = $post_type_object->labels->bp_activity_comments_front_filter;
+
+                // Fall back to a generic name.
+                } else {
+                        $post_type_activity->comments_tracking->front_filter = sprintf( __( '%s comments', 'buddypress' ), $post_type_object->labels->singular_name );
+                }
+
+                $post_type_activity->comments_tracking->contexts = $post_type_activity->contexts;
+                $post_type_activity->comments_tracking->position = (int) $post_type_activity->position + 1;
+
+                // Try to get the action for new post type comment action on non-multisite installations.
+                if ( ! empty( $post_type_object->labels->bp_activity_new_comment ) ) {
+                        $post_type_activity->comments_tracking->new_post_type_comment_action = $post_type_object->labels->bp_activity_new_comment;
+                }
+
+                // Try to get the action for new post type comment action on multisite installations.
+                if ( ! empty( $post_type_object->labels->bp_activity_new_comment_ms ) ) {
+                        $post_type_activity->comments_tracking->new_post_type_comment_action_ms = $post_type_object->labels->bp_activity_new_comment_ms;
+                }
+        }
+
         /**
          * Filters tracking arguments for a specific post type.
          *
@@ -524 +583 @@
                 $track_post_type = bp_activity_get_post_type_tracking_args( $post_type );
 
                 if ( ! empty( $track_post_type ) ) {
+                        // Set the post type comments tracking args
+                        if ( ! empty( $track_post_type->comments_tracking->action_id ) ) {
+                                // Used to check support for comment tracking by activity action (new_post_type_comment)
+                                $track_post_type->comments_tracking->comments_tracking = true;
+
+                                $post_types_tracking_args[ $track_post_type->comments_tracking->action_id ] = $track_post_type->comments_tracking;
+
+                                // Used to check support for comment tracking by activity action (new_post_type)
+                                $track_post_type->comments_tracking = true;
+                        }
+
                         $post_types_tracking_args[ $track_post_type->action_id ] = $track_post_type;
                 }
 
@@ -541 +611 @@
 }
 
 /**
+ * Helper function to check if the activity action is about a "parent" post type activity
+ * supporting comments tracking
+ *
+ * @since BuddyPress (2.4.0)
+ *
+ * @param  string $action_id the activity action to check
+ * @return bool   true if it's a parent post type activity supporting comments
+ *                false otherwise
+ */
+function bp_activity_action_is_post_tracking_action( $action_id ) {
+        if ( empty( $action_id ) ) {
+                return false;
+        }
+
+        $bp = buddypress();
+
+        $retval = bp_activity_action_supports_comments_tracking( $action_id );
+
+        if ( empty( $retval ) ) {
+                return $retval;
+        }
+
+        return ! empty( $bp->activity->track[ $action_id ]->comment_action_id );
+}
+
+/**
+ * Helper function to check if the activity action is supporting comments tracking
+ *
+ * @since BuddyPress (2.4.0)
+ *
+ * @param  string $action_id the activity action to check
+ * @return bool   true activity action supports comments tracking
+ *                false otherwise
+ */
+function bp_activity_action_supports_comments_tracking( $action_id ) {
+        if ( empty( $action_id ) ) {
+                return false;
+        }
+
+        $bp = buddypress();
+
+        // Set the activity track global if not set yet
+        if ( empty( $bp->activity->track ) ) {
+                $bp->activity->track = bp_activity_get_post_types_tracking_args();
+        }
+
+        return ! empty( $bp->activity->track[ $action_id ]->comments_tracking );
+}
+
+/**
+ * Helper function to get the parent action out of a post type comment action
+ *
+ * eg: new_blog_comment > new_blog_post
+ *
+ * @since BuddyPress (2.4.0)
+ *
+ * @param  string       $action_id the activity action to check
+ * @return array|object $parent_action the parent action post type tracking args
+ *                      empty array if not found
+ */
+function bp_activity_get_parent_post_type_action( $comment_action_id ) {
+        if ( empty( $comment_action_id ) ) {
+                return false;
+        }
+
+        $bp = buddypress();
+
+        // Set the activity track global if not set yet
+        if ( empty( $bp->activity->track ) ) {
+                $bp->activity->track = bp_activity_get_post_types_tracking_args();
+        }
+
+        $parent_action = wp_list_filter( $bp->activity->track, array( 'comment_action_id' => $comment_action_id ) );
+
+        return reset( $parent_action );
+}
+
+/**
  * Get all components' activity actions, sorted by their position attribute.
  *
  * @since BuddyPress (2.2.0)
@@ -1418 +1566 @@
         return apply_filters( 'bp_activity_custom_post_type_post_action', $action, $activity );
 }
 
+/**
+ * Format activity action strings for custom post types comments.
+ *
+ * @since BuddyPress (2.4.0)
+ *
+ * @param string $action   Static activity action.
+ * @param object $activity Activity data object.
+ *
+ * @return string
+ */
+function bp_activity_format_activity_action_custom_post_type_comment( $action, $activity ) {
+        $bp = buddypress();
+
+        // Fetch all the tracked post types once.
+        if ( empty( $bp->activity->track ) ) {
+                $bp->activity->track = bp_activity_get_post_types_tracking_args();
+        }
+
+        if ( empty( $activity->type ) || empty( $bp->activity->track[ $activity->type ] ) ) {
+                return $action;
+        }
+
+        $user_link = bp_core_get_userlink( $activity->user_id );
+
+        if ( is_multisite() ) {
+                $blog_link = '<a href="' . esc_url( get_home_url( $activity->item_id ) ) . '">' . get_blog_option( $activity->item_id, 'blogname' ) . '</a>';
+
+                if ( ! empty( $bp->activity->track[ $activity->type ]->new_post_type_comment_action_ms ) ) {
+                        $action = sprintf( $bp->activity->track[ $activity->type ]->new_post_type_comment_action_ms, $user_link, $activity->primary_link, $blog_link );
+                } else {
+                        $action = sprintf( _x( '%1$s commented on the <a href="%2$s">item</a>, on the site %3$s', 'Activity Custom Post Type comment action', 'buddypress' ), $user_link, $activity->primary_link, $blog_link );
+                }
+        } else {
+                if ( ! empty( $bp->activity->track[ $activity->type ]->new_post_type_comment_action ) ) {
+                        $action = sprintf( $bp->activity->track[ $activity->type ]->new_post_type_comment_action, $user_link, $activity->primary_link );
+                } else {
+                        $action = sprintf( _x( '%1$s commented on the <a href="%2$s">item</a>', 'Activity Custom Post Type post comment action', 'buddypress' ), $user_link, $activity->primary_link );
+                }
+        }
+
+        /**
+         * Filters the formatted custom post type activity comment action string.
+         *
+         * @since BuddyPress (2.4.0)
+         *
+         * @param string               $action   Activity action string value.
+         * @param BP_Activity_Activity $activity Activity item object.
+         */
+        return apply_filters( 'bp_activity_custom_post_type_comment_action', $action, $activity );
+}
+
 /******************************************************************************
  * Business functions are where all the magic happens in BuddyPress. They will
  * handle the actual saving or manipulation of information. Usually they will
@@ -2006 +2205 @@
          *
          * @since BuddyPress (2.2.0)
          *
-         * @param WP_Post              $post     Post object.
-         * @param BP_Activity_Activity $activity Activity object.
+         * @param WP_Post              $post                 Post object.
+         * @param BP_Activity_Activity $activity             Activity object.
+         * @param object               $activity_post_object the post type tracking args object
          */
-        do_action( 'bp_activity_post_type_updated', $post, $activity );
+        do_action( 'bp_activity_post_type_updated', $post, $activity, $activity_post_object );
 
         return $updated;
 }
@@ -2066 +2266 @@
 }
 
 /**
+ * Create an activity item for a newly posted post type comment.
+ *
+ * @since BuddyPress (2.4.0)
+ *
+ * @param  int  $comment_id  ID of the comment.
+ * @param  bool $is_approved Whether the comment is approved or not.
+ * @param  object $activity_post_object the post type tracking args object.
+ *
+ * @return int|bool The ID of the activity on success. False on error.
+ */
+function bp_activity_post_type_comment( $comment_id = 0, $is_approved = true, $activity_post_object = null ) {
+        // Get the users comment
+        $post_type_comment = get_comment( $comment_id );
+
+        // Don't record activity if the comment hasn't been approved
+        if ( empty( $is_approved ) ) {
+                return false;
+        }
+
+        // Don't record activity if no email address has been included
+        if ( empty( $post_type_comment->comment_author_email ) ) {
+                return false;
+        }
+
+        // Don't record activity if the comment has already been marked as spam
+        if ( 'spam' === $is_approved ) {
+                return false;
+        }
+
+        // Get the user by the comment author email.
+        $user = get_user_by( 'email', $post_type_comment->comment_author_email );
+
+        // If user isn't registered, don't record activity
+        if ( empty( $user ) ) {
+                return false;
+        }
+
+        // Get the user_id
+        $user_id = (int) $user->ID;
+
+        // Get blog and post data
+        $blog_id = get_current_blog_id();
+
+        // Get the post
+        $post_type_comment->post = get_post( $post_type_comment->comment_post_ID );
+
+        if ( ! is_a( $post_type_comment->post, 'WP_Post' ) ) {
+                return false;
+        }
+
+        /**
+         * Filters whether to publish activities about the comment regarding the post status
+         *
+         * @since BuddyPress (2.4.0)
+         *
+         * @param bool true to bail, false otherwise.
+         */
+        $is_post_status_not_allowed = (bool) apply_filters( 'bp_activity_post_type_is_post_status_allowed', 'publish' !== $post_type_comment->post->post_status || ! empty( $post_type_comment->post->post_password ) );
+
+        // If this is a password protected post, or not a public post don't record the comment
+        if ( $is_post_status_not_allowed ) {
+                return false;
+        }
+
+        // Set post type
+        $post_type = $post_type_comment->post->post_type;
+
+        if ( empty( $activity_post_object ) ) {
+                // Get the post type tracking args.
+                $activity_post_object = bp_activity_get_post_type_tracking_args( $post_type );
+
+                // Bail if the activity action does not exist
+                if ( empty( $activity_post_object->comments_tracking->action_id ) ) {
+                        return false;
+                }
+        }
+
+        // Set the $activity_comment_object
+        $activity_comment_object = $activity_post_object->comments_tracking;
+
+        /**
+         * Filters whether or not to post the activity about the comment.
+         *
+         * This is a variable filter, dependent on the post type,
+         * that lets components or plugins bail early if needed.
+         *
+         * @since BuddyPress (2.4.0)
+         *
+         * @param bool $value      Whether or not to continue.
+         * @param int  $blog_id    ID of the current site.
+         * @param int  $post_id    ID of the current post being commented.
+         * @param int  $user_id    ID of the current user.
+         * @param int  $comment_id ID of the current comment being posted.
+         */
+        if ( false === apply_filters( "bp_activity_{$post_type}_pre_comment", true, $blog_id, $post_type_comment->post->ID, $user_id, $comment_id ) ) {
+                return false;
+        }
+
+        // Is this an update ?
+        $activity_id = bp_activity_get_activity_id( array(
+                'user_id'           => $user_id,
+                'component'         => $activity_comment_object->component_id,
+                'type'              => $activity_comment_object->action_id,
+                'item_id'           => $blog_id,
+                'secondary_item_id' => $comment_id,
+        ) );
+
+        // Record this in activity streams.
+        $comment_link = get_comment_link( $post_type_comment->comment_ID );
+
+        // Backward compatibility filters for the 'blogs' component.
+        if ( 'blogs' == $activity_comment_object->component_id )  {
+                $activity_content      = apply_filters_ref_array( 'bp_blogs_activity_new_comment_content',      array( $post_type_comment->comment_content, &$post_type_comment, $comment_link ) );
+                $activity_primary_link = apply_filters_ref_array( 'bp_blogs_activity_new_comment_primary_link', array( $comment_link, &$post_type_comment ) );
+        } else {
+                $activity_content      = $post_type_comment->comment_content;
+                $activity_primary_link = $comment_link;
+        }
+
+        $activity_args = array(
+                'id'            => $activity_id,
+                'user_id'       => $user_id,
+                'content'       => $activity_content,
+                'primary_link'  => $activity_primary_link,
+                'component'     => $activity_comment_object->component_id,
+                'recorded_time' => $post_type_comment->comment_date_gmt,
+        );
+
+        if ( bp_disable_blogforum_comments() ) {
+                $blog_url = get_home_url( $blog_id );
+                $post_url = add_query_arg(
+                        'p',
+                        $post_type_comment->post->ID,
+                        trailingslashit( $blog_url )
+                );
+
+                $activity_args['type']              = $activity_comment_object->action_id;
+                $activity_args['item_id']           = $blog_id;
+                $activity_args['secondary_item_id'] = $post_type_comment->comment_ID;
+
+                if ( ! empty( $activity_args['content'] ) ) {
+                        // Create the excerpt.
+                        $activity_summary = bp_activity_create_summary( $activity_args['content'], $activity_args );
+
+                        // Backward compatibility filter for blog comments.
+                        if ( 'blogs' == $activity_post_object->component_id )  {
+                                $activity_args['content'] = apply_filters( 'bp_blogs_record_activity_content', $activity_summary, $activity_args['content'], $activity_args, $post_type );
+                        } else {
+                                $activity_args['content'] = $activity_summary;
+                        }
+                }
+
+                // Set up the action by using the format functions.
+                $action_args = array_merge( $activity_args, array(
+                        'post_title' => $post_type_comment->post->post_title,
+                        'post_url'   => $post_url,
+                        'blog_url'   => $blog_url,
+                        'blog_name'  => get_blog_option( $blog_id, 'blogname' ),
+                ) );
+
+                $activity_args['action'] = call_user_func_array( $activity_comment_object->format_callback, array( '', (object) $action_args ) );
+
+                // Make sure the action is set.
+                if ( empty( $activity_args['action'] ) ) {
+                        return;
+                } else {
+                        // Backward compatibility filter for the blogs component.
+                        if ( 'blogs' === $activity_post_object->component_id )  {
+                                $activity_args['action'] = apply_filters( 'bp_blogs_record_activity_action', $activity_args['action'] );
+                        }
+                }
+
+                $activity_id = bp_activity_add( $activity_args );
+        }
+
+        /**
+         * Fires after the publishing of an activity item for a newly published post type post.
+         *
+         * @since BuddyPress (2.4.0)
+         *
+         * @param int        $activity_id          ID of the newly published activity item.
+         * @param WP_Comment $post_type_comment    Comment object.
+         * @param array      $activity_args        Array of activity arguments.
+         * @param object     $activity_post_object the post type tracking args object.
+         */
+        do_action_ref_array( 'bp_activity_post_type_comment', array( &$activity_id, $post_type_comment, $activity_args, $activity_post_object ) );
+
+        return $activity_id;
+}
+add_action( 'comment_post', 'bp_activity_post_type_comment', 10, 2 );
+add_action( 'edit_comment', 'bp_activity_post_type_comment', 10    );
+
+/**
+ * Remove an activity item when a comment about a post type is deleted.
+ *
+ * @since BuddyPress (2.4.0)
+ *
+ * @param  int    $comment_id           ID of the comment.
+ * @param  object $activity_post_object the post type tracking args object.
+ *
+ * @return bool True on success. False on error.
+ */
+function bp_activity_post_type_remove_comment( $comment_id = 0, $activity_post_object = null ) {
+        if ( empty( $activity_post_object ) ) {
+                $comment = get_comment( $comment_id );
+                if ( ! $comment ) {
+                        return;
+                }
+
+                $post_type = get_post_type( $comment->comment_post_ID );
+                if ( ! $post_type ) {
+                        return;
+                }
+
+                // Get the post type tracking args.
+                $activity_post_object = bp_activity_get_post_type_tracking_args( $post_type );
+
+                // Bail if the activity action does not exist
+                if ( empty( $activity_post_object->comments_tracking->action_id ) ) {
+                        return false;
+                }
+        }
+
+        // Set the $activity_comment_object
+        $activity_comment_object = $activity_post_object->comments_tracking;
+
+        $deleted = false;
+
+        if ( bp_disable_blogforum_comments() ) {
+                $deleted = bp_activity_delete_by_item_id( array(
+                        'item_id'           => get_current_blog_id(),
+                        'secondary_item_id' => $comment_id,
+                        'component'         => $activity_comment_object->component_id,
+                        'type'              => $activity_comment_object->action_id,
+                        'user_id'           => false,
+                ) );
+        }
+
+        /**
+         * Fires after the unpublishing for the custom post type.
+         *
+         * @since BuddyPress (2.4.0)
+         *
+         * @param bool       $deleted              true if the activity was deleted false otherwise
+         * @param WP_Comment $comment              Comment object.
+         * @param object     $activity_post_object the post type tracking args object.
+         */
+        do_action( 'bp_activity_post_type_remove_comment', $deleted, $comment_id, $activity_post_object );
+
+        return $deleted;
+}
+add_action( 'delete_comment', 'bp_activity_post_type_remove_comment', 10, 1 );
+
+/**
  * Add an activity comment.
  *
  * @since BuddyPress (1.2.0)
@@ -2078 +2532 @@
  * @uses do_action() To call the 'bp_activity_comment_posted' hook.
  *
  * @param array|string $args {
- *     @type int    $id          Optional. Pass an ID to update an existing comment.
- *     @type string $content     The content of the comment.
- *     @type int    $user_id     Optional. The ID of the user making the comment.
- *                               Defaults to the ID of the logged-in user.
- *     @type int    $activity_id The ID of the "root" activity item, ie the oldest
- *                               ancestor of the comment.
- *     @type int    $parent_id   Optional. The ID of the parent activity item, ie the item to
- *                               which the comment is an immediate reply. If not provided,
- *                               this value defaults to the $activity_id.
+ *     @type int    $id                Optional. Pass an ID to update an existing comment.
+ *     @type string $content           The content of the comment.
+ *     @type int    $user_id           Optional. The ID of the user making the comment.
+ *                                     Defaults to the ID of the logged-in user.
+ *     @type int    $activity_id       The ID of the "root" activity item, ie the oldest
+ *                                     ancestor of the comment.
+ *     @type int    $parent_id         Optional. The ID of the parent activity item, ie the item to
+ *                                     which the comment is an immediate reply. If not provided,
+ *                                     this value defaults to the $activity_id.
+ *     @type bool   $skip_notification Optional. false to send a comment notification, false otherwise
+ *                                     Defaults to false
  * }
  * @return int|bool The ID of the comment on success, otherwise false.
  */
@@ -2100 +2556 @@
         }
 
         $r = wp_parse_args( $args, array(
-                'id'          => false,
-                'content'     => false,
-                'user_id'     => bp_loggedin_user_id(),
-                'activity_id' => false, // ID of the root activity item
-                'parent_id'   => false  // ID of a parent comment (optional)
+                'id'                => false,
+                'content'           => false,
+                'user_id'           => bp_loggedin_user_id(),
+                'activity_id'       => false, // ID of the root activity item
+                'parent_id'         => false, // ID of a parent comment (optional),
+                'skip_notification' => false,
         ) );
 
         // Bail if missing necessary data
@@ -2169 +2626 @@
         }
         wp_cache_delete( $activity_id, 'bp_activity' );
 
-        /**
-         * Fires near the end of an activity comment posting, before the returning of the comment ID.
-         *
-         * @since BuddyPress (1.2.0)
-         *
-         * @param int   $comment_id ID of the newly posted activity comment.
-         * @param array $r          Array of parsed comment arguments.
-         * @param int   $activity   ID of the activity item being commented on.
-         */
-        do_action( 'bp_activity_comment_posted', $comment_id, $r, $activity );
+        if ( empty( $r[ 'skip_notification' ] ) ) {
+                /**
+                 * Fires near the end of an activity comment posting, before the returning of the comment ID.
+                 * Sends a notification to the user @see bp_activity_new_comment_notification_helper()
+                 *
+                 * @since BuddyPress (1.2.0)
+                 *
+                 * @param int   $comment_id ID of the newly posted activity comment.
+                 * @param array $r          Array of parsed comment arguments.
+                 * @param int   $activity   ID of the activity item being commented on.
+                 */
+                do_action( 'bp_activity_comment_posted', $comment_id, $r, $activity );
+        } else {
+                /**
+                 * Fires near the end of an activity comment posting, before the returning of the comment ID.
+                 * without sending a notification to the user
+                 *
+                 * @since BuddyPress (2.4.0)
+                 *
+                 * @param int   $comment_id ID of the newly posted activity comment.
+                 * @param array $r          Array of parsed comment arguments.
+                 * @param int   $activity   ID of the activity item being commented on.
+                 */
+                do_action( 'bp_activity_comment_posted_notification_skipped', $comment_id, $r, $activity );
+        }
 
         if ( empty( $comment_id ) ) {
                 $errors->add( 'comment_failed', $feedback );
@@ -2451 +2923 @@
  * @return bool True on success, false on failure.
  */
 function bp_activity_delete_comment( $activity_id, $comment_id ) {
+        $deleted = false;
 
         /**
          * Filters whether BuddyPress should delete an activity comment or not.
@@ -2464 +2937 @@
          * @param int  $activity_id ID of the root activity item being deleted.
          * @param int  $comment_id  ID of the comment being deleted.
          */
-        if ( ! apply_filters( 'bp_activity_delete_comment_pre', true, $activity_id, $comment_id ) ) {
-                return false;
+        if ( ! apply_filters_ref_array( 'bp_activity_delete_comment_pre', array( true, $activity_id, $comment_id, &$deleted ) ) ) {
+                return $deleted;
         }
 
         // Delete any children of this comment.
@@ -2474 +2947 @@
         // Delete the actual comment
         if ( ! bp_activity_delete( array( 'id' => $comment_id, 'type' => 'activity_comment' ) ) ) {
                 return false;
+        } else {
+                $deleted = true;
         }
 
         // Purge comment cache for the root activity update
@@ -2492 +2967 @@
          */
         do_action( 'bp_activity_delete_comment', $activity_id, $comment_id );
 
-        return true;
+        return $deleted;
 }
 
         /**

src/bp-blogs/bp-blogs-activity.php

@@ -37 +37 @@
                 );
         }
 
-        // Only add the comment type if the 'post' post type is trackable
-        if ( post_type_supports( 'post', 'buddypress-activity' ) ) {
-                bp_activity_set_action(
-                        $bp->blogs->id,
-                        'new_blog_comment',
-                        __( 'New post comment posted', 'buddypress' ),
-                        'bp_blogs_format_activity_action_new_blog_comment',
-                        __( 'Comments', 'buddypress' ),
-                        array( 'activity', 'member' ),
-                        10
-                );
-        }
-
         /**
          * Fires after the registry of the default blog component activity actions.
          *
@@ -215 +202 @@
  * @param obj $activity Activity data object.
  */
 function bp_blogs_format_activity_action_new_blog_comment( $action, $activity ) {
-        $blog_url  = bp_blogs_get_blogmeta( $activity->item_id, 'url' );
-        $blog_name = bp_blogs_get_blogmeta( $activity->item_id, 'name' );
+        /**
+         * When the comment is published we are faking an activity object
+         * to which we add 4 properties :
+         * - the post url
+         * - the post title
+         * - the blog url
+         * - the blog name
+         * This is done to build the 'post link' part of the activity
+         * action string.
+         * NB: in this case the activity has not yet been created.
+         */
+
+        $blog_url = false;
+
+        // Try to get the blog url from the activity object
+        if ( isset( $activity->blog_url ) ) {
+                $blog_url = $activity->blog_url;
+        } else {
+                $blog_url = bp_blogs_get_blogmeta( $activity->item_id, 'url' );
+        }
+
+        $blog_name = false;
+
+        // Try to get the blog name from the activity object
+        if ( isset( $activity->blog_name ) ) {
+                $blog_name = $activity->blog_name;
+        } else {
+                $blog_name = bp_blogs_get_blogmeta( $activity->item_id, 'name' );
+        }
 
         if ( empty( $blog_url ) || empty( $blog_name ) ) {
                 $blog_url  = get_home_url( $activity->item_id );
@@ -226 +240 @@
                 bp_blogs_update_blogmeta( $activity->item_id, 'name', $blog_name );
         }
 
-        $post_url   = bp_activity_get_meta( $activity->id, 'post_url' );
-        $post_title = bp_activity_get_meta( $activity->id, 'post_title' );
+        $post_url = false;
+
+        // Try to get the post url from the activity object
+        if ( isset( $activity->post_url ) ) {
+                $post_url = $activity->post_url;
+
+        /**
+         * The post_url property is not set, we need to build the url
+         * thanks to the post id which is also saved as the secondary
+         * item id property of the activity object.
+         */
+        } elseif ( ! empty( $activity->id ) ) {
+                $post_url = bp_activity_get_meta( $activity->id, 'post_url' );
+        }
+
+        $post_title = false;
+
+        // Should be the case when the comment has just been published
+        if ( isset( $activity->post_title ) ) {
+                $post_title = $activity->post_title;
+
+        // If activity already exists try to get the post title from activity meta
+        } elseif ( ! empty( $activity->id ) ) {
+                $post_title = bp_activity_get_meta( $activity->id, 'post_title' );
+        }
 
         // Should only be empty at the time of post creation
         if ( empty( $post_url ) || empty( $post_title ) ) {
@@ -518 +555 @@
  *
  * Note: This is only a one-way sync - activity comments -> blog comment.
  *
- * For blog post -> activity comment, see {@link bp_blogs_record_comment()}.
+ * For blog post -> activity comment, see {@link bp_activity_post_type_comment()}.
  *
  * @since BuddyPress (2.0.0)
  *
@@ -527 +564 @@
  * @param object Parameters of the parent activity item (in this case, the blog post).
  */
 function bp_blogs_sync_add_from_activity_comment( $comment_id, $params, $parent_activity ) {
-        // if parent activity isn't a blog post, stop now!
-        if ( $parent_activity->type != 'new_blog_post' ) {
+        // if parent activity isn't a post type having the buddypress-activity support, stop now!
+        if ( ! bp_activity_action_supports_comments_tracking( $parent_activity->type ) ) {
                 return;
         }
 
@@ -561 +598 @@
                 'comment_type'         => '', // could be interesting to add 'buddypress' here...
                 'comment_parent'       => (int) $comment_parent,
                 'user_id'              => $params['user_id'],
-
-                // commenting these out for now
-                //'comment_author_IP'    => '127.0.0.1',
-                //'comment_agent'        => '',
-
                 'comment_approved'     => 1
         );
 
         // prevent separate activity entry being made
-        remove_action( 'comment_post', 'bp_blogs_record_comment', 10, 2 );
+        remove_action( 'comment_post', 'bp_activity_post_type_comment', 10, 2 );
 
         // handle multisite
         switch_to_blog( $parent_activity->item_id );
@@ -587 +619 @@
 
         // add meta to activity comment
         bp_activity_update_meta( $comment_id, 'bp_blogs_post_comment_id', $post_comment_id );
+        bp_activity_update_meta( $comment_id, 'bp_parent_action', $parent_activity->type );
 
         // resave activity comment with WP comment permalink
         //
@@ -603 +636 @@
         restore_current_blog();
 
         // add the comment hook back
-        add_action( 'comment_post', 'bp_blogs_record_comment', 10, 2 );
+        add_action( 'comment_post', 'bp_activity_post_type_comment', 10, 2 );
 
         /**
          * Fires after activity comments have been synced and posted as blog comments.
@@ -629 +662 @@
  * @since BuddyPress (2.0.0)
  *
  * @param bool $retval
- * @param int $parent_activity_id The parent activity ID for the activity comment.
- * @param int $activity_id The activity ID for the pending deleted activity comment.
+ * @param int  $parent_activity_id The parent activity ID for the activity comment.
+ * @param int  $activity_id The activity ID for the pending deleted activity comment.
+ * @param bool $deleted whether the comment was deleted or not
  */
-function bp_blogs_sync_delete_from_activity_comment( $retval, $parent_activity_id, $activity_id ) {
+function bp_blogs_sync_delete_from_activity_comment( $retval, $parent_activity_id, $activity_id, &$deleted ) {
         // check if parent activity is a blog post
         $parent_activity = new BP_Activity_Activity( $parent_activity_id );
-        if ( 'new_blog_post' != $parent_activity->type ) {
+
+        // if parent activity isn't a post type having the buddypress-activity support, stop now!
+        if ( ! bp_activity_action_supports_comments_tracking( $parent_activity->type ) ) {
                 return $retval;
         }
 
@@ -643 +679 @@
         $activity = bp_activity_get( array(
                 'in'               => $activity_id,
                 'display_comments' => 'stream',
+                'spam'             => 'all',
         ) );
 
         // get all activity comment IDs for the pending deleted item
@@ -663 +700 @@
         // emulate bp_activity_delete_comment()
         BP_Activity_Activity::rebuild_activity_comment_tree( $parent_activity_id );
 
+        // Avoid the error message although the comments were successfully deleted
+        $deleted = true;
+
         // we're overriding the default bp_activity_delete_comment() functionality
         // so we need to return false
         return false;
 }
-add_filter( 'bp_activity_delete_comment_pre', 'bp_blogs_sync_delete_from_activity_comment', 10, 3 );
+add_filter( 'bp_activity_delete_comment_pre', 'bp_blogs_sync_delete_from_activity_comment', 10, 4 );
 
 /**
  * Updates the blog comment when the associated activity comment is edited.
@@ -701 +741 @@
         // fetch parent activity item
         $parent_activity = new BP_Activity_Activity( $activity->item_id );
 
-        // sanity check
-        if ( 'new_blog_post' !== $parent_activity->type ) {
+        // if parent activity isn't a post type having the buddypress-activity support for comments, stop now!
+        if ( ! bp_activity_action_supports_comments_tracking( $parent_activity->type ) ) {
                 return;
         }
 
@@ -766 +806 @@
  * @return array $args
  */
 function bp_blogs_new_blog_comment_query_backpat( $args ) {
-        // Bail if this is not a 'new_blog_comment' query
-        if ( 'new_blog_comment' !== $args['action'] ) {
+        global $wpdb;
+        $bp = buddypress();
+
+        // if activity comments are disabled for blog posts, stop now!
+        if ( bp_disable_blogforum_comments() ) {
                 return $args;
         }
 
-        // display_comments=stream is required to show new-style
-        // 'activity_comment' items inline
-        $args['display_comments'] = 'stream';
+        // Get the parent action
+        $parent_action = bp_activity_get_parent_post_type_action( $args['action'] );
 
-        // For the remaining clauses, we filter the SQL query directly
-        add_filter( 'bp_activity_paged_activities_sql', '_bp_blogs_new_blog_comment_query_backpat_filter' );
-        add_filter( 'bp_activity_total_activities_sql', '_bp_blogs_new_blog_comment_query_backpat_filter' );
+        // Bail if this is not a 'new_blog_comment' query
+        if ( empty( $parent_action ) ) {
+                return $args;
+        }
 
-        // Return the original arguments
-        return $args;
-}
-add_filter( 'bp_after_has_activities_parse_args', 'bp_blogs_new_blog_comment_query_backpat' );
+        // Build the filter_query
+        $activity_ids = $wpdb->get_col( $wpdb->prepare( "SELECT activity_id FROM {$bp->activity->table_name_meta} WHERE meta_key = 'bp_parent_action' AND meta_value = %s", $parent_action->action_id ) );
+
+        // Init the filter query
+        $filter_query = array();
+
+        if ( 'null' === $args['scope'] ) {
+                $args['scope'] = '';
+        } elseif ( 'just-me' === $args['scope'] ) {
+                $filter_query = array(
+                        'relation' => 'AND',
+                        array(
+                                'column' => 'user_id',
+                                'value'  => bp_displayed_user_id(),
+                        ),
+                );
+                $args['scope'] = '';
+        }
 
-/**
- * Filter activity SQL to include new- and old-style 'new_blog_comment' activity items.
- *
- * @since BuddyPress (2.1.0)
- *
- * @access private
- * @see bp_blogs_new_blog_comment_query_backpat()
- *
- * @param string $query SQL query as assembled in BP_Activity_Activity::get().
- * @return string $query Modified SQL query.
- */
-function _bp_blogs_new_blog_comment_query_backpat_filter( $query ) {
-        $bp = buddypress();
+        $filter_query[] = array(
+                'relation' => 'OR',
+                array(
+                        'column' => 'type',
+                        'value'  => $args['action'],
+                ),
+                array(
+                        'column'  => 'id',
+                        'value'   =>  $activity_ids,
+                        'compare' => 'IN'
+                ),
+        );
 
-        // The query passed to the filter is for old-style 'new_blog_comment'
-        // items. We include new-style 'activity_comment' items by running a
-        // subquery inside of a large OR clause.
-        $activity_comment_subquery = "SELECT a.id FROM {$bp->activity->table_name} a INNER JOIN {$bp->activity->table_name_meta} am ON (a.id = am.activity_id) WHERE am.meta_key = 'bp_blogs_post_comment_id' AND a.type = 'activity_comment'";
+        // Set the filter_query arg
+        $args['filter_query'] = $filter_query;
 
-        // WHERE ( [original WHERE clauses] OR a.id IN (activity_comment subquery) )
-        $query = preg_replace( '|WHERE (.*?) ORDER|', 'WHERE ( ( $1 ) OR ( a.id IN ( ' . $activity_comment_subquery . ' ) ) ) ORDER', $query );
+        // Display 'activity_comment' items inline, but make sure to avoid duplicate content.
+        $args['display_comments'] = 'stream';
 
-        // Don't run this on future queries
-        remove_filter( current_filter(), '_bp_blogs_new_blog_comment_query_backpat_filter' );
+        // reset the action
+        $args['action'] = '';
+        $args['type']   = '';
 
-        return $query;
+        // Return the original arguments
+        return $args;
 }
+add_filter( 'bp_after_has_activities_parse_args', 'bp_blogs_new_blog_comment_query_backpat' );
 
 /**
  * Utility function to set up some variables for use in the activity loop.
@@ -832 +889 @@
                 return;
         }
 
-        // parent not a blog post? stop now!
-        if ( 'new_blog_post' !== $activity->type ) {
+        // parent not a post post type action ? stop now!
+        if ( ! bp_activity_action_is_post_tracking_action( $activity->type ) ) {
                 return;
         }
 
@@ -915 +972 @@
                 return $retval;
         }
 
-        // activity commenting is enabled for blog posts
-        switch ( bp_get_activity_action_name() ) {
-
-                // we still have to disable activity commenting for 'new_blog_comment' items
-                // commenting should only be done on the parent 'new_blog_post' item
-                case 'new_blog_comment' :
-                        $retval = false;
+        $action = bp_get_activity_action_name();
 
-                        break;
-
-                // check if commenting is disabled for the WP blog post
-                // we should extrapolate this and automate this for plugins... or not
-                case 'new_blog_post' :
+        // It's a post type action supporting comment tracking
+        if ( bp_activity_action_supports_comments_tracking( $action ) ) {
+                // it's a "post" action
+                if ( bp_activity_action_is_post_tracking_action( $action ) ) {
                         global $activities_template;
 
                         // setup some globals we'll need to reference later
                         bp_blogs_setup_activity_loop_globals( $activities_template->activity );
 
-                        // if comments are closed for the WP blog post, we should disable
+                        // if comments are closed for the WP blog post type, we should disable
                         // activity comments for this activity entry
                         if ( empty( buddypress()->blogs->allow_comments[bp_get_activity_id()] ) ) {
                                 $retval = false;
                         }
-
-                        break;
+                // It's a "comment" action
+                } else {
+                        $retval = false;
+                }
         }
 
         return $retval;
@@ -1057 +1109 @@
                 return $retval;
         }
 
+        $bp = buddypress();
         $blog_comment_id = bp_activity_get_meta( $activity->id, 'bp_blogs_post_comment_id' );
 
         if ( ! empty( $blog_comment_id ) ) {
@@ -1072 +1125 @@
                 // override 'secondary_item_id' to use comment ID
                 $object->secondary_item_id = $blog_comment_id;
 
-                // now format the activity action using the 'new_blog_comment' action callback
-                $retval = bp_blogs_format_activity_action_new_blog_comment( '', $object );
+                // Set the activity track global if not set yet
+                if ( empty( $bp->activity->track ) ) {
+                        $bp->activity->track = bp_activity_get_post_types_tracking_args();
+                }
+
+                // Use the fallback of the action
+                if ( ! empty( $bp->activity->track[ $parent_blog_post_activity->type ]->comment_action_id ) ) {
+                        $object->type = $bp->activity->track[ $parent_blog_post_activity->type ]->comment_action_id;
+
+                        // now format the activity action using the 'new_blog_comment' action callback
+                        $retval = call_user_func_array( $bp->activity->track[ $object->type ]->format_callback, array( '', $object ) );
+                }
         }
 
         return $retval;

src/bp-blogs/bp-blogs-filters.php

@@ -62 +62 @@
 }
 
 /**
- * Check whether the current post can be published.
+ * Check whether the current activity about a post or a comment can be published.
  *
  * Abstracted from the deprecated `bp_blogs_record_post()`.
  *
@@ -122 +122 @@
         return $return;
 }
 add_filter( 'bp_activity_post_pre_publish', 'bp_blogs_post_pre_publish', 10, 4 );
+add_filter( 'bp_activity_post_pre_comment', 'bp_blogs_post_pre_publish', 10, 4 );

src/bp-blogs/bp-blogs-functions.php

@@ -467 +467 @@
  *
  * @since BuddyPress (2.2.0)
  *
- * @param WP_Post              $post     Post object.
- * @param BP_Activity_Activity $activity Activity object.
+ * @param WP_Post              $post                 Post object.
+ * @param BP_Activity_Activity $activity             Activity object.
+ * @param object               $activity_post_object the post type tracking args object
  */
-function bp_blogs_update_post_activity_meta( $post, $activity ) {
-        if ( empty( $activity->id ) || 'post' != $post->post_type ) {
+function bp_blogs_update_post_activity_meta( $post, $activity, $activity_post_object ) {
+        if ( empty( $activity->id ) || empty( $activity_post_object->action_id ) ) {
                 return;
         }
 
@@ -480 +481 @@
         if ( $post->post_title !== $existing_title ) {
                 bp_activity_update_meta( $activity->id, 'post_title', $post->post_title );
 
-                // Now update activity meta for post comments... sigh.
-                add_filter( 'comments_clauses', 'bp_blogs_comments_clauses_select_by_id' );
-                $comments = get_comments( array( 'post_id' => $post->ID ) );
-                remove_filter( 'comments_clauses', 'bp_blogs_comments_clauses_select_by_id' );
-
-                if ( ! empty( $comments ) ) {
-                        $activity_ids = array();
-                        $comment_ids  = wp_list_pluck( $comments, 'comment_ID' );
-
-                        // Set up activity args.
-                        $args = array(
-                                'update_meta_cache' => false,
-                                'show_hidden'       => true,
-                                'per_page'          => 99999,
-                        );
-
-                        // Query for old-style "new_blog_comment" activity items.
-                        $args['filter'] = array(
-                                'object'       => buddypress()->blogs->id,
-                                'action'       => 'new_blog_comment',
-                                'secondary_id' => implode( ',', $comment_ids ),
-                        );
-
-                        $activities = bp_activity_get( $args );
-                        if ( ! empty( $activities['activities'] ) ) {
-                                $activity_ids = (array) wp_list_pluck( $activities['activities'], 'id' );
-                        }
-
-                        // Query for activity comments connected to a blog post.
-                        unset( $args['filter'] );
-                        $args['meta_query'] = array( array(
-                                'key'     => 'bp_blogs_post_comment_id',
-                                'value'   => $comment_ids,
-                                'compare' => 'IN',
-                        ) );
-                        $args['type'] = 'activity_comment';
-                        $args['display_comments'] = 'stream';
+                if ( ! empty( $activity_post_object->comments_tracking->action_id ) ) {
+                        // Now update activity meta for post comments... sigh.
+                        add_filter( 'comments_clauses', 'bp_blogs_comments_clauses_select_by_id' );
+                        $comments = get_comments( array( 'post_id' => $post->ID ) );
+                        remove_filter( 'comments_clauses', 'bp_blogs_comments_clauses_select_by_id' );
+
+                        if ( ! empty( $comments ) ) {
+                                $activity_ids = array();
+                                $comment_ids  = wp_list_pluck( $comments, 'comment_ID' );
+
+                                // Set up activity args.
+                                $args = array(
+                                        'update_meta_cache' => false,
+                                        'show_hidden'       => true,
+                                        'per_page'          => 99999,
+                                );
+
+                                // Query for old-style "new_blog_comment" activity items.
+                                $args['filter'] = array(
+                                        'object'       => $activity_post_object->comments_tracking->component_id,
+                                        'action'       => $activity_post_object->comments_tracking->action_id,
+                                        'secondary_id' => implode( ',', $comment_ids ),
+                                );
+
+                                $activities = bp_activity_get( $args );
+                                if ( ! empty( $activities['activities'] ) ) {
+                                        $activity_ids = (array) wp_list_pluck( $activities['activities'], 'id' );
+                                }
 
-                        $activities = bp_activity_get( $args );
-                        if ( ! empty( $activities['activities'] ) ) {
-                                $activity_ids = array_merge( $activity_ids, (array) wp_list_pluck( $activities['activities'], 'id' ) );
-                        }
+                                // Query for activity comments connected to a blog post.
+                                unset( $args['filter'] );
+                                $args['meta_query'] = array( array(
+                                        'key'     => 'bp_blogs_post_comment_id',
+                                        'value'   => $comment_ids,
+                                        'compare' => 'IN',
+                                ) );
+                                $args['type'] = 'activity_comment';
+                                $args['display_comments'] = 'stream';
+
+                                $activities = bp_activity_get( $args );
+                                if ( ! empty( $activities['activities'] ) ) {
+                                        $activity_ids = array_merge( $activity_ids, (array) wp_list_pluck( $activities['activities'], 'id' ) );
+                                }
 
-                        // Update activity meta for all found activity items.
-                        if ( ! empty( $activity_ids ) ) {
-                                foreach ( $activity_ids as $aid ) {
-                                        bp_activity_update_meta( $aid, 'post_title', $post->post_title );
+                                // Update activity meta for all found activity items.
+                                if ( ! empty( $activity_ids ) ) {
+                                        foreach ( $activity_ids as $aid ) {
+                                                bp_activity_update_meta( $aid, 'post_title', $post->post_title );
+                                        }
                                 }
-                        }
 
-                        unset( $activities, $activity_ids, $comment_ids, $comments );
+                                unset( $activities, $activity_ids, $comment_ids, $comments );
+                        }
                 }
         }
 
@@ -541 +544 @@
                 bp_activity_delete_meta( $activity->id, 'post_comment_status' );
         }
 }
-add_action( 'bp_activity_post_type_updated', 'bp_blogs_update_post_activity_meta', 10, 2 );
+add_action( 'bp_activity_post_type_updated', 'bp_blogs_update_post_activity_meta', 10, 3 );
 
 /**
- * Record a new blog comment in the BuddyPress activity stream.
+ * Update Activity and blogs meta and eventually sync comment with activity comment
  *
- * Only posts the item if blog is public and post is not password-protected.
+ * @since  BuddyPress (2.4.0)
  *
- * @param int $comment_id ID of the comment being recorded.
- * @param bool|string $is_approved Optional. The $is_approved value passed to
- *        the 'comment_post' action. Default: true.
- * @return bool|object Returns false on failure, the comment object on success.
+ * @param  int|bool   $activity_id ID of recorded activity, or false if sync is active.
+ * @param  WP_Comment $comment the comment object
+ * @param  array      $activity_args        Array of activity arguments.
+ * @param  object     $activity_post_object the post type tracking args object.
+ * @return int|bool   Returns false if no activity, the activity id otherwise.
  */
-function bp_blogs_record_comment( $comment_id, $is_approved = true ) {
-        // bail if activity component is not active
-        if ( ! bp_is_active( 'activity' ) ) {
-                return;
-        }
-
-        // Get the users comment
-        $recorded_comment = get_comment( $comment_id );
-
-        // Don't record activity if the comment hasn't been approved
-        if ( empty( $is_approved ) )
-                return false;
-
-        // Don't record activity if no email address has been included
-        if ( empty( $recorded_comment->comment_author_email ) )
-                return false;
-
-        // Don't record activity if the comment has already been marked as spam
-        if ( 'spam' === $is_approved )
-                return false;
-
-        // Get the user by the comment author email.
-        $user = get_user_by( 'email', $recorded_comment->comment_author_email );
-
-        // If user isn't registered, don't record activity
-        if ( empty( $user ) )
+function bp_blogs_comment_sync_activity_comment( &$activity_id, $comment = null, $activity_args = array(), $activity_post_object = null ) {
+        if ( empty( $activity_args ) || empty( $comment->post->ID ) || empty( $activity_post_object->comment_action_id ) ) {
                 return false;
+        }
 
-        // Get the user_id
-        $user_id = (int) $user->ID;
-
-        // Get blog and post data
+        // Set the current blog id.
         $blog_id = get_current_blog_id();
 
-        // If blog is not trackable, do not record the activity.
-        if ( ! bp_blogs_is_blog_trackable( $blog_id, $user_id ) )
-                return false;
-
-        $recorded_comment->post = get_post( $recorded_comment->comment_post_ID );
-
-        if ( empty( $recorded_comment->post ) || is_wp_error( $recorded_comment->post ) )
-                return false;
-
-        // If this is a password protected post, don't record the comment
-        if ( !empty( $recorded_comment->post->post_password ) )
-                return false;
-
-        // Don't record activity if the comment's associated post isn't a WordPress Post
-        if ( !in_array( $recorded_comment->post->post_type, apply_filters( 'bp_blogs_record_comment_post_types', array( 'post' ) ) ) )
-                return false;
-
-        $is_blog_public = apply_filters( 'bp_is_blog_public', (int)get_blog_option( $blog_id, 'blog_public' ) );
-
-        // If blog is public allow activity to be posted
-        if ( $is_blog_public ) {
-
-                // Get activity related links
-                $post_permalink = get_permalink( $recorded_comment->comment_post_ID );
-                $comment_link   = get_comment_link( $recorded_comment->comment_ID );
-
-                // Setup activity args
-                $args = array();
-
-                $args['user_id']       = $user_id;
-                $args['content']       = apply_filters_ref_array( 'bp_blogs_activity_new_comment_content', array( $recorded_comment->comment_content, &$recorded_comment, $comment_link ) );
-                $args['primary_link']  = apply_filters_ref_array( 'bp_blogs_activity_new_comment_primary_link', array( $comment_link,     &$recorded_comment ) );
-                $args['recorded_time'] = $recorded_comment->comment_date_gmt;
-
-                // Setup some different activity args depending if activity commenting is
-                // enabled or not
-
-                // if cannot comment, record separate activity entry
-                // this is the old way of doing things
-                if ( bp_disable_blogforum_comments() ) {
-                        $args['type']              = 'new_blog_comment';
-                        $args['item_id']           = $blog_id;
-                        $args['secondary_item_id'] = $comment_id;
-
-                        // record the activity entry
-                        $activity_id = bp_blogs_record_activity( $args );
+        // These activity metadatas are used to build the new_blog_comment action string
+        if ( ! empty( $activity_id ) && ! empty( $activity_args['item_id'] ) && 'new_blog_comment' === $activity_post_object->comment_action_id ) {
+                // add some post info in activity meta
+                bp_activity_update_meta( $activity_id, 'post_title', $comment->post->post_title );
+                bp_activity_update_meta( $activity_id, 'post_url',   esc_url_raw( add_query_arg( 'p', $comment->post->ID, home_url( '/' ) ) ) );
+        }
 
-                        // add some post info in activity meta
-                        bp_activity_update_meta( $activity_id, 'post_title', $recorded_comment->post->post_title );
-                        bp_activity_update_meta( $activity_id, 'post_url',   add_query_arg( 'p', $recorded_comment->post->ID, home_url( '/' ) ) );
+        // Sync comment - activity comment
+        if ( ! bp_disable_blogforum_comments() ) {
 
-                // record comment as BP activity comment under the parent 'new_blog_post'
-                // activity item
-                } else {
-                        // this is a comment edit
-                        // check to see if corresponding activity entry already exists
-                        if ( ! empty( $_REQUEST['action'] ) ) {
-                                $existing_activity_id = get_comment_meta( $comment_id, 'bp_activity_comment_id', true );
+                if ( ! empty( $_REQUEST['action'] ) ) {
+                        $existing_activity_id = get_comment_meta( $comment->comment_ID, 'bp_activity_comment_id', true );
 
-                                if ( ! empty( $existing_activity_id ) ) {
-                                        $args['id'] = $existing_activity_id;
-                                }
+                        if ( ! empty( $existing_activity_id ) ) {
+                                $activity_args['id'] = $existing_activity_id;
                         }
+                }
 
-                        // find the parent 'new_blog_post' activity entry
+                if ( empty( $activity_post_object ) ) {
+                        $activity_post_object = bp_activity_get_post_type_tracking_args( $comment->post->post_type );
+                }
+
+                if ( isset( $activity_post_object->action_id ) && isset( $activity_post_object->component_id ) ) {
+                        // find the parent 'new_post_type' activity entry
                         $parent_activity_id = bp_activity_get_activity_id( array(
-                                'component'         => 'blogs',
-                                'type'              => 'new_blog_post',
+                                'component'         => $activity_post_object->component_id,
+                                'type'              => $activity_post_object->action_id,
                                 'item_id'           => $blog_id,
-                                'secondary_item_id' => $recorded_comment->comment_post_ID
+                                'secondary_item_id' => $comment->comment_post_ID
                         ) );
+                }
 
-                        // we found the parent activity entry
-                        // so let's go ahead and reconfigure some activity args
-                        if ( ! empty( $parent_activity_id ) ) {
-                                // set the 'item_id' with the parent activity entry ID
-                                $args['item_id'] = $parent_activity_id;
+                // we found the parent activity entry
+                // so let's go ahead and reconfigure some activity args
+                if ( ! empty( $parent_activity_id ) ) {
+                        // set the parent activity entry ID
+                        $activity_args['activity_id'] = $parent_activity_id;
 
-                                // now see if the WP parent comment has a BP activity ID
-                                $comment_parent = 0;
-                                if ( ! empty( $recorded_comment->comment_parent ) ) {
-                                        $comment_parent = get_comment_meta( $recorded_comment->comment_parent, 'bp_activity_comment_id', true );
-                                }
+                        // now see if the WP parent comment has a BP activity ID
+                        $comment_parent = 0;
+                        if ( ! empty( $comment->comment_parent ) ) {
+                                $comment_parent = get_comment_meta( $comment->comment_parent, 'bp_activity_comment_id', true );
+                        }
 
-                                // WP parent comment does not have a BP activity ID
-                                // so set to 'new_blog_post' activity ID
-                                if ( empty( $comment_parent ) ) {
-                                        $comment_parent = $parent_activity_id;
-                                }
+                        // WP parent comment does not have a BP activity ID
+                        // so set to 'new_' . post_type activity ID
+                        if ( empty( $comment_parent ) ) {
+                                $comment_parent = $parent_activity_id;
+                        }
 
-                                $args['secondary_item_id'] = $comment_parent;
-                                $args['component']         = 'activity';
-                                $args['type']              = 'activity_comment';
+                        $activity_args['parent_id']         = $comment_parent;
+                        $activity_args['skip_notification'] = true;
 
-                        // could not find corresponding parent activity entry
-                        // so wipe out $args array
-                        } else {
-                                $args = array();
-                        }
+                // could not find corresponding parent activity entry
+                // so wipe out $args array
+                } else {
+                        $activity_args = array();
+                }
 
-                        // Record in activity streams
-                        if ( ! empty( $args ) ) {
-                                // @todo should we use bp_activity_new_comment()? that function will also send
-                                // an email to people in the activity comment thread
-                                //
-                                // what if a site already has some comment email notification plugin setup?
-                                // this is why I decided to go with bp_activity_add() to avoid any conflict
-                                // with existing comment email notification plugins
-                                $comment_activity_id = bp_activity_add( $args );
-
-                                if ( empty( $args['id'] ) ) {
-                                        // add meta to activity comment
-                                        bp_activity_update_meta( $comment_activity_id, 'bp_blogs_post_comment_id', $comment_id );
-                                        bp_activity_update_meta( $comment_activity_id, 'post_title', $recorded_comment->post->post_title );
-                                        bp_activity_update_meta( $comment_activity_id, 'post_url', add_query_arg( 'p', $recorded_comment->post->ID, home_url( '/' ) ) );
-
-                                        // add meta to comment
-                                        add_comment_meta( $comment_id, 'bp_activity_comment_id', $comment_activity_id );
+                // Record in activity streams
+                if ( ! empty( $activity_args ) ) {
+                        $activity_id = bp_activity_new_comment( $activity_args );
+
+                        if ( empty( $activity_args['id'] ) ) {
+                                // The activity metadata to inform about the corresponding comment ID
+                                bp_activity_update_meta( $activity_id, 'bp_blogs_post_comment_id', $comment->comment_ID );
+
+                                /**
+                                 * The activity metadata to inform about the "parent" action
+                                 * eg: the "parent" action for new_blog_comment is new_blog_post
+                                 *
+                                 * This is used to make sure filtering the activities using the new_{post_type}_comment action
+                                 * will fetch all new_{post_type}_comment activities & activity_comment activities belonging to
+                                 * the new_{post_type} parent activity
+                                 */
+                                bp_activity_update_meta( $activity_id, 'bp_parent_action', $activity_post_object->action_id );
+
+                                // The comment metadata to inform about the corresponding activity ID
+                                add_comment_meta( $comment->comment_ID, 'bp_activity_comment_id', $activity_id );
+
+                                // These activity metadatas are used to build the new_blog_comment action string
+                                if ( 'new_blog_comment' === $activity_post_object->comment_action_id ) {
+                                        bp_activity_update_meta( $activity_id, 'post_title', $comment->post->post_title );
+                                        bp_activity_update_meta( $activity_id, 'post_url', esc_url_raw( add_query_arg( 'p', $comment->post->ID, home_url( '/' ) ) ) );
                                 }
                         }
                 }
-
-                // Update the blogs last active date
-                bp_blogs_update_blogmeta( $blog_id, 'last_activity', bp_core_current_time() );
         }
 
-        return $recorded_comment;
+        // Update the blogs last active date
+        bp_blogs_update_blogmeta( $blog_id, 'last_activity', bp_core_current_time() );
+
+        return $activity_id;
 }
-add_action( 'comment_post', 'bp_blogs_record_comment', 10, 2 );
-add_action( 'edit_comment', 'bp_blogs_record_comment', 10    );
+add_action( 'bp_activity_post_type_comment', 'bp_blogs_comment_sync_activity_comment', 10, 4 );
 
 /**
  * Record a user's association with a blog.
@@ -974 +917 @@
  *
  * @param int $comment_id ID of the comment to be removed.
  */
-function bp_blogs_remove_comment( $comment_id ) {
+function bp_blogs_remove_synced_comment( $deleted, $comment_id, $activity_post_object ) {
         global $wpdb;
 
         // activity comments are disabled for blog posts
-        // which means that individual activity items exist for blog comments
         if ( bp_disable_blogforum_comments() ) {
-                // Delete the individual activity stream item
-                bp_blogs_delete_activity( array(
-                        'item_id'           => $wpdb->blogid,
-                        'secondary_item_id' => $comment_id,
-                        'type'              => 'new_blog_comment'
-                ) );
+                return;
+        }
 
-        // activity comments are enabled for blog posts
-        // remove the associated activity item
-        } else {
-                // get associated activity ID from comment meta
-                $activity_id = get_comment_meta( $comment_id, 'bp_activity_comment_id', true );
-
-                // delete the associated activity comment
-                //
-                // also removes child post comments and associated activity comments
-                if ( ! empty( $activity_id ) && bp_is_active( 'activity' ) ) {
-                        // fetch the activity comments for the activity item
-                        $activity = bp_activity_get( array(
-                                'in'               => $activity_id,
-                                'display_comments' => 'stream',
-                        ) );
+        // get associated activity ID from comment meta
+        $activity_id = get_comment_meta( $comment_id, 'bp_activity_comment_id', true );
+
+        // delete the associated activity comment
+        //
+        // also removes child post comments and associated activity comments
+        if ( ! empty( $activity_id ) ) {
+                // fetch the activity comments for the activity item
+                $activity = bp_activity_get( array(
+                        'in'               => $activity_id,
+                        'display_comments' => 'stream',
+                        'spam'             => 'all',
+                ) );
 
-                        // get all activity comment IDs for the pending deleted item
-                        if ( ! empty( $activity['activities'] ) ) {
-                                $activity_ids   = bp_activity_recurse_comments_activity_ids( $activity );
-                                $activity_ids[] = $activity_id;
+                // get all activity comment IDs for the pending deleted item
+                if ( ! empty( $activity['activities'] ) ) {
+                        $activity_ids   = bp_activity_recurse_comments_activity_ids( $activity );
+                        $activity_ids[] = $activity_id;
 
-                                // delete activity items
-                                foreach ( $activity_ids as $activity_id ) {
-                                        bp_activity_delete( array(
-                                                'id' => $activity_id
-                                        ) );
-                                }
+                        // delete activity items
+                        foreach ( $activity_ids as $activity_id ) {
+                                bp_activity_delete( array(
+                                        'id' => $activity_id
+                                ) );
+                        }
 
-                                // remove associated blog comments
-                                bp_blogs_remove_associated_blog_comments( $activity_ids );
+                        // remove associated blog comments
+                        bp_blogs_remove_associated_blog_comments( $activity_ids );
 
-                                // rebuild activity comment tree
-                                BP_Activity_Activity::rebuild_activity_comment_tree( $activity['activities'][0]->item_id );
-                        }
+                        // rebuild activity comment tree
+                        BP_Activity_Activity::rebuild_activity_comment_tree( $activity['activities'][0]->item_id );
                 }
         }
 
@@ -1035 +970 @@
          */
         do_action( 'bp_blogs_remove_comment', $wpdb->blogid, $comment_id, bp_loggedin_user_id() );
 }
-add_action( 'delete_comment', 'bp_blogs_remove_comment' );
+add_action( 'bp_activity_post_type_remove_comment', 'bp_blogs_remove_synced_comment', 10, 3 );
 
 /**
  * Removes blog comments that are associated with activity comments.
  *
  * @since BuddyPress (2.0.0)
  *
- * @see bp_blogs_remove_comment()
+ * @see bp_blogs_remove_synced_comment()
  * @see bp_blogs_sync_delete_from_activity_comment()
  *
  * @param array $activity_ids The activity IDs to check association with blog
@@ -1079 +1014 @@
 }
 
 /**
- * When a blog comment status transition occurs, update the relevant activity's status.
- *
- * @since BuddyPress (1.6.0)
- *
- * @param string $new_status New comment status.
- * @param string $old_status Previous comment status.
- * @param object $comment Comment data.
- */
-function bp_blogs_transition_activity_status( $new_status, $old_status, $comment ) {
-
-        // Check the Activity component is active
-        if ( ! bp_is_active( 'activity' ) )
-                return;
-
-        /**
-         * Activity currently doesn't have any concept of a trash, or an unapproved/approved state.
-         *
-         * If a blog comment transitions to a "delete" or "hold" status, delete the activity item.
-         * If a blog comment transitions to trashed, or spammed, mark the activity as spam.
-         * If a blog comment transitions to approved (and the activity exists), mark the activity as ham.
-         * If a blog comment transitions to unapproved (and the activity exists), mark the activity as spam.
-         * Otherwise, record the comment into the activity stream.
-         */
-
-        // This clause was moved in from bp_blogs_remove_comment() in BuddyPress 1.6. It handles delete/hold.
-        if ( in_array( $new_status, array( 'delete', 'hold' ) ) ) {
-                return bp_blogs_remove_comment( $comment->comment_ID );
-
-        // These clauses handle trash, spam, and un-spams.
-        } elseif ( in_array( $new_status, array( 'trash', 'spam', 'unapproved' ) ) ) {
-                $action = 'spam_activity';
-        } elseif ( 'approved' == $new_status ) {
-                $action = 'ham_activity';
-        }
-
-        // Get the activity
-        if ( bp_disable_blogforum_comments() ) {
-                $activity_id = bp_activity_get_activity_id( array(
-                        'component'         => buddypress()->blogs->id,
-                        'item_id'           => get_current_blog_id(),
-                        'secondary_item_id' => $comment->comment_ID,
-                        'type'              => 'new_blog_comment'
-                ) );
-        } else {
-                $activity_id = get_comment_meta( $comment->comment_ID, 'bp_activity_comment_id', true );
-        }
-
-        // Check activity item exists
-        if ( empty( $activity_id ) ) {
-                // If no activity exists, but the comment has been approved, record it into the activity table.
-                if ( 'approved' == $new_status ) {
-                        return bp_blogs_record_comment( $comment->comment_ID, true );
-                }
-
-                return;
-        }
-
-        // Create an activity object
-        $activity = new BP_Activity_Activity( $activity_id );
-        if ( empty( $activity->component ) )
-                return;
-
-        // Spam/ham the activity if it's not already in that state
-        if ( 'spam_activity' == $action && ! $activity->is_spam ) {
-                bp_activity_mark_as_spam( $activity );
-        } elseif ( 'ham_activity' == $action) {
-                bp_activity_mark_as_ham( $activity );
-        }
-
-        // Add "new_blog_comment" to the whitelisted activity types, so that the activity's Akismet history is generated
-        $comment_akismet_history = create_function( '$t', '$t[] = "new_blog_comment"; return $t;' );
-        add_filter( 'bp_akismet_get_activity_types', $comment_akismet_history );
-
-        // Save the updated activity
-        $activity->save();
-
-        // Remove the "new_blog_comment" activity type whitelist so we don't break anything
-        remove_filter( 'bp_akismet_get_activity_types', $comment_akismet_history );
-}
-add_action( 'transition_comment_status', 'bp_blogs_transition_activity_status', 10, 3 );
-
-/**
  * Get the total number of blogs being tracked by BuddyPress.
  *
  * @return int $count Total blog count.

src/bp-blogs/bp-blogs-loader.php

@@ -327 +327 @@
                 $params->contexts        = array( 'activity', 'member' );
                 $params->position        = 5;
 
+                if ( post_type_supports( $post_type, 'comments' ) ) {
+                        $params->comment_action_id = 'new_blog_comment';
+
+                        /**
+                         * Filters the post types to track for the Blogs component.
+                         *
+                         * @since BuddyPress (1.5.0)
+                         * @deprecated BuddyPress (2.3.0)
+                         *
+                         * Make sure plugins still using 'bp_blogs_record_comment_post_types'
+                         * to track comment about their post types will generate new_blog_comment activities
+                         * See https://buddypress.trac.wordpress.org/ticket/6306
+                         *
+                         * @param array $value Array of post types to track.
+                         */
+                        $comment_post_types = apply_filters( 'bp_blogs_record_comment_post_types', array( 'post' ) );
+                        $comment_post_types_array = array_flip( $comment_post_types );
+
+                        if ( isset( $comment_post_types_array[ $post_type ] ) ) {
+                                $params->comments_tracking = new stdClass();
+                                $params->comments_tracking->component_id      = $this->id;
+                                $params->comments_tracking->action_id         = 'new_blog_comment';
+                                $params->comments_tracking->admin_filter      = __( 'New post comment posted', 'buddypress' );
+                                $params->comments_tracking->format_callback   = 'bp_blogs_format_activity_action_new_blog_comment';
+                                $params->comments_tracking->front_filter      = __( 'Comments', 'buddypress' );
+                                $params->comments_tracking->contexts          = array( 'activity', 'member' );
+                                $params->comments_tracking->position          = 10;
+                        }
+                }
+
                 return $params;
         }
 }

src/bp-core/deprecated/1.6.php

@@ -85 +85 @@
 
 /**
  * @deprecated BuddyPress (1.6)
- * @deprecated No longer used; see bp_blogs_transition_activity_status()
+ * @deprecated No longer used; see bp_activity_transition_post_type_comment_status()
  */
 function bp_blogs_manage_comment( $comment_id, $comment_status ) {
         _deprecated_function( __FUNCTION__, '1.6', 'No longer used' );

src/bp-core/deprecated/2.4.php

@@ +1 @@
+<?php
+/**
+ * Deprecated functions.
+ *
+ * @deprecated 2.4.0
+ */
+
+// Exit if accessed directly.
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * Record a new blog comment in the BuddyPress activity stream.
+ *
+ * Only posts the item if blog is public and post is not password-protected.
+ *
+ * @deprecated BuddyPress (2.4.0)
+ *
+ * @param int $comment_id ID of the comment being recorded.
+ * @param bool|string $is_approved Optional. The $is_approved value passed to
+ *        the 'comment_post' action. Default: true.
+ * @return bool|object Returns false on failure, the comment object on success.
+ */
+function bp_blogs_record_comment( $comment_id, $is_approved = true ) {
+        _deprecated_function( __FUNCTION__, '2.4.0', 'bp_activity_post_type_comment()' );
+        bp_activity_post_type_comment( $comment_id, $is_approved );
+}
+
+/**
+ * Remove a blog comment activity item from the activity stream.
+ *
+ * @deprecated BuddyPress (2.4.0)
+ *
+ * @param int $comment_id ID of the comment to be removed.
+ */
+function bp_blogs_remove_comment( $comment_id ) {
+        _deprecated_function( __FUNCTION__, '2.4.0', 'bp_activity_post_type_remove_comment()' );
+        bp_activity_post_type_remove_comment( $comment_id );
+}
+
+/**
+ * When a blog comment status transition occurs, update the relevant activity's status.
+ *
+ * @since BuddyPress (1.6.0)
+ * @deprecated BuddyPress (2.4.0)
+ *
+ * @param string $new_status New comment status.
+ * @param string $old_status Previous comment status.
+ * @param object $comment Comment data.
+ */
+function bp_blogs_transition_activity_status( $new_status, $old_status, $comment ) {
+        _deprecated_function( __FUNCTION__, '2.4.0', 'bp_activity_transition_post_type_comment_status()' );
+        bp_activity_transition_post_type_comment_status( $new_status, $old_status, $comment );
+}
+

src/bp-loader.php

@@ -484 +484 @@
                         require( $this->plugin_dir . 'bp-core/deprecated/2.1.php' );
                         require( $this->plugin_dir . 'bp-core/deprecated/2.2.php' );
                         require( $this->plugin_dir . 'bp-core/deprecated/2.3.php' );
+                        require( $this->plugin_dir . 'bp-core/deprecated/2.4.php' );
                 }
         }
 

tests/phpunit/includes/testcase.php

@@ -40 +40 @@
 
                 // Fixes warnings in multisite functions
                 $_SERVER['REMOTE_ADDR'] = '';
+
+                // Make sure Activity actions are reset before each test
+                $this->reset_bp_activity_actions();
+
+                // Make sure all Post types activities globals are reset before each test
+                $this->reset_bp_activity_post_types_globals();
         }
 
         function clean_up_global_scope() {
@@ -75 +81 @@
                 }
         }
 
+        protected function reset_bp_activity_actions() {
+                buddypress()->activity->actions = new stdClass();
+
+                /**
+                 * Populate the global with default activity actions only
+                 * before each test.
+                 */
+                do_action( 'bp_register_activity_actions' );
+        }
+
+        protected function reset_bp_activity_post_types_globals() {
+                global $wp_post_types;
+
+                // Remove all remaining tracking arguments to each post type
+                foreach ( $wp_post_types as $post_type => $post_type_arg ) {
+                        if ( post_type_supports( $post_type, 'buddypress-activity' ) ) {
+                                remove_post_type_support( 'page', 'buddypress-activity' );
+                        }
+
+                        if ( isset( $post_type_arg->bp_activity ) ) {
+                                unset( $post_type_arg->bp_activity );
+                        }
+                }
+
+                buddypress()->activity->track = array();
+        }
+
         function assertPreConditions() {
                 parent::assertPreConditions();
 

tests/phpunit/testcases/activity/template.php

@@ -1216 +1216 @@
 
         /**
          * @group bp_has_activities
+         * @group post_type_comment_activities
          */
         public function test_bp_has_activities_with_type_new_blog_comments() {
                 add_filter( 'bp_disable_blogforum_comments', '__return_false' );

tests/phpunit/testcases/blogs/filters.php

@@ -2 +2 @@
 /**
  * @group blogs
  * @ticket BP6306
+ * @group post_type_comment_activities
  */
 class BP_Tests_Blogs_Filters extends BP_UnitTestCase {
         protected $activity_actions;
@@ -42 +43 @@
         }
 
         /**
-         * @goup bp_activity_get_actions
+         * @group bp_activity_get_actions
          */
         public function test_bp_activity_get_actions() {
                 $activity_actions = bp_activity_get_actions();
@@ -51 +52 @@
         }
 
         /**
-         * @goup bp_activity_catch_transition_post_type_status
+         * @group bp_activity_catch_transition_post_type_status
          */
         public function test_bp_activity_catch_transition_post_type_status() {
                 $post_id = $this->factory->post->create( array(
@@ -63 +64 @@
         }
 
         /**
-         * @goup bp_blogs_record_comment
+         * @group bp_blogs_record_comment
          */
         public function test_bp_blogs_record_comment() {
                 $u = $this->factory->user->create();
@@ -88 +89 @@
         }
 
         /**
-         * @goup bp_blogs_record_comment_sync_activity_comment
+         * @group bp_blogs_record_comment_sync_activity_comment
          */
         public function test_bp_blogs_record_comment_sync_activity_comment() {
                 $u = $this->factory->user->create();

tests/phpunit/testcases/blogs/functions.php

@@ -513 +513 @@
 
         /**
          * @group bp_blogs_catch_transition_post_status
+         * @group post_type_comment_activities
          */
         public function test_update_blog_post_and_new_blog_comment_and_activity_comment_meta() {
                 // save the current user and override logged-in user