GeneralThreat.com » php

Grappling with BP theme compatibility

David — Wed, 28 Aug 2013 18:16:26 +0000

Theme compatibility was introduced in BuddyPress 1.7 and allows site operators to use BP with any available WordPress theme. I have been way behind at updating BP Group Hierarchy to support theme compatibility, and as a result the Group Tree page looks like garbage when not using a theme that was written for BuddyPress. This post is about the effort to fix that.

If you are writing a normal BuddyPress plugin — one that adds pages rather than replacing them — see this excellent article (and this one too) at the BuddyPress Codex for info on how to implement BP theme compatibility.

First idea: Replace the content from `directory_content` with the group tree.

BP_Groups_Theme_Compat::directory_content() is the native BP function that displays the group list page. It’s called as a hook to a filter called bp_replace_the_content, so the content should be available for further filtering after it runs.

 
/**
 * (BP 1.7+) Filter the theme-compatibility content for a group tree page
 */
function bp_group_hierarchy_inject_group_tree() {
        add_filter( 'bp_replace_the_content', 'bp_group_hierarchy_buffer_group_tree', 100 );
}
function bp_group_hierarchy_buffer_group_tree( $content ) {
 
        ob_start();
 
        $loop_template = apply_filters( 'bp_located_template', locate_template( array( "tree/index.php" ), false ), "tree/index.php" );
        load_template( $loop_template );
 
        $output = ob_get_clean();
        return $output;
}
 
// If admin says only show the group tree (and we are in theme compat), do it:
add_action( 'groups_directory_groups_setup', 'bp_group_hierarchy_inject_group_tree' );

Result: No dice. Directory content is echoed to the screen, not returned to the filter chain. The group tree appears below the flat group list.

Workaround / second idea: Unhook the `directory_content` function so it doesn’t echo.

Here’s a snippet that I threw together testing this out (warning: closure => PHP 5.3+ !):

/**
 * (BP 1.7+) Filter the theme-compatibility content for a group tree page
 */
function bp_group_hierarchy_inject_group_tree() {
 
        add_filter( 'bp_replace_the_content', function() {
                /**
                 * Filter is hooked by a method of an anonymous instance...
                 * Search all registered listeners and pick off the BP_Groups_Theme_Compat one.
                 */
 
                global $wp_filter;
 
                foreach( $wp_filter['bp_replace_the_content'][10] as $key => $filter ) {
                        if( is_array( $filter['function'] ) && is_a( $filter['function'][0], 'BP_Groups_Theme_Compat' ) ) {
                                // Found and removing the native content
                                unset( $wp_filter['bp_replace_the_content'][10][$key] );
                        }
                }
 
        }, 1 );
 
        add_filter( 'bp_replace_the_content', 'bp_group_hierarchy_buffer_group_tree', 100 );
}
function bp_group_hierarchy_buffer_group_tree( $content ) {
 
        /* Same as before */
        return $output;
}
 
// If admin says only show the group tree (and we are in theme compat), do it:
add_action( 'groups_directory_groups_setup', 'bp_group_hierarchy_inject_group_tree' );

Result: Works well but is pretty awkward and brittle. It looks like the kind of solution I’d really like to avoid.

Let’s try something completely different.

Third idea: Use BP Theme Compat functions to replace the loop template file.

BuddyPress theme compatibility adds a lot of flexibility in how content is gathered for the site. I actually find the theme compatibility process much more intuitive to work with than the traditional template loading process.

Here are some highlights:

bp_register_template_stack() lets you add a source of template files without filtering bp_located_template. Nice!
bp_get_template_part() offers an easy way to switch out template files on the fly that is just not possible with load_template.

Is it really this easy?

SPOILER ALERT: This does not work for BP Group Hierarchy. But for most applications, I think this is the best way to conditionally replace a BP page with content from a plugin.

 
/**
 * (BP 1.7+) Add plugin templates folder to list of available template paths
 */
function bp_group_hierarchy_register_template_location() {
	return dirname( __FILE__ ) . '/templates/';
}
 
/**
 * (BP 1.7+) Replace groups/groups-loop with tree/tree-loop depending on user settings
 */
function bp_group_hierarchy_maybe_replace_group_loop_template( $templates, $slug, $name ) {
 
	if( 'groups/groups-loop' != $slug )
		return $templates;
 
	return array( 'tree/tree-loop.php' );
}
 
if( function_exists( 'bp_register_template_stack' ) )
	bp_register_template_stack( 'bp_group_hierarchy_register_template_location' );
 
// If admin says only show the group tree (and we are in theme compat), do it:
add_filter( 'bp_get_template_part', 'bp_group_hierarchy_maybe_replace_group_loop_template', 10, 3 );

Result: Works(!)
But when you trigger an AJAX request, the unaltered ID on the “All Groups” tab leads BP to load the flat list.
We also still need to hook the bp_located_template filter to find stylesheets, since we are enqueue-ing them instead of loading the contents inline.
It also also removes the ability to customize the “Group Tree” label, a feature added by popular demand.

Fourth idea: Use BP Theme Compat functions to replace the whole Groups list page.

This is really just a twist on how things are currently handled, and it looks like the current way will be around as long as BP-compatible themes bypass bp_get_template_part.

 
/**
 * (BP 1.7+) Add plugin templates folder to list of available template paths
 */
function bp_group_hierarchy_register_template_location() {
	return dirname( __FILE__ ) . '/templates/';
}
 
/**
 * (BP 1.7+) Replace groups/index with tree/index-compat depending on user settings
 */
function bp_group_hierarchy_maybe_replace_group_index_template( $templates, $slug, $name ) {
 
	if( 'groups/index' != $slug )
		return $templates;
 
	return array( 'tree/index-compat.php' );
}
 
if( function_exists( 'bp_register_template_stack' ) )
	bp_register_template_stack( 'bp_group_hierarchy_register_template_location' );
 
// If admin says only show the group tree (and we are in theme compat), do it:
add_filter( 'bp_get_template_part', 'bp_group_hierarchy_maybe_replace_group_index_template', 10, 3 );

Result: Works seamlessly. It even allows BP to load templates from the stylesheet and template directories before falling back to those included with the plugin.

The only drawback is that it requires a new template file, the group tree version of the bp-templates/bp-legacy/buddypress/groups/index.php file from BP. Which is to say that it adds another layer of template hijinks and possible theme compatibility issues rather than removing an existing one.

Wrap up

I don’t know if this is the strategy that will ultimately make it into the plugin, but it is straightforward and has performed well in early tests. In the meantime, I hope this post will be useful to anyone else trying to do something crazy and ill-advised with BuddyPress.

If you use any of the techniques on this page, please drop me a line in the comments and let me know how they worked for you. And if you have any suggestions on techniques that work even better than these, please send those along too.

Make P2 posts private by default (and control them with tags)

David — Sun, 30 Jun 2013 20:02:24 +0000

The WordPress theme P2 is great for collaboration and team discussion. Sometimes that discussion can be entirely public, and at other times it makes sense to put the entire site behind a login screen. But what if you want to combine a private discussion stream with public pages? Or mix public posts with private ones? P2 emphasizes quick and easy posting by streamlining the process, but this comes at the expense of options.

This post will show you how to mix and match private and public posts on your P2 blog and will set up a framework for controlling post behavior through tags.

No changes to P2’s files are needed, and this trick will work even with older versions on the theme. This code should be placed in your child theme’s functions.php file or in a plugin of your own. There’s a combined block at the bottom of this post for easy copy and paste.

1. Hook P2’s post save mechanism

While P2 exposes limited posting options, authors using the back-end dashboard have access to the full publishing UI. So we want to make sure to target only posts made from the front-end to avoid confusion for authors using full UI.

Loading our handlers this way allows us to ensure that only P2 posts are affected by these magic tags.

/**
 * Use this action to catch requests to P2 AJAX functions
 */
function gtp2_add_hooks() {
	add_filter( 'wp_insert_post_data', 'gtp2_maybe_make_post_private', 10, 2 );
	add_action( 'pre_get_posts', 'gtp2_include_private_posts' );
}
add_action('p2_ajax', 'gtp2_add_hooks' );

2. Check for magic tags when saving

Having hooked the action above, we know that the function below will only run on P2 posts. First, the list of tags is split into an array so we can look for them more easily. Then, we search for any tags we have decided will control post behavior, and change the post accordingly.

Check out lines 21-24 — this is where the magic happens. We check whether the post is tagged public. If it is, we leave it alone (P2 posts are public by default). If it isn’t, we change its status to private.

This example only implements a single check, but you can create as many as you want.

/**
 * Change post status to private unless it is tagged "public"
 */
function gtp2_maybe_make_post_private( $data, $postarr ) {
 
	$tags = $postarr['tags_input'];
 
	/**
	 * Tag processing borrowed from wp_set_post_terms()
	 */
	if ( ! is_array( $tags ) ) {
		$comma = _x( ',', 'tag delimiter' );
		if ( ',' !== $comma )
			$tags = str_replace( $comma, ',', $tags );
		$tags = explode( ',', trim( $tags, " \n\t\r\0\x0B," ) );
	}
 
	/**
	 * Look for tags and control what they do here
	 */
	if( ! in_array( 'public', $tags ) ) {
		// Change attributes of the post here
		$data['post_status'] = 'private';
	}
 
	// Make sure to return the data!
	return $data;
 
}

3. Fix the in-page refresh

P2’s fancy in-page refresh only loads public posts. To make our change seamless to users, this needs to be expanded to load private posts too. We’ll need to add one more short function to accomplish this. You may have seen a hint of it in Step 1, but here’s the function itself.

/**
 * Expand query to include all post status values visible to current user
 */
function gtp2_include_private_posts( $obj ) {
	$obj->set( 'post_status', 'any' );
}

That’s it! Users logged in with Editor or Administrator privileges won’t notice a difference, but other users and anonymous visitors will see only their own posts and those tagged public.

Feel free to drop me a line in the comments if you have any questions or find a use for this on your own sites!

The whole thing

/**
 * Make all P2 posts Private unless they are tagged "public"
 */
 
/**
 * Use this action to catch requests to P2 AJAX functions
 */
function gtp2_add_hooks() {
	add_filter( 'wp_insert_post_data', 'gtp2_maybe_make_post_private', 10, 2 );
	add_action( 'pre_get_posts', 'gtp2_include_private_posts' );
}
add_action('p2_ajax', 'gtp2_add_hooks' );
 
/**
 * Change post status to private unless it is tagged "public"
 */
function gtp2_maybe_make_post_private( $data, $postarr ) {
 
	$tags = $postarr['tags_input'];
 
	/**
	 * Tag processing borrowed from wp_set_post_terms()
	 */
	if ( ! is_array( $tags ) ) {
		$comma = _x( ',', 'tag delimiter' );
		if ( ',' !== $comma )
			$tags = str_replace( $comma, ',', $tags );
		$tags = explode( ',', trim( $tags, " \n\t\r\0\x0B," ) );
	}
 
	/**
	 * Look for tags and control what they do here
	 */
	if( ! in_array( 'public', $tags ) ) {
		// Change attributes of the post here
		$data['post_status'] = 'private';
	}
 
	// Make sure to return the data!
	return $data;
 
}
 
/**
 * Expand query to include all post status values visible to the current user
 */
function gtp2_include_private_posts( $obj ) {
	$obj->set( 'post_status', 'any' );
}

Creating a (relatively) secure dynamic PHP test environment with nginx

David — Fri, 30 Nov 2012 02:51:54 +0000

I’ve been working on a deployment tool for WordPress development environments; one that can quickly provision and maintain the dizzying array of sites needed to test plugins against different versions of WordPress (with and w/o Multisite), BuddyPress, bbPress, etc.

Some cocktail napkin math suggested at least 20 combinations were needed to cover all the currently-supported configurations. Besides the chore of setting up environments for each, the need to add or remove environments as components are updated makes a manual deployment effort seem ridiculous.

While I’m finishing up work on that tool, I thought I’d start by posting the web server and PHP configs I’m using to make this happen.

nginx Configuration

I went with nginx because of its low memory usage and its handy regular-expression hostname matching, which I find more flexible and less kludgey for this application than mod_vhost_alias or mod_rewrite. This nginx config will provide the flexibility of dynamically-creating sites while still providing some isolation between them.

server {
        server_name ~^(.*)\.dev.your.domain$ ;
 
        set $instance $1;
        set $session_root /var/www/dev/$instance/sessions;
 
        root /var/www/dev/$instance/html;
        index index.php;
 
        location ~ \.php$ {
 
                try_files $uri =404;
                fastcgi_split_path_info ^(.+\.php)(/.+)$;
 
                fastcgi_pass unix:/var/run/fpm-devsites.sock;
#               fastcgi_pass 127.0.0.1:9000
                fastcgi_param PATH_INFO $fastcgi_path_info;
                fastcgi_param SCRIPT_FILENAME  $document_root$fastcgi_script_name;
                fastcgi_param PHP_ADMIN_VALUE  "open_basedir=$document_root\nsession.save_path=$session_root";
                include /etc/nginx/fastcgi_params;
 
        }
 
        location / {
                try_files $uri $uri/ /index.php;
        }
}

Thanks to mike at http://michaelshadle.com/2011/02/11/setting-php-ini-parameters-from-nginx for the great guide to the PHP_ADMIN_VALUE param.

PHP-FPM Configuration

Ideally each site would have its own FPM pool, but that would mean root privileges were needed to provision new sites. So a single but separate pool for the dev environments was a necessary compromise. The goal of dynamically creating sites through an unprivileged web interface also meant that the devsites pool needed to run as the web user.

; Start a new pool named 'www'.
; the variable $pool can we used in any directive and will be replaced by the
; pool name ('www' here)
[devsites]
 
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;       will be used.
user = www-data
group = www-data
 
; The address on which to accept FastCGI requests.
; Valid syntaxes are:
;   'ip.add.re.ss:port'    - to listen on a TCP socket to a specific address on
;                            a specific port;
;   'port'                 - to listen on a TCP socket to all addresses on a
;                            specific port;
;   '/path/to/unix/socket' - to listen on a unix socket.
; Note: This value is mandatory.
listen = /var/run/fpm-$pool.sock
 
; Set permissions for unix socket, if one is used. In Linux, read/write
; permissions must be set in order to allow connections from a web server. Many
; BSD-derived systems allow connections regardless of permissions.
; Default Values: user and group are set as the running user
;                 mode is set to 0666
listen.owner = www-data
listen.group = www-data
listen.mode = 0666

If you’ve found this helpful (or troublesome), feel free to drop me a line in the comments below!

Extending BuddyPress Group Hierarchy – Adding Breadcrumbs to Your Theme

David — Wed, 04 Apr 2012 17:49:34 +0000

Once you’ve created a hierarchy of BuddyPress groups, you can help your users navigate and give your site the professional touch by including group breadcrumbs where appropriate. Here’s how!

Step One: Change the link at the top of every group page to a trail of links to parent groups

This is the easy part! BuddyPress Group Hierarchy includes a function, bp_group_hierarchy_breadcrumbs(), that will generate a string of links to a group and all its parents. Use it in the Groups loop, and no parameter is required.

Note: If you need to pass in a different group for some reason, you’ll need to use bp_group_hierarchy_get_breadcrumbs( $separator = '|', $group = false ) function and echo the result yourself. This tutorial won’t address using that more advanced function.

Just locate your theme’s groups/single/group-header.php file, and find the current group header which will look something like this:

 bp_group_permalink(); ?>" title=" bp_group_name(); ?>"> bp_group_name(); ?>

Replace it with this simple line:

 bp_group_hierarchy_breadcrumbs() ?>

Step Two: Change the page title on group pages to reflect your group structure

Changing the page title is more complicated. BuddyPress builds its page titles with a function hooked to the wp_title filter. This function in turn presents its own filter, and that’s the one we have to hook to put breadcrumbs in the title of our Group page. This makes sure our filtering function runs only when BuddyPress is enabled and on as few pages as necessary.

If you zoned out during that bit, don’t worry! Just place the code below into your theme’s functions.php file.

add_filter( 'bp_modify_page_title', 'my_func_group_breadcrumbs', 10, 4 );
 
function my_func_group_breadcrumbs( $processed_title, $title, $sep, $seplocation  ) {
 
	global $bp;
 
 	if( bp_is_active( 'groups' ) && ! empty( $bp->groups->current_group ) ) {
		$processed_title = substr( $processed_title, strpos( $processed_title, $sep ) );
		$processed_title = bp_group_hierarchy_get_full_name( '|', $bp->groups->current_group ) . ' ' . $processed_title;
 	}
 
	return $processed_title;
}

This function strips the group name from the page title, but re-adds the names of the group and all its ancestors. The bp_group_hierarchy_get_full_name function works like the bp_group_hierarchy_get_breadcrumbs function I mentioned earlier, but it builds a plain text list instead of a list of links.

That’s it! Check back soon for a reference child theme, implementing this technique. As always, if you have any questions or problems adding this to your site, or if you have a novel implementation you’d like to share, please post in the comments below!

Update: As promised, here is the sample child theme! BuddyPress Group Hierarchy Breadcrumbs - Sample Theme

Adding Externally-Authenticated Users to BuddyPress

David — Wed, 29 Feb 2012 01:49:26 +0000

BuddyPress does a great job integrating new users who register through your WordPress site into the community — optionally synchronizing profile information between BP and WP, and creating an activity feed item for new user signups.

But what about users who login against an external authentication provider, and whose accounts are created and managed by such a system? Today we’re going to look at how to bring those users into the community in the same way as those who registered locally. Be warned — this is a fairly dense piece, especially if you haven’t worked with an authenticate filter before.

A crash course on `authenticate`

If you are using (or writing) an external authentication plugin, you’ll need a function hooked to the authenticate filter. This function is where your plugin gets a chance to authenticate users against your outside system. It is also where your users will have subordinate WordPress accounts made and managed by the external system.

A very quick example:

function my_func_to_authenticate( $user, $username, $password ) {
 // if $user is a valid WP_User, authenticated by an upstream filter
 // pass these params to the external auth source for verification
 // proceed if user is logged in, otherwise return a WP_Error
}
add_filter( 'authenticate', 'my_func_to_authenticate', 10, 3 );

The first login

The first time your users log in to your WordPress install using their external credentials, you’ll probably want to create a WP account for them. You may skip this if you’re just trying to restrict read access, but this is about BuddyPress, so I’m assuming you want them to post and contribute to the site.

Here’s a rundown of the process:

Suppress the BuddyPress activation email
Create WP user account
Update user meta and, optionally, xprofile data
Activate user and set proper display_name
Publish activity stream message about new user, with properly-formatted display name

Suppress the BuddyPress activation email

These users are already verified by virtue of being in our external auth system, so an activation email would just be confusing.

/** Suppress activation key email for users logging in with external auth */
add_filter( 'bp_core_signup_send_activation_key', create_function('','return false;') );

Create WordPress user account

Normally, you’d use wp_create_user (or wp_insert_user if you want access to the full set of user properties).
But BuddyPress comes with a wrapper function that can be used to do a lot of the heavy lifting for us.

$new_user = bp_core_signup_user(
	$user_login,
	$user_password,
	$user_email,
	array()
);
 
if( is_wp_error( $new_user ) ) {
	return $new_user;
}

Update user meta and, optionally, xprofile data

There are actually a few ways to handle this, ranging from bull-in-a-china-shop overwriting to graceful but more complicated filtering. Which one you choose may depend on your comfort with WP or PHP, which BuddyPress features you have enabled, or the structure of your authentication script.

Easiest

Easiest

$display_name = $first_name . ' ' . $last_name;
 
update_user_meta( $new_user, 'nickname',   $display_name  );
update_user_meta( $new_user, 'first_name', $first_name );
update_user_meta( $new_user, 'last_name',  $last_name  );
 
if( bp_is_active( 'xprofile' ) )
	xprofile_set_field_data( bp_xprofile_fullname_field_name(), $new_user, $display_name );
 
// Even though setting the xprofile value, above, should take care of this, 
// testing revealed that we needed to prime the cache with the right value
wp_cache_set( 'bp_user_fullname_' . $new_user, $display_name, 'bp' );

PROS:

Very straightforward and procedural — no objects or data sharing needed
Complete control over format of display_name and BP fullname field
Control over any other BP xprofile values you want to set
Does not require xprofile or WP-BP profile sync in order to operate

CONS:

Will ultimately drift out of sync with BP development
Still need to set the display_name property below
Might as well use wp_insert_user, since we’re manually adding so much

Shortest

Shortest

Replace the bp_core_signup_user call above with this:

$new_user = bp_core_signup_user(
	$login_name,
	$password,
	$email,
	array(
		'profile_field_ids' => bp_xprofile_fullname_field_name(),
		"field_{bp_xprofile_fullname_field_name()}" => $display_name
	)
);

PROS:

Uses BP to eliminate the need for additional filters or processing
Least code redundancy of all
Can supply additional xprofile fields to be added to the new user
Most natural method in terms of program flow

CONS:

Complex meta parameter structure can be difficult to read
Parameter or data structure may change in future BP releases
Requires xprofile and WP-BP profile sync to update WP display_name and usermeta

Fanciest

Fanciest

function my_display_name_filter( $user_id, $user_login, $user_password, $user_email, $usermeta ) {
	// must get $display_name from another part of the authentication process
	if ( bp_is_active( 'xprofile' ) ) {
		xprofile_set_field_data( bp_xprofile_fullname_field_name(), $new_user, $display_name );
	}
}

Change your authenticate function to look like this:

function my_func_to_authenticate( $user, $username, $password ) {
 
	// ... authenticate user
	add_action( 'bp_core_signup_user', 'my_display_name_filter', 9, 5 );
	$new_user = bp_core_signup_user(
		$login_name,
		$password,
		$email,
		array()
	);
}

PROS:

Uses BP filters for forward compatibility
Reduces the amount of repeated code

CONS:

Requires an object or data-sharing infrastructure to get user details to the filter
Requires xprofile and WP-BP profile sync to update WP display_name and usermeta

Now that the xprofile and usermeta data are set up, it’s time to activate the user! This is done by simply setting the user_status column to 0.

Activate user (and set proper display_name, if needed)

Update 08-06-2012: I used to recommend wp_update_user for this, but that has proven unreliable on a recent project. So to be safe, just use a direct query.

// activate user and set display name appropriately
$wpdb->query( $wpdb->prepare( "UPDATE $wpdb->users SET display_name=%s, user_status=0 WHERE ID=%d", $display_name, $new_user ) );

And if you set $display_name above, use the shortened version:

// activate user
$wpdb->query( $wpdb->prepare( "UPDATE $wpdb->users SET user_status=0 WHERE ID=%d", $new_user ) );

Publish an activity stream message about the new user and notify the site admin

Since the display_name property and associated xprofile field are finally set the way we want them, it’s time to trigger the activity stream message and administrator notification.

bp_core_new_user_activity( $new_user );
wp_new_user_notification( $new_user );

And you’re done!

Return a WP_User object to let other authentication filters know you’ve handled this user.

return new WP_User( $new_user );

A complete example

function my_func_to_authenticate( $user, $username, $password ) {
	// if $user is a valid WP_User, authenticated by an upstream filter
	if( is_a( $user, 'WP_User' ) ) return $user;
 
	// pass these params to the external auth source for verification
	// proceed if user is logged in, otherwise return a WP_Error
	if( $user_details = my_external_auth( $username, $password ) ) {
 
		// for simplicity's sake, I'm assuming that $user_details is an array with all the right keys
		// in practice, more checks would be required
		extract( $user_details );
 
		// this function returns the new user account ID if successful
		$new_user = bp_core_signup_user(
			$username,
			$password,
			$user_email,
			array()
		);
 
		// If signup returned an error, skip the rest
		if( is_wp_error( $new_user ) ) {
			return $new_user;
		}
 
		$display_name = $first_name . ' ' . $last_name;
 
		update_user_meta( $new_user, 'nickname',   $display_name  );
		update_user_meta( $new_user, 'first_name', $first_name );
		update_user_meta( $new_user, 'last_name',  $last_name  );
 
		if( bp_is_active( 'xprofile' ) )
			xprofile_set_field_data( bp_xprofile_fullname_field_name(), $new_user, $display_name );
 
		// Even though setting the xprofile value, above, should take care of this, 
		// testing revealed that we needed to prime the cache with the right value
		wp_cache_set( 'bp_user_fullname_' . $new_user, $display_name, 'bp' );
 
		// activate user and set display name appropriately
		$wpdb->query( $wpdb->prepare( "UPDATE $wpdb->users SET display_name=%s, user_status=0 WHERE ID=%d", $display_name, $new_user ) );
 
		bp_core_new_user_activity( $new_user );
		wp_new_user_notification( $new_user );
 
		return new WP_User( $new_user );
	}
	// you can return FALSE, or a WP_Error if you have something specific to say
	return new WP_Error( 'login_failed', __( 'Could not authenticate user' ) );
}
add_filter( 'authenticate', 'my_func_to_authenticate', 10, 3 );

If you have questions, or if you put this to use in your next project, feel free to drop me a line in the comments!

Extending BuddyPress Group Hierarchy – Creating a Member Groups list

David — Sun, 29 Jan 2012 19:44:39 +0000

In this post, I’m going to show you how to create a Member Groups page/list/widget, with a little background on how Group Hierarchy extends the BuddyPress Groups loop.

BuddyPress Groups loop overview

If you aren’t familiar with bp_has_groups() from looking at the BuddyPress theme files, you should take a look at this overview from the BP Codex before continuing.

In a nutshell, bp_has_groups() accepts a series of parameters which it uses to populate the global $groups_template variable with a set of groups. This, in turn, allows all the cool template functions to work without parameters cluttering up your theme file.

How Group Hierarchy changes the Loop

BuddyPress Group Hierarchy changes this in two important ways:

bp_has_groups() creates a set of BP_Groups_Hierarchy objects instead of BP_Groups_Group objects
bp_has_groups_hierarchy() extends the loop with a parent_id parameter for getting only child groups of the passed group ID

There are more changes made just for the Group Tree, but that’s enough to get us started. Onward!

Creating a Member Groups list

Before we build our Member Groups page / widget / list, there’s something you should know about working “in the loop,” i.e. in the context of the current group. The only thing telling BuddyPress what group we’re looking at is the $groups_template variable introduced above. Our member group list is going to change that variable, so we need to save its current state and restore it when we’re done.

// If you're in a function, bring $groups_template into scope
global $groups_template;
 
// Save the current group context for later
$current_group_template = $groups_template;

Using the Codex article I posted at the top as a reference, you’ll see how easy it is to create a Member Groups page / widget / whatever.

Just replace:

 if ( bp_has_groups() ) : ?>

with:

 if ( bp_has_groups_hierarchy( array( 
	'type'      => 'alphabetical',
	'parent_id' => bp_get_current_group_id() 
) ) ) : ?>

…and the rest works as is! Since 1.3.0, pagination is handled automatically.

Don’t forget to restore the original context!

$groups_template = $current_group_template;

A complete example

Here’s a quick example that adds a list of Member Groups on the Members page, above the list of users. Drop this in your functions.php file, or in a custom plugin, but note that it will only display if the parent group has at least one member!


add_action( 'bp_before_group_members_content', 'my_func_list_member_groups' );
 
function my_func_list_member_groups() {
	// If you're in a function, bring $groups_template into scope
	global $groups_template;
 
	// Save the current group context for later
	$current_group_template = $groups_template;
 
	if ( bp_has_groups_hierarchy( array( 
		'type'      => 'alphabetical',
		'parent_id' => bp_get_current_group_id(),
	) ) ) : ?>
 
	 _e( 'Member Groups' ); ?>
 
 
	
 
		
			 bp_groups_pagination_count() ?>
		
 
		
			 bp_groups_pagination_links() ?>
		
 
	
 
	
	 while ( bp_groups() ) : bp_the_group(); ?>
 
		
			
				 bp_group_permalink() ?>"> bp_group_avatar( 'type=thumb&width=50&height=50' ) ?>
			
 
			
				 bp_group_permalink() ?>"> bp_group_name() ?>
				 printf( __( 'active %s ago', 'buddypress' ), bp_get_group_last_active() ) ?>
 
				 bp_group_description_excerpt() ?>
 
				 do_action( 'bp_directory_groups_item' ) ?>
				
 
			
				 bp_group_join_button() ?>
 
				
					 bp_group_type() ?> /  bp_group_member_count() ?>
				
 
				 do_action( 'bp_directory_groups_actions' ) ?>
			
 
			
		
 
	 endwhile; ?>
	
 
		 do_action( 'bp_after_member_groups_loop' ) ?>
 
	 else: ?>
 
		
		 _e( 'There were no member groups found.' ) ?>
		
 
	 endif;
 
	// restore original group context!
	$groups_template = $current_group_template;
}

That’s it! Drop me a line in the comments if you find a novel use for this technique.

Highlighting Features with WordPress Admin Pointers – A Quick Guide for Plugin Authors

David — Mon, 02 Jan 2012 05:24:12 +0000

Here’s a quick intro to admin pointers for plugins to WordPress 3.3+, based on some work I recently put into making the help system in Networks more intuitive:

Step One — Add the admin pointer style and script to your page

This is a fairly standard chain of admin_menu action functions, which should look familiar if you’re using a class for your plugin. If they don’t, some light background reading may be in order.

You’ll need to create a script file for your admin page to follow this guide, although you could also dump the required JavaScript into the admin page itself.

 
function admin_menu()
{
	$this->admin_page = add_menu_page( __('My Page'), __('My Page'), 'manage_options', 'my-page', FUNCTION );
 
	wp_register_script( 'my_admin_js', plugins_url(SCRIPT FILE, __FILE__), array('jquery') );
 
	add_action( 'admin_print_scripts-' . $this->admin_page, array( &$this, 'add_admin_scripts' ) );
	add_action( 'admin_print_styles-' . $this->admin_page, array( &$this, 'add_admin_styles' ) );
}
 
function add_admin_styles() {
	wp_enqueue_style( 'wp-pointer' );
}
 
function add_admin_scripts() {
	wp_enqueue_script( 'wp-pointer', false, array('jquery') );
	wp_enqueue_script( 'my_admin_js', false, array('jquery') );
	wp_localize_script( 'my_admin_js', 'strings', $this->localize_admin_js() );
}

In addition to enqueueing the admin pointer CSS and script files, we’ve set up a localization function. Beside being good coding practice, generating the strings for the admin pointer here, instead of in the script file, is going to allow us to use a nice shortcut.

Step Two — Build the pointer text and check for dismissal

function localize_admin_js() {
 
	$pointer_text = '' . esc_js( __( 'My Pointer Header') ) . '
';
	$pointer_text .= '' . esc_js( __( 'This is the text of my pointer.' ) ). '
';
 
	// Get the list of dismissed pointers for the user
	$dismissed = explode( ',', (string) get_user_meta( get_current_user_id(), 'dismissed_wp_pointers', true ) );
 
	// Check whether our pointer has been dismissed
	if ( in_array( POINTER HANDLE, $dismissed ) ) {
		$pointer_text = '';
	}
 
	return array(
		'pointerText' => $pointer_text
	);
}

In testing, setting the pointer text to '' was sufficient to hide the pointer from the screen. However, we can add another layer of protection in the script, which you’ll see below.

Step Three – Script the pointer object gracefully

If you don’t already have an admin script file, you’ll need to create one for this step.

jQuery(document).ready( function() {
 
	/** Check that pointer support exists AND that text is not empty */
	if(typeof(jQuery().pointer) != 'undefined' && strings.pointerText != '') {
		jQuery('#OBJECT_YOU_WANT_TO_POINT_AT').pointer({
			content    : strings.pointerText,
			close  : function() {
				jQuery.post( ajaxurl, {
					pointer: POINTER HANDLE,
					action: 'dismiss-wp-pointer'
				});
			}
		}).pointer('open');
	}
});

Note the close property of the pointer object: calling this action hooks us right into WordPress’s pointer management, so that when the user clicks the Dismiss button, our pointer is added to his list of dismissed pointers. The wp-pointer stylesheet takes care of making the pointer look right so long as there’s an

and one or more paragraphs, and the close button is added and wired up automatically.

Hope this helps anyone wishing to use this neat, new feature!

Extending BuddyPress Group Hierarchy – Join to Upstream Groups

David — Wed, 07 Dec 2011 18:23:16 +0000

Introduction

A frequent feature request for BuddyPress Group Hierarchy has been to automatically join members of a subgroup to its parent groups. While pretty straightforward to implement, there are two main reasons this feature won’t make it into the plugin:

This behavior isn’t appropriate for many or even most setups
Everyone who has requested it has wanted it to work on groups by different criteria — some want groups of a certain depth, others a specific set of groups, others all the children of a certain group. Building a UI that would let this work the way anyone wants would overwhelm the project.

Instead, I decided to post this sample implementation, including a few ways to select groups. Take a look!

The Code

The code below can be included in your theme’s functions.php file, or can be part of a new plugin.

Note for the true novice: you must choose one of the if statements in the block below with this code and substitute the placeholders for things you care about. It will not work pasted as is.

/* groups_join_group is called whenever someone joins a group in both BP 1.2 and 1.5.x */
add_action('groups_join_group', 'my_join_group_action', 10, 2);
 
function my_join_group_action( $group_id, $user_id ) {
 
	/* This part is critical - you must select ONLY the groups you want to START this chain
	 * This function will recurse up to the toplevel on its own, so if you have a parent group
	 * in the list, you will waste resources trying to join the same group multiple times
	 * as this function is called on each step up the tree
	 */ 
	/** Pick from a list of groups */
	if( in_array( $group_id, ARRAY_OF_GROUPS_I_CARE_ABOUT ) ) {
	/* -- OR -- */
	/** Select groups by depth */
	if( count( bp_group_hierarchy_get_parents() ) == DEPTH_OF_GROUP_I_CARE_ABOUT_EG_3 ) {
	/* -- OR ANYTHING ELSE YOU LIKE */
 
		/* However you choose to select groups, once the group_id matched this part will 
		 * walk up the tree, joining the user to each parent group along the way
		 */
 
		$parents = bp_group_hierarchy_get_parents();
		foreach( $parents as $parent_group_id ) {
			groups_join_group( $parent_group_id, $user_id );
		}
	}
}

If this helps you, or if you have some code to select the groups that matter to YOU, feel free to post in the comments below!

WordPress Plugin Help Panels with WP_Screen – Features and Limits

David — Fri, 25 Nov 2011 21:31:40 +0000

With version 3.3 (currently at beta 4), WordPress has introduced the WP_Screen API for adding rich help screens to your plugin’s admin page(s). This is still a very new API so, even though some options functions exist, you won’t be making crazy customizations or replacing meta boxes just yet.

Update: version 3.3 is current at RC 2 and, while there have been many internal improvements, the API still works as described below.

Creating an admin page and WP_Screen instance

Creating an admin page for your plugin hasn’t changed, but it’s more important than ever to save the handle of your admin page.

 
	/**
	 * Save the handle to your admin page - you'll need it to create a WP_Screen object
	 */
	$this->admin_page = add_options_page( 
		__('WP_Screen Test','my-plugin'), 
		__('WP_Screen Test','my-plugin'), 
		'manage_options', 
		'wp_screen_test', 
		array(&$this, 'test_page') 
	);
 
	/** Use this hook to catch your admin page's loading */
	add_action("load-{$this->admin_page}",array(&$this,'create_help_screen'));
 
public function create_help_screen() {
 
	/** 
	 * Create the WP_Screen object against your admin page handle
	 * This ensures we're working with the right admin page
	 */
	$this->admin_screen = WP_Screen::get($this->admin_page);

Working with WP_Screen – Tabs and the Sidebar

The main feature of the new Help tab system is the ability to divide your help menu into separate sections without a lot of effort.

For each help tab you want to create, call the add_help_tab method to build it. You can specify the content of the help tab inline, or use a callback to generate it.

 
	/**
	 * Inline tab content
	 */
	$this->admin_screen->add_help_tab(
		array(
			'title'    => 'Help',
			'id'       => 'help_tab',
			'content'  => 'This is my content.
',
			'callback' => false
		)
	);
 
	/**
	 * Content generated by callback
	 * The callback fires when tab is rendered - args: WP_Screen object, current tab
	 */
	$this->admin_screen->add_help_tab(
		array(
			'title'    => 'Info on this Page',
			'id'       => 'page_info',
			'content'  => '',
			'callback' => create_function('','echo "This is my generated content.
";')
		)
	);

The sidebar is a much nicer way to display the list of links we’ve often put at the bottom of the help panel. It’s displayed regardless of which tab is selected.

 
	$this->admin_screen->set_help_sidebar(
		'This is my help sidebar content.
'
	);

WP_Screen and Options

WP_Screen excels at handling help pages. Unfortunately, the only options it seems to recognize with the add_option method are the built-in per_page and layout_columns. Anything else simply isn’t displayed.

 
	$this->admin_screen->add_option( 
		'per_page', 
		array(
			'label' => 'Entries per page', 
			'default' => 20, 
			'option' => 'edit_per_page'
		) 
	);
 
	$this->admin_screen->add_option( 
		'layout_columns', 
		array(
			'default' => 3, 
			'max' => 5
		) 
	);
 
	/**
	 * This option will NOT show up
	 */
	$this->admin_screen->add_option( 
		'invisible_option', 
		array(
			'label'	=> 'I am a custom option',
			'default' => 'wow', 
			'max' => 5
		) 
	);

But you can use a metabox to at least get a custom checkbox generated.

 
	/**
	 * Old-style metaboxes still work for creating custom checkboxes in the option panel
	 * This is a little hack-y, but it works
	 */
	add_meta_box(
		'my_meta_id',
		'My Metabox',
		array(&$this,'create_my_metabox'),
		$this->admin_page
	);
}

And here’s the complete skeleton:

 

/*
Plugin Name: WP 3.3 WP_Screen Test
Version: 1.0
*/
 
class wp_screen_test {
 
	private $slug = 'screentest';
	private $admin_page;
	private $admin_screen;
 
	public function __construct() {
		add_action( 'admin_menu', array(&$this, 'admin_menu') );
	}
 
	public function admin_menu() {
 
		/**
		 * Save the handle to your admin page - you'll need it to create a WP_Screen object
		 */
		$this->admin_page = add_options_page( 
			__('WP_Screen Test','my-plugin'), 
			__('WP_Screen Test','my-plugin'), 
			'manage_options', 
			$this->slug, 
			array(&$this, 'test_page') 
		);
 
		add_action("load-{$this->admin_page}",array(&$this,'create_help_screen'));
	}
 
 
	public function create_help_screen() {
 
		/** 
		 * Create the WP_Screen object against your admin page handle
		 * This ensures we're working with the right admin page
		 */
		$this->admin_screen = WP_Screen::get($this->admin_page);
 
		/**
		 * Content specified inline
		 */
		$this->admin_screen->add_help_tab(
			array(
				'title'    => 'Help',
				'id'       => 'help_tab',
				'content'  => 'This is my content.
',
				'callback' => false
			)
		);
 
		/**
		 * Content generated by callback
		 * The callback fires when tab is rendered - args: WP_Screen object, current tab
		 */
		$this->admin_screen->add_help_tab(
			array(
				'title'    => 'Info on this Page',
				'id'       => 'page_info',
				'content'  => '',
				'callback' => create_function('','echo "This is my generated content.
";')
			)
		);
 
		$this->admin_screen->set_help_sidebar(
			'This is my help sidebar content.
'
		);
 
		$this->admin_screen->add_option( 
			'per_page', 
			array(
				'label' => 'Entries per page', 
				'default' => 20, 
				'option' => 'edit_per_page'
			) 
		);
 
		$this->admin_screen->add_option( 
			'layout_columns', 
			array(
				'default' => 3, 
				'max' => 5
			) 
		);
 
		/**
		 * This option will NOT show up
		 */
		$this->admin_screen->add_option( 
			'invisible_option', 
			array(
				'label'	=> 'I am a custom option',
				'default' => 'wow', 
				'option' => 'my_option_id'
			) 
		);
 
		/**
		 * But old-style metaboxes still work for creating custom checkboxes in the option panel
		 * This is a little hack-y, but it works
		 */
		add_meta_box(
			'my_meta_id',
			'My Metabox',
			array(&$this,'create_my_metabox'),
			$this->admin_page
		);
	}
 
	public function test_page() {
		// Plugin options page content
	}
 
}
 
function screen_test_init() {
	$screenTest = new wp_screen_test();
}
 
add_action( 'init', 'screen_test_init' );

Pull Parsing ARIN WHOIS Data in PHP

David — Fri, 04 Nov 2011 02:56:47 +0000

At JerseyConnect, we’ve been using the Bulk WHOIS Data from ARIN for a few years now, mostly as a diagnostic tool for libraries concerned about their bandwidth usage, but also for capacity planning and judging peering options. After years of using the flat text format dumps, this week I decided to take the plunge and change to the much larger — but much better structured — XML formatted files. Here’s how I did it.

TL;DR? Skip to the solution!

The Old Way – The Flat Text Dump

ARIN bulk WHOIS data was originally available only as a flat text dump from their database. This format made it easy to convert into individual records into a data structure, as it came in a pseudo-tab delimited format. But it lacked any structure, and you had to convert each record and inspect its properties to determine its type. This slowed down processing significantly.

I had written a parser for the flat text dump format when we first started using the data and it worked well enough that we’ve stuck with it. However, not every record in the flat text file has every key, and some fields are used differently between records, so it had to be built with a maze of filters and regular expressions and ended up an unmanageable mess with sections like this:

/** create or re-create any missing fields */
 
/** sometimes street address is its own field, but sometimes not */
if(!array_key_exists('Street',$record)) {
	if(array_key_exists('City',$record)) {
		if(preg_match('/(.*?)[\s]{2,}(.*?)/',$record['City'])) {
			/** if there is a clear break, use it to delineate city from street */
			$addr = preg_split('/[\s]{2,}/',$record['City']);
			$record['Street'] = $addr[0];
			$record['City'] = $addr[1];
		} else {
			/** 
			 * if we can't tell just grab everything but the last word
			 * This misses cases like "Los Angeles" and "Palm Beach" but it will have to do
			 */
			$record['Street'] = substr($record['City'],0,strrpos($record['City'],' '));
			$record['City'] = substr($record['City'],strrpos($record['City'],' '));
		}
	} else {
		/** if there is no data, just put in blanks */
		$record['Street'] = '';
		$record['City'] = '';
	}
}
 
if(!array_key_exists('Company',$record) && strpos($record['Street'],"\n") !== FALSE) {
	$record['Company'] = substr($record['Street'],0,strpos($record['Street'],"\n"));
	$record['Street'] = substr($record['Street'],strpos($record['Street'],"\n")+1);
}
if(!array_key_exists('FirstName',$record)) {
	if(array_key_exists('LastName',$record)) {
 
		if(strpos($record['LastName'],',') !== FALSE) {
			$name = explode(',',$record['LastName']);
			$record['LastName'] = trim($name[0]);
			$record['FirstName'] = trim($name[1]);
		} else {
			$record['FirstName'] = '';
		}
	}
}

The New Way – XML Format

In XML, the bulk WHOIS data is huge — at over 3 GB and growing by over 25 MB per month, it is about 3x the size of the flat file — but is far more consistent in terms of structure. This makes writing the parser MUCH more straightforward. The biggest problem is the sheer size, and for that we have XMLReader.

Parsing a Large XML File

Since the file is so large, we need to read it piece by piece. Fortunately, XMLReader makes this simple. No more chunking with fread() or fget* variants! While this post is about parsing ARIN data, not general XML, here’s an example of how easy it is to get started with XMLReader:

$xmlHandle = new XMLReader();
$xmlStatus = $xmlHandle->open( 'any_xml_file.xml' );
while($xmlHandle->read()) {
	/** any processing on current node */
	echo $xmlHandle->nodeValue;
}
if($xmlStatus) $xmlHandle->close();

The modest code above will scan an XML file of any size without running out of memory. Of course, depending on how deeply nested your data is, it may take a VERY long time.

For more information on XML processing with PHP, see this excellent IBM series, “XML for PHP developers” (part 1) (part 2).

Parsing the ARIN WHOIS XML File

Our parser needs to be tailored to the ARIN WHOIS data. We want it to locate the four types of record (ASN, NET, ORG, and POC) that may be in the file we’re scanning and hand them off to subordinate functions as efficiently as possible.

Here’s the finished skeleton parser:

ARIN XML Parser – Skeleton

/**
 * ARIN Bulk XML Data Parser class
 */
class Parse_ARIN {
 
	var $xmlStatus = false;
	var $xmlHandle;
	var $count;
	var $startTime = null;
 
	/**
	 * @param string XMLFile File containing bulk whois data in XML format
	 */
	function __construct( $xmlFile = null ) {
		$this->xmlHandle = new XMLReader();
		if(ob_get_level() == 0) ob_start();
		if(empty($xmlFile)) {
			return true;
		} else if(!is_file($xmlFile)) {
			return false;
		}
		$this->count = 0;
 
		$this->xmlStatus = $this->xmlHandle->open( $xmlFile );
		return $this->xmlStatus;
	}
 
	function __destruct() {
		if($this->xmlStatus) $this->xmlHandle->close();
 
		/** Report time taken */
		$endTime = microtime(true);
		echo 'Processed ' . $this->count . ' records in: ' . ($endTime - $this->startTime) . ' seconds.';
	}
 
	public function setSource( $xmlFile ) {
		if(is_file($xmlFile)) {
			$this->xmlStatus = $this->xmlHandle->open( $xmlFile );
			return $this->xmlStatus;
		}
		return false;
	}
 
	public function process() {
		if(!$this->xmlStatus) {
			return false;
		}
		$this->startTime = microtime(true);
		$this->scan();
	}
 
	/**
	 * Echo progress to the browser and continue execution
	 * @param string Message Message to be echoed
	 */
	public function report( $message ) {
		echo str_pad($message . '
', 4096) . "\n";
		ob_flush();
		flush();
	}
 
	protected function scan() {
		while($this->xmlHandle->read()) {
			if(in_array( $this->xmlHandle->name, array('asn','net','poc','org') ) && $this->xmlHandle->nodeType == XMLREADER::ELEMENT) {
				switch($this->xmlHandle->name) {
					case 'asn':
						$this->saveASNRecord( $this->xmlHandle->expand() );
						break;
					case 'net':
						$this->saveNETRecord( $this->xmlHandle->expand() );
						break;
					case 'org':
						$this->saveORGRecord( $this->xmlHandle->expand() );
						break;
					case 'poc':
						$this->savePOCRecord( $this->xmlHandle->expand() );
						break;
				}
				$this->count++;
				if($this->count % 10000 == 0) {
					$this->report('Processed: ' . $this->count . ' records.');
				}
				$this->xmlHandle->next();
			}
		}
	}
 
	/**
	 * Convert the DOMNode into a SimpleXML object for manipulation
	 * @param DOMNode RecordData XML data from the file being scanned
	 * @return SimpleXMLElement
	 */
	protected function processRecord( $recordData ) {
 
		/** From Listing 9: http://www.ibm.com/developerworks/xml/library/x-xmlphp2/index.html */
		$dom = new DomDocument();
		$n = $dom->importNode($recordData,true);
		$dom->appendChild($n);
		$result = simplexml_import_dom($n);
		return $result;
	}
 
	protected function saveASNRecord( $asnNode ) {
		$record = $this->processRecord( $asnNode );
 
	}
 
	protected function saveNETRecord( $netNode ) {
		$record = $this->processRecord( $netNode );
 
	}
 
	protected function saveORGRecord( $orgNode ) {
		$record = $this->processRecord( $orgNode );
 
	}
 
	protected function savePOCRecord( $pocNode ) {
		$record = $this->processRecord( $pocNode );
 
	}
}

Calling the ARIN Parser

The class we created keeps the surface area as small as possible. We can now use the parser with just a few lines of code.

Calling the ARIN Parser – Sample Code

$ARIN = new Parse_ARIN('arin_db.xml');
 
$ARIN->report('Starting process...');
$ARIN->process();

Processing the XML Data

In order to do something useful with the data, like store it in a database or display it to the screen, you can alter the save{TYPE}Record functions (or extend the parser) to suit your needs. Here’s an example:

protected function savePOCRecord( $pocNode ) {
 
	$record = $this->processRecord( $pocNode );
 
	/**
	 * DB structure:
	 * POCHandle (PK)
	 * IsRole
	 * Company
	 * LastName
	 * FirstName
	 * RoleName
	 * Street
	 * City
	 * State
	 * Country
	 * PostalCode
	 * RegDate
	 * Updated
	 * OfficePhone
	 * Mailbox
	 */
 
	$POCrecord = array(
		'POCHandle'		=> (string)$record->handle,
		'IsRole'		=> (int)($record->isRoleAccount == 'Y'),
		'Company'		=> (string)$record->companyName,
		'LastName'		=> (string)$record->lastName,
		'FirstName'		=> (string)$record->firstName,
		'RoleName'		=> '',
		'Street'		=> '',
		'City'			=> (string)$record->city,
		'State'			=> (string)$record->{'iso3166-2'},
		'Country'		=> (string)$record->{'iso3166-1'}->code2,
		'PostalCode'		=> (string)$record->postalCode,
		'RegDate'		=> (string)$record->registrationDate,
		'Updated'		=> (string)$record->updateDate,
		'OfficePhone'		=> (isset($record->phones->phone) ? (string)$record->phones->phone->number->phoneNumber : ''),
		'Mailbox'		=> (string)$record->emails->email
	);
 
	/** create or re-create any missing fields */
	if(count($record->streetAddress->line) > 1) {
		$streetAddress = get_object_vars($record->streetAddress);
		if(empty($POCrecord['companyName']))
			$POCrecord['Company'] = array_shift($streetAddress['line']);
		$POCrecord['Street'] = join("\n",$streetAddress['line']);
	} else if(count($record->streetAddress->line) == 1) {
		$POCrecord['Street'] = (string)$record->streetAddress->line;
	}
 
	$POC_DB->add($POCrecord);
}

Other Notes – Processing Speed

Finally, this data set is big enough that I thought a quick analysis might be a useful contribution to the age-old if/else vs. switch debate.

Here are the results for iterating over the approx. 4.6 million records in this file without further processing. Tests were run on Win7/PHP 5.3.5:

Method	Min. time (seconds)	Max. time (seconds)
No Test	141.1	141.6
If/Else	149.1	150.2
Switch	147.7	147.7

GeneralThreat.com » php

Grappling with BP theme compatibility

First idea: Replace the content from directory_content with the group tree.

Workaround / second idea: Unhook the directory_content function so it doesn’t echo.

Third idea: Use BP Theme Compat functions to replace the loop template file.

Fourth idea: Use BP Theme Compat functions to replace the whole Groups list page.

Wrap up

Make P2 posts private by default (and control them with tags)

1. Hook P2’s post save mechanism

2. Check for magic tags when saving

3. Fix the in-page refresh

The whole thing

Creating a (relatively) secure dynamic PHP test environment with nginx

nginx Configuration

PHP-FPM Configuration

Extending BuddyPress Group Hierarchy – Adding Breadcrumbs to Your Theme

Step One: Change the link at the top of every group page to a trail of links to parent groups

bp_group_permalink(); ?>" title=" bp_group_name(); ?>"> bp_group_name(); ?>

bp_group_hierarchy_breadcrumbs() ?>

Step Two: Change the page title on group pages to reflect your group structure

Adding Externally-Authenticated Users to BuddyPress

A crash course on authenticate

The first login

Suppress the BuddyPress activation email

Create WordPress user account

Update user meta and, optionally, xprofile data

Easiest

Shortest

Fanciest

Activate user (and set proper display_name, if needed)

Publish an activity stream message about the new user and notify the site admin

And you’re done!

A complete example

Extending BuddyPress Group Hierarchy – Creating a Member Groups list

BuddyPress Groups loop overview

How Group Hierarchy changes the Loop

Creating a Member Groups list

A complete example

_e( 'Member Groups' ); ?>

Highlighting Features with WordPress Admin Pointers – A Quick Guide for Plugin Authors

Step One — Add the admin pointer style and script to your page

Step Two — Build the pointer text and check for dismissal

' . esc_js( __( 'My Pointer Header') ) . '

Step Three – Script the pointer object gracefully

and one or more paragraphs, and the close button is added and wired up automatically. Hope this helps anyone wishing to use this neat, new feature!

Extending BuddyPress Group Hierarchy – Join to Upstream Groups

Introduction

The Code

WordPress Plugin Help Panels with WP_Screen – Features and Limits

Creating an admin page and WP_Screen instance

Working with WP_Screen – Tabs and the Sidebar

WP_Screen and Options

Pull Parsing ARIN WHOIS Data in PHP

TL;DR? Skip to the solution!

The Old Way – The Flat Text Dump

The New Way – XML Format

Parsing a Large XML File

Parsing the ARIN WHOIS XML File

ARIN XML Parser – Skeleton

Calling the ARIN Parser

Calling the ARIN Parser – Sample Code

Processing the XML Data

Other Notes – Processing Speed

First idea: Replace the content from `directory_content` with the group tree.

Workaround / second idea: Unhook the `directory_content` function so it doesn’t echo.

A crash course on `authenticate`

and one or more paragraphs, and the close button is added and wired up automatically.

Hope this helps anyone wishing to use this neat, new feature!