/**
  * @ticket BP7237
  * @ticket BP6643
  * @ticket BP7245
  */
 public function test_last_activity_should_bust_activity_with_last_activity_cache()
 {
     global $wpdb;
     $u1 = $this->factory->user->create();
     $u2 = $this->factory->user->create();
     $time_1 = date('Y-m-d H:i:s', time() - HOUR_IN_SECONDS);
     $time_2 = date('Y-m-d H:i:s', time() - HOUR_IN_SECONDS * 2);
     bp_update_user_last_activity($u1, $time_1);
     bp_update_user_last_activity($u2, $time_2);
     $activity_args_a = array('filter' => array('object' => buddypress()->members->id, 'action' => 'last_activity'), 'max' => 1);
     $activity_args_b = array('filter' => array('action' => 'new_member'), 'fields' => 'ids');
     // Prime bp_activity and bp_activity_with_last_activity caches.
     $a1 = bp_activity_get($activity_args_a);
     $expected = array($u1, $u2);
     $found = array_map('intval', wp_list_pluck($a1['activities'], 'user_id'));
     $this->assertSame($expected, $found);
     $b1 = bp_activity_get($activity_args_b);
     // Bump u2 activity so it should appear first.
     $new_time = date('Y-m-d H:i:s', time() - HOUR_IN_SECONDS);
     bp_update_user_last_activity($u2, $new_time);
     $a2 = bp_activity_get($activity_args_a);
     $expected = array($u2, $u1);
     $found = array_map('intval', wp_list_pluck($a2['activities'], 'user_id'));
     $this->assertSame($expected, $found);
     $num_queries = $wpdb->num_queries;
     // bp_activity cache should not have been touched.
     $b2 = bp_activity_get($activity_args_b);
     $this->assertEqualSets($b1, $b2);
     $this->assertSame($num_queries, $wpdb->num_queries);
 }

function bp_media_activity_parent_content_filter($activity_content)
{
    global $activities_template;
    $defaults = array('hide_user' => false);
    if (!($parent_id = $activities_template->activity->item_id)) {
        return false;
    }
    if (!isset($bp_media_hidden_activity_cache[$parent_id])) {
        $activities = bp_activity_get(array('in' => $parent_id));
        if (isset($activities['activities'][0])) {
            $bp_media_hidden_activity_cache[$parent_id] = $activities['activities'][0];
        }
    }
    if (empty($bp_media_hidden_activity_cache[$parent_id])) {
        return false;
    }
    if (empty($bp_media_hidden_activity_cache[$parent_id]->content)) {
        $content = $bp_media_hidden_activity_cache[$parent_id]->action;
    } else {
        $content = $bp_media_hidden_activity_cache[$parent_id]->action . ' ' . $bp_media_hidden_activity_cache[$parent_id]->content;
    }
    // Remove the time since content for backwards compatibility
    $content = str_replace('<span class="time-since">%s</span>', '', $content);
    // Remove images
    $content = preg_replace('/<img[^>]*>/Ui', '', $content);
    return $content;
    return $activity_content;
}

 /**
  * @group bp_xprofile_updated_profile_activity
  */
 public function test_bp_xprofile_updated_profile_activity_no_existing_activity()
 {
     $d = $this->setup_updated_profile_data();
     // Fake new/old values to ensure a change
     $old_values = array($this->updated_profile_data['f'] => array('value' => 'foo', 'visibility' => 'public'));
     $new_values = array($this->updated_profile_data['f'] => array('value' => 'foo2', 'visibility' => 'public'));
     $this->assertTrue(bp_xprofile_updated_profile_activity($d['u'], array($d['f']), false, $old_values, $new_values));
     $existing = bp_activity_get(array('max' => 1, 'filter' => array('user_id' => $d['u'], 'object' => buddypress()->profile->id, 'action' => 'updated_profile'), 'count_total' => 'count_query'));
     $this->assertEquals(1, $existing['total']);
 }

 /**
  * @group bp_activity_clear_cache_for_activity
  */
 public function test_bp_activity_clear_cache_for_activity()
 {
     $u = $this->factory->user->create();
     $a = $this->factory->activity->create(array('component' => buddypress()->activity->id, 'type' => 'activity_update', 'user_id' => $u, 'content' => 'foo bar'));
     $a_fp = bp_activity_get(array('type' => 'activity_update', 'user' => array('filter' => array('user_id' => $u))));
     $activity_updated = new BP_Activity_Activity($a);
     $activity_updated->content = 'bar foo';
     $activity_updated->save();
     $a_fp = bp_activity_get(array('type' => 'activity_update', 'user' => array('filter' => array('user_id' => $u))));
     $this->assertSame('bar foo', $a_fp['activities'][0]->content);
 }

 public function getResults($search)
 {
     $results = array();
     if (!$this->isEnabled()) {
         return $results;
     }
     $results = bp_activity_get(array('filter' => array('action' => 'activity_update'), 'search_terms' => $search));
     return array_map(function ($activity) use($search) {
         return new Expert_Finder_Activity_Stream_Result($activity, $this->options['A'], $search);
     }, $results['activities']);
 }

 /**
  * Make sure doc activity is deleted when the doc is deleted
  */
 function test_delete_activity_on_doc_deletion()
 {
     $doc_id = $this->factory->doc->create();
     $activity_args = array('component' => 'docs', 'item_id' => 1, 'secondary_item_id' => $doc_id, 'type' => 'bp_doc_edited');
     $activity_id = $this->factory->activity->create($activity_args);
     $activity_args2 = array('component' => 'docs', 'item_id' => 1, 'secondary_item_id' => $doc_id, 'type' => 'bp_doc_created');
     $activity_id2 = $this->factory->activity->create($activity_args2);
     // Now delete using the api method
     bp_docs_trash_doc($doc_id);
     $activities = bp_activity_get(array('filter' => array('secondary_id' => $doc_id, 'component' => 'docs')));
     $this->assertEquals($activities['activities'], array());
 }

function bp_media_upgrade_to_2_2()
{
    global $wpdb;
    remove_filter('bp_activity_get_user_join_filter', 'bp_media_activity_query_filter', 10);
    /* @var $wpdb wpdb */
    $media_files = new WP_Query(array('post_type' => 'bp_media', 'posts_per_page' => -1));
    $media_files = $media_files->posts;
    $wall_posts_album_ids = array();
    if (is_array($media_files) && count($media_files)) {
        foreach ($media_files as $media_file) {
            $attachment_id = get_post_meta($media_file->ID, 'bp_media_child_attachment', true);
            $child_activity = get_post_meta($media_file->ID, 'bp_media_child_activity', true);
            update_post_meta($attachment_id, 'bp_media_child_activity', $child_activity);
            $attachment = get_post($attachment_id, ARRAY_A);
            if (isset($wall_posts_album_ids[$media_file->post_author])) {
                $wall_posts_id = $wall_posts_album_ids[$media_file->post_author];
            } else {
                $wall_posts_id = $wpdb->get_var("SELECT ID FROM {$wpdb->posts} WHERE post_title = 'Wall Posts' AND post_author = '" . $media_file->post_author . "' AND post_type='bp_media_album'");
                if ($wall_posts_id == null) {
                    $album = new BP_Media_Album();
                    $album->add_album('Wall Posts', $media_file->post_author);
                    $wall_posts_id = $album->get_id();
                }
                if (!$wall_posts_id) {
                    continue;
                    //This condition should never be encountered
                }
                $wall_posts_album_ids[$media_file->post_author] = $wall_posts_id;
            }
            $attachment['post_parent'] = $wall_posts_id;
            wp_update_post($attachment);
            update_post_meta($attachment_id, 'bp-media-key', $media_file->post_author);
            $activity = bp_activity_get(array('in' => intval($child_activity)));
            if (isset($activity['activities'][0]->id)) {
                $activity = $activity['activities'][0];
            }
            $bp_media = new BP_Media_Host_Wordpress($attachment_id);
            $args = array('content' => $bp_media->get_media_activity_content(), 'id' => $child_activity, 'type' => 'media_upload', 'action' => apply_filters('bp_media_added_media', sprintf(__('%1$s added a %2$s', 'bp-media'), bp_core_get_userlink($media_file->post_author), '<a href="' . $bp_media->get_url() . '">' . $bp_media->get_media_activity_type() . '</a>')), 'primary_link' => $bp_media->get_url(), 'item_id' => $attachment_id, 'recorded_time' => $activity->date_recorded);
            $act_id = bp_media_record_activity($args);
            bp_activity_delete_meta($child_activity, 'bp_media_parent_post');
            wp_delete_post($media_file->ID);
        }
    }
    update_option('bp_media_db_version', BP_MEDIA_DB_VERSION);
    add_action('admin_notices', 'bp_media_database_updated_notice');
    wp_cache_flush();
}

function wangguard_bp_activity_spam_all_user_data($user_id = 0)
{
    global $bp, $wpdb;
    // Do not delete user data unless a logged in user says so
    if (empty($user_id)) {
        return false;
    }
    // Get all the user's activities.
    $activities = bp_activity_get(array('display_comments' => 'stream', 'filter' => array('user_id' => $user_id), 'show_hidden' => true));
    // Mark each as spam
    foreach ((array) $activities['activities'] as $activity) {
        // Create an activity object
        $activity_obj = new BP_Activity_Activity();
        foreach ($activity as $k => $v) {
            $activity_obj->{$k} = $v;
        }
        // Mark as spam
        bp_activity_mark_as_spam($activity_obj);
        /*
         * If Akismet is present, update the activity history meta.
         *
         * This is usually taken care of when BP_Activity_Activity::save() happens, but
         * as we're going to be updating all the activity statuses directly, for efficency,
         * we need to update manually.
         */
        if (!empty($bp->activity->akismet)) {
            $bp->activity->akismet->update_activity_spam_meta($activity_obj);
        }
        // Tidy up
        unset($activity_obj);
    }
    // Mark all of this user's activities as spam
    $wpdb->query($wpdb->prepare("UPDATE {$bp->activity->table_name} SET is_spam = 1 WHERE user_id = %d", $user_id));
    // Call an action for plugins to use
    do_action('bp_activity_spam_all_user_data', $user_id, $activities['activities']);
}

 /**
  * Posts an activity item on doc save
  *
  * @package BuddyPress Docs
  * @since 1.0-beta
  *
  * @param obj $query The query object created in BP_Docs_Query and passed to the
  *     bp_docs_doc_saved filter
  * @return int $activity_id The id number of the activity created
  */
 function post_activity($query)
 {
     global $bp;
     // todo: exception for autosave?
     if (!bp_is_active('activity')) {
         return false;
     }
     $doc_id = !empty($query->doc_id) ? $query->doc_id : false;
     if (!$doc_id) {
         return false;
     }
     $last_editor = get_post_meta($doc_id, 'bp_docs_last_editor', true);
     // Throttle 'doc edited' posts. By default, one per user per hour
     if (!$query->is_new_doc) {
         // Look for an existing activity item corresponding to this user editing
         // this doc
         $already_args = array('max' => 1, 'sort' => 'DESC', 'show_hidden' => 1, 'filter' => array('user_id' => $last_editor, 'action' => 'bp_doc_edited', 'secondary_id' => $doc_id));
         $already_activity = bp_activity_get($already_args);
         // If any activity items are found, compare its date_recorded with time() to
         // see if it's within the allotted throttle time. If so, don't record the
         // activity item
         if (!empty($already_activity['activities'])) {
             $date_recorded = $already_activity['activities'][0]->date_recorded;
             $drunix = strtotime($date_recorded);
             if (time() - $drunix <= apply_filters('bp_docs_edit_activity_throttle_time', 60 * 60)) {
                 return;
             }
         }
     }
     $doc = get_post($doc_id);
     // Set the action. Filterable so that other integration pieces can alter it
     $action = '';
     $user_link = bp_core_get_userlink($last_editor);
     $doc_url = bp_docs_get_doc_link($doc_id);
     $doc_link = '<a href="' . $doc_url . '">' . $doc->post_title . '</a>';
     if ($query->is_new_doc) {
         $action = sprintf(__('%1$s created the doc %2$s', 'bp-docs'), $user_link, $doc_link);
     } else {
         $action = sprintf(__('%1$s edited the doc %2$s', 'bp-docs'), $user_link, $doc_link);
     }
     $action = apply_filters('bp_docs_activity_action', $action, $user_link, $doc_link, $query->is_new_doc, $query);
     // Get a canonical name for the component. This is a nightmare because of the way
     // the current component and root slug relate in BP 1.3+
     if (function_exists('bp_is_current_component')) {
         foreach ($bp->active_components as $comp => $value) {
             if (bp_is_current_component($comp)) {
                 $component = $comp;
                 break;
             }
         }
     } else {
         $component = bp_current_component();
     }
     // This is only temporary! This item business needs to be component-neutral
     $item = isset($bp->groups->current_group->id) ? $bp->groups->current_group->id : false;
     // Set the type, to be used in activity filtering
     $type = $query->is_new_doc ? 'bp_doc_created' : 'bp_doc_edited';
     $args = array('user_id' => $last_editor, 'action' => $action, 'primary_link' => $doc_url, 'component' => $component, 'type' => $type, 'item_id' => $query->item_id, 'secondary_item_id' => $doc_id, 'recorded_time' => bp_core_current_time(), 'hide_sitewide' => apply_filters('bp_docs_hide_sitewide', false, false, $doc, $item, $component));
     do_action('bp_docs_before_activity_save', $args);
     $activity_id = bp_activity_add(apply_filters('bp_docs_activity_args', $args));
     do_action('bp_docs_after_activity_save', $activity_id, $args);
     return $activity_id;
 }

 protected function activity_exists_for_post_type($item_id, $secondary_item_id, $action, $display_comments = false)
 {
     $a = bp_activity_get(array('display_comments' => $display_comments, 'filter' => array('action' => $action, 'primary_id' => $item_id, 'secondary_id' => $secondary_item_id)));
     return !empty($a['activities']);
 }

/**
 * Deletes the blog comment when the associated activity comment is deleted.
 *
 * Note: This is hooked on the 'bp_activity_delete_comment_pre' filter instead
 * of the 'bp_activity_delete_comment' action because we need to fetch the
 * activity comment children before they are deleted.
 *
 * @since 2.0.0
 * @since 2.5.0 Add the $delected parameter
 *
 * @param bool $retval             Whether BuddyPress should continue or not.
 * @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.
 * @return bool
 */
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 parent activity isn't a post type having the buddypress-activity support, stop now!
    if (!bp_activity_type_supports($parent_activity->type, 'post-type-comment-tracking')) {
        return $retval;
    }
    // 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.
    $activity_ids = bp_activity_recurse_comments_activity_ids($activity);
    $activity_ids[] = $activity_id;
    // Handle multisite
    // switch to the blog where the comment was made.
    switch_to_blog($parent_activity->item_id);
    // Remove associated blog comments.
    bp_blogs_remove_associated_blog_comments($activity_ids, current_user_can('moderate_comments'));
    // Multisite again!
    restore_current_blog();
    // Rebuild activity comment tree
    // 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;
}

/**
 * Create activity for paper edits.
 *
 * Edit activity is throttled: no more than one activity item per 60 minutes.
 *
 * @param int     $post_id     ID of the post.
 * @param WP_Post $post_after  New post.
 * @param WP_Post $post_before Old post.
 */
function cacsp_create_edit_activity($post_id, WP_Post $post_after, WP_Post $post_before)
{
    if ('cacsp_paper' !== $post_after->post_type) {
        return;
    }
    // We only want to record edits of published posts. Drafts don't get activity, and BP handles publishing.
    if ('publish' !== $post_before->post_status || 'publish' !== $post_after->post_status) {
        return;
    }
    // The author of the edit is the one who wrote the last revision.
    if ($revisions = wp_get_post_revisions($post_id)) {
        // Grab the last revision, but not an autosave.
        foreach ($revisions as $revision) {
            if (false !== strpos($revision->post_name, "{$revision->post_parent}-revision")) {
                $last_revision = $revision;
                break;
            }
        }
    }
    // Either revisions are disabled, or something else has gone wrong. Just use the post author.
    if (!isset($last_revision)) {
        $rev_author = $post_after->post_author;
    } else {
        $rev_author = $last_revision->post_author;
    }
    // Throttle.
    $existing = bp_activity_get(array('filter_query' => array(array('column' => 'component', 'value' => 'cacsp'), array('column' => 'type', 'value' => 'new_cacsp_edit'), array('column' => 'secondary_item_id', 'value' => $post_id), array('column' => 'user_id', 'value' => $rev_author)), 'update_meta_cache' => false, 'per_page' => 1));
    if (!empty($existing['activities'])) {
        /**
         * Filters the number of seconds in the edit throttle.
         *
         * This prevents activity stream flooding by multiple edits of the same paper.
         *
         * @param int $throttle_period Defaults to 6 hours.
         */
        $throttle_period = apply_filters('bpeo_event_edit_throttle_period', 6 * HOUR_IN_SECONDS);
        if (time() - strtotime($existing['activities'][0]->date_recorded) < $throttle_period) {
            return;
        }
    }
    // Poor man's diff. https://coderwall.com/p/3j2hxq/find-and-format-difference-between-two-strings-in-php
    $old = $post_before->post_content;
    $new = $post_after->post_content;
    $from_start = strspn($old ^ $new, "");
    $from_end = strspn(strrev($old) ^ strrev($new), "");
    $old_end = strlen($old) - $from_end;
    $new_end = strlen($new) - $from_end;
    $start = substr($new, 0, $from_start);
    $end = substr($new, $new_end);
    $new_diff = substr($new, $from_start, $new_end - $from_start);
    // Take a few words before the diff.
    $_start = explode(' ', $start);
    $_start = implode(' ', array_slice($_start, -5));
    $content = bp_create_excerpt('&hellip;' . $_start . $new_diff . $end);
    $activity_id = bp_activity_add(array('content' => $content, 'component' => 'cacsp', 'type' => 'new_cacsp_edit', 'primary_link' => get_permalink($post_id), 'user_id' => $rev_author, 'item_id' => get_current_blog_id(), 'secondary_item_id' => $post_id, 'hide_sitewide' => false));
}

/**
 * Create an activity item for a newly published post type post.
 *
 * @since 2.2.0
 *
 * @param int          $post_id ID of the new post.
 * @param WP_Post|null $post    Post object.
 * @param int          $user_id ID of the post author.
 * @return int|bool The ID of the activity on success. False on error.
 */
function bp_activity_post_type_publish($post_id = 0, $post = null, $user_id = 0)
{
    if (!is_a($post, 'WP_Post')) {
        return;
    }
    // Get the post type tracking args.
    $activity_post_object = bp_activity_get_post_type_tracking_args($post->post_type);
    if ('publish' != $post->post_status || !empty($post->post_password) || empty($activity_post_object->action_id)) {
        return;
    }
    if (empty($post_id)) {
        $post_id = $post->ID;
    }
    $blog_id = get_current_blog_id();
    if (empty($user_id)) {
        $user_id = (int) $post->post_author;
    }
    // Bail if an activity item already exists for this post.
    $existing = bp_activity_get(array('filter' => array('action' => $activity_post_object->action_id, 'primary_id' => $blog_id, 'secondary_id' => $post_id)));
    if (!empty($existing['activities'])) {
        return;
    }
    /**
     * Filters whether or not to post the activity.
     *
     * This is a variable filter, dependent on the post type,
     * that lets components or plugins bail early if needed.
     *
     * @since 2.2.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 published.
     * @param int  $user_id ID of the current user or post author.
     */
    if (false === apply_filters("bp_activity_{$post->post_type}_pre_publish", true, $blog_id, $post_id, $user_id)) {
        return;
    }
    // Record this in activity streams.
    $blog_url = get_home_url($blog_id);
    $post_url = add_query_arg('p', $post_id, trailingslashit($blog_url));
    // Backward compatibility filters for the 'blogs' component.
    if ('blogs' == $activity_post_object->component_id) {
        $activity_content = apply_filters('bp_blogs_activity_new_post_content', $post->post_content, $post, $post_url, $post->post_type);
        $activity_primary_link = apply_filters('bp_blogs_activity_new_post_primary_link', $post_url, $post_id, $post->post_type);
    } else {
        $activity_content = $post->post_content;
        $activity_primary_link = $post_url;
    }
    $activity_args = array('user_id' => $user_id, 'content' => $activity_content, 'primary_link' => $activity_primary_link, 'component' => $activity_post_object->component_id, 'type' => $activity_post_object->action_id, 'item_id' => $blog_id, 'secondary_item_id' => $post_id, 'recorded_time' => $post->post_date_gmt);
    if (!empty($activity_args['content'])) {
        // Create the excerpt.
        $activity_summary = bp_activity_create_summary($activity_args['content'], $activity_args);
        // Backward compatibility filter for blog posts.
        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->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->post_title, 'post_url' => $post_url));
    $activity_args['action'] = call_user_func_array($activity_post_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 2.2.0
     *
     * @param int     $activity_id   ID of the newly published activity item.
     * @param WP_Post $post          Post object.
     * @param array   $activity_args Array of activity arguments.
     */
    do_action('bp_activity_post_type_published', $activity_id, $post, $activity_args);
    return $activity_id;
}

 function __construct($page, $per_page, $max, $include, $sort, $filter, $search_terms, $display_comments, $show_hidden, $exclude = false, $in = false)
 {
     global $bp;
     $this->pag_page = isset($_REQUEST['acpage']) ? intval($_REQUEST['acpage']) : $page;
     $this->pag_num = isset($_REQUEST['num']) ? intval($_REQUEST['num']) : $per_page;
     // Check if blog/forum replies are disabled
     $this->disable_blogforum_replies = isset($bp->site_options['bp-disable-blogforum-comments']) ? $bp->site_options['bp-disable-blogforum-comments'] : false;
     // Get an array of the logged in user's favorite activities
     $this->my_favs = maybe_unserialize(bp_get_user_meta($bp->loggedin_user->id, 'bp_favorite_activities', true));
     // Fetch specific activity items based on ID's
     if (!empty($include)) {
         $this->activities = bp_activity_get_specific(array('activity_ids' => explode(',', $include), 'max' => $max, 'page' => $this->pag_page, 'per_page' => $this->pag_num, 'sort' => $sort, 'display_comments' => $display_comments, 'show_hidden' => $show_hidden));
     } else {
         $this->activities = bp_activity_get(array('display_comments' => $display_comments, 'max' => $max, 'per_page' => $this->pag_num, 'page' => $this->pag_page, 'sort' => $sort, 'search_terms' => $search_terms, 'filter' => $filter, 'show_hidden' => $show_hidden, 'exclude' => $exclude, 'in' => $in));
     }
     if (!$max || $max >= (int) $this->activities['total']) {
         $this->total_activity_count = (int) $this->activities['total'];
     } else {
         $this->total_activity_count = (int) $max;
     }
     $this->activities = $this->activities['activities'];
     if ($max) {
         if ($max >= count($this->activities)) {
             $this->activity_count = count($this->activities);
         } else {
             $this->activity_count = (int) $max;
         }
     } else {
         $this->activity_count = count($this->activities);
     }
     $this->full_name = $bp->displayed_user->fullname;
     // Fetch parent content for activity comments so we do not have to query in the loop
     foreach ((array) $this->activities as $activity) {
         if ('activity_comment' != $activity->type) {
             continue;
         }
         $parent_ids[] = $activity->item_id;
     }
     if (!empty($parent_ids)) {
         $activity_parents = bp_activity_get_specific(array('activity_ids' => $parent_ids));
     }
     if (!empty($activity_parents['activities'])) {
         foreach ($activity_parents['activities'] as $parent) {
             $this->activity_parents[$parent->id] = $parent;
         }
         unset($activity_parents);
     }
     if ((int) $this->total_activity_count && (int) $this->pag_num) {
         $this->pag_links = paginate_links(array('base' => add_query_arg('acpage', '%#%'), 'format' => '', 'total' => ceil((int) $this->total_activity_count / (int) $this->pag_num), 'current' => (int) $this->pag_page, 'prev_text' => _x('←', 'Activity pagination previous text', 'buddypress'), 'next_text' => _x('→', 'Activity pagination next text', 'buddypress'), 'mid_size' => 1));
     }
 }

/**
 * Remove a blog comment activity item from the activity stream.
 *
 * @param int $comment_id ID of the comment to be removed.
 */
function bp_blogs_remove_comment($comment_id)
{
    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'));
        // 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 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));
                }
                // 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);
            }
        }
    }
    /**
     * Fires after a blog comment activity item was removed from activity stream.
     *
     * @since BuddyPress (1.0.0)
     *
     * @param int $blogid     Item ID for the blog associated with the removed comment.
     * @param int $comment_id ID of the comment being removed.
     * @param int $value      ID of the current logged in user.
     */
    do_action('bp_blogs_remove_comment', $wpdb->blogid, $comment_id, bp_loggedin_user_id());
}

 /**
  * Process the repair tool
  *
  * In case something went wrong with group activities (visibility, component...),
  * this tool should repair the problematic activities.
  *
  * @package WP Idea Stream
  * @subpackage buddypress/activity
  *
  * @since 2.0.0
  *
  * @global $wpdb
  * @uses   bp_is_active() to check if a component is active
  * @uses   wp_list_pluck() to pluck a certain field out of each object in a list.
  * @uses   bp_activity_get() to get all ideastream activities
  * @uses   wp_filter_object_list() to filter a list of objects, based on a set of key => value arguments.
  * @uses   wp_parse_id_list() to sanitize a list of ids
  * @uses   get_post_meta() to get the group id the idea is attached to
  * @uses   groups_get_groups() to get the needed groups
  * @uses   WP_Idea_Stream_Activity::bulk_edit_activity() to update the activities (component/item_id/visibility)
  * @return array the result of the repair operation.
  */
 public function repair_activities()
 {
     global $wpdb;
     $buddypress = buddypress();
     $blog_id = get_current_blog_id();
     // Description of this tool, displayed to the user
     $statement = __('Making sure IdeaStream activities are consistent: %s', 'wp-idea-stream');
     // Default to failure text
     $result = __('No activity needs to be repaired.', 'wp-idea-stream');
     // Default to unrepaired
     $repair = 0;
     if (!bp_is_active('groups')) {
         return;
     }
     $ideastream_types = wp_list_pluck($this->activity_actions, 'type');
     // Get all activities
     $ideastream_activities = bp_activity_get(array('filter' => array('action' => $ideastream_types), 'show_hidden' => true, 'spam' => 'all', 'per_page' => false));
     if (is_array($ideastream_activities['activities'])) {
         $idea_comments = array();
         $idea_posts = array();
         $to_repair = array();
         $attached_component = array('comment' => array($buddypress->groups->id => array(), $buddypress->blogs->id => array()), 'post' => array($buddypress->groups->id => array(), $buddypress->blogs->id => array()));
         foreach ($ideastream_activities['activities'] as $activity) {
             if (false !== strpos($activity->type, 'comment')) {
                 $idea_comments[$activity->id] = $activity->secondary_item_id;
                 $attached_component['comment'][$activity->component][] = $activity->id;
             } else {
                 $idea_posts[$activity->id] = $activity->secondary_item_id;
                 $attached_component['post'][$activity->component][] = $activity->id;
             }
         }
         // Gets the comment activities to repair
         if (!empty($idea_comments)) {
             // I don't think get_comments() allow us to get comments
             // using a list of comment ids..
             $in = implode(',', wp_parse_id_list($idea_comments));
             $sql = array('select' => "SELECT c.comment_ID, m.meta_value as group_id", 'from' => "FROM {$wpdb->comments} c LEFT JOIN {$wpdb->postmeta} m", 'on' => "ON (c.comment_post_ID = m.post_id )", 'where' => $wpdb->prepare("WHERE comment_ID IN ({$in}) AND m.meta_key = %s", '_ideastream_group_id'));
             $idea_comments_check = $wpdb->get_results(join(' ', $sql), OBJECT_K);
             foreach ($idea_comments as $activity_comment_id => $comment_secondary_id) {
                 if (!empty($idea_comments_check[$comment_secondary_id]) && !in_array($activity_comment_id, $attached_component['comment'][$buddypress->groups->id])) {
                     $to_repair['groups'][$idea_comments_check[$comment_secondary_id]->group_id][] = $activity_comment_id;
                 } else {
                     if (empty($idea_comments_check[$comment_secondary_id]) && in_array($activity_comment_id, $attached_component['comment'][$buddypress->groups->id])) {
                         $to_repair['blogs'][] = $activity_comment_id;
                     }
                 }
             }
         }
         // Gets the idea activities to repair
         if (!empty($idea_posts)) {
             add_filter('wp_idea_stream_ideas_get_status', 'wp_idea_stream_ideas_get_all_status', 10, 1);
             // Get user's ideas posted in the group
             $idea_posts_check = wp_idea_stream_ideas_get_ideas(array('per_page' => -1, 'include' => $idea_posts, 'meta_query' => array(array('key' => '_ideastream_group_id', 'compare' => 'EXIST'))));
             $idea_posts_check = wp_list_pluck($idea_posts_check['ideas'], 'ID');
             remove_filter('wp_idea_stream_ideas_get_status', 'wp_idea_stream_ideas_get_all_status', 10, 1);
             foreach ($idea_posts as $activity_post_id => $post_secondary_id) {
                 if (in_array($post_secondary_id, $idea_posts_check) && !in_array($activity_post_id, $attached_component['post'][$buddypress->groups->id])) {
                     $group_id = get_post_meta($post_secondary_id, '_ideastream_group_id', true);
                     if (!empty($group_id)) {
                         $to_repair['groups'][$group_id][] = $activity_post_id;
                     }
                 } else {
                     if (!in_array($post_secondary_id, $idea_posts_check) && in_array($activity_post_id, $attached_component['post'][$buddypress->groups->id])) {
                         $to_repair['blogs'][] = $activity_post_id;
                     }
                 }
             }
         }
     }
     if (!empty($to_repair['groups'])) {
         // Get the groups to have their status
         $groups = groups_get_groups(array('show_hidden' => true, 'populate_extras' => false, 'include' => join(',', array_keys($to_repair['groups'])), 'per_page' => false));
         if (!empty($groups['groups'])) {
             $public_groups = wp_filter_object_list($groups['groups'], array('status' => 'public'), 'and', 'id');
             foreach ($to_repair['groups'] as $item_id => $repair_activities) {
                 $hide_sitewide = 0;
                 if (!in_array($item_id, $public_groups)) {
                     $hide_sitewide = 1;
//.........这里部分代码省略.........

 /**
  * Add action links to Stream drop row in admin list screen
  *
  * @filter wp_stream_action_links_{connector}
  *
  * @param  array  $links     Previous links registered
  * @param  object $record    Stream record
  *
  * @return array             Action links
  */
 public static function action_links($links, $record)
 {
     if (in_array($record->context, array('components'))) {
         $option_key = wp_stream_get_meta($record, 'option_key', true);
         if ('bp-active-components' === $option_key) {
             $links[__('Edit', 'stream')] = add_query_arg(array('page' => 'bp-components'), admin_url('admin.php'));
         } elseif ('bp-pages' === $option_key) {
             $page_id = wp_stream_get_meta($record, 'page_id', true);
             $links[__('Edit setting', 'stream')] = add_query_arg(array('page' => 'bp-page-settings'), admin_url('admin.php'));
             if ($page_id) {
                 $links[__('Edit Page', 'stream')] = get_edit_post_link($page_id);
                 $links[__('View', 'stream')] = get_permalink($page_id);
             }
         }
     } elseif (in_array($record->context, array('settings'))) {
         $links[__('Edit setting', 'stream')] = add_query_arg(array('page' => wp_stream_get_meta($record, 'page', true)), admin_url('admin.php'));
     } elseif (in_array($record->context, array('groups'))) {
         $group_id = wp_stream_get_meta($record, 'id', true);
         $group = groups_get_group(array('group_id' => $group_id));
         if ($group) {
             // Build actions URLs
             $base_url = bp_get_admin_url('admin.php?page=bp-groups&gid=' . $group_id);
             $delete_url = wp_nonce_url($base_url . '&action=delete', 'bp-groups-delete');
             $edit_url = $base_url . '&action=edit';
             $visit_url = bp_get_group_permalink($group);
             $links[__('Edit group', 'stream')] = $edit_url;
             $links[__('View group', 'stream')] = $visit_url;
             $links[__('Delete group', 'stream')] = $delete_url;
         }
     } elseif (in_array($record->context, array('activity'))) {
         $activity_id = wp_stream_get_meta($record, 'id', true);
         $activities = bp_activity_get(array('in' => $activity_id, 'spam' => 'all'));
         if (!empty($activities['activities'])) {
             $activity = reset($activities['activities']);
             $base_url = bp_get_admin_url('admin.php?page=bp-activity&aid=' . $activity->id);
             $spam_nonce = esc_html('_wpnonce=' . wp_create_nonce('spam-activity_' . $activity->id));
             $delete_url = $base_url . "&action=delete&{$spam_nonce}";
             $edit_url = $base_url . '&action=edit';
             $ham_url = $base_url . "&action=ham&{$spam_nonce}";
             $spam_url = $base_url . "&action=spam&{$spam_nonce}";
             if ($activity->is_spam) {
                 $links[__('Ham', 'stream')] = $ham_url;
             } else {
                 $links[__('Edit', 'stream')] = $edit_url;
                 $links[__('Spam', 'stream')] = $spam_url;
             }