Add User Autocomplete

Site admins on a WordPress Network can add existing network members to their site on the Dashboard > Users > Add New panel. But the interface requires that one know either the email address or the username of the user in question. My new plugin, Add User Autocomplete, makes the Add Existing User workflow a bit easier, by adding autocomplete/autosuggest to the Email Address/Username field. Just start typing, and the plugin will return matching users; arrow down or click on the intended user to add her to the Add User list.

A few additional bonuses provided by the plugin, aside from autocomplete:

• In addition to return email address and username matches, the plugin also checks against the display_name and user_url fields. So if my username is ‘admin’, and my email address is ‘bgorges@boonebgorges.com’, but my display name around the site is ‘Boone Gorges’, you’ll be able to find me by searching on ‘Boone’.
• You can add many users to a blog at once. Search for one user, select and hit Return, and then search for another.
• Prettier success messages. When you submit the Add New User page, your success message will give you a list of the users invited, instead of a generic “Invitations have been sent” type message.

Add User Autocomplete requires WP 3.1 and JavaScript. The plugin was developed for the CUNY Academic Commons. Check out the plugin at wordpress.org or follow its development at Github.

Related posts:

1. New WordPress plugin: Simple Import Users
2. New WordPress plugin: Unconfirmed
3. Using Github with wordpress.org plugin SVN

BuddyPress Docs History

I’ve just released version 1.1 of BuddyPress Docs, my collaborative editing software for BuddyPress.

The big new feature in version 1.1 is the History tab. After upgrading, you’ll notice that what used to be a single Edit button has been reorganized into three tabs: Read, Edit, and History. History allows you to brows the entire revision history of a document, to compare the differences between two revisions side by side, to view a single revision, or to restore to any point in the document’s history. Access to the History tab can be limited in the same way that access to the Edit tab can be, on a doc-by-doc basis.

This new feature will, I hope, bring some of the best qualities of wikis to BuddyPress Docs, and make Docs an even better way to collaborate.

Download BuddyPress Docs from the wordpress.org plugin repo or follow development at Github.

Related posts:

1. New BuddyPress plugin: BuddyPress Docs
2. Group Announcements tab in BuddyPress
3. New BuddyPress plugin: BP External Activity

If you’re building a client site, you can activate the plugin directly in the WordPress Dashboard, and instantiate the class anywhere in your installation. Or, if you’re the developer of a theme or plugin that you’ll be distributing for wide use, you can simply copy the file boones-sortable-columns.php into your own plugin/theme (I recommend a directory called ‘lib’), and then require it manually when you want to do some sortin’.

The plugin is extensively documented inline. I highly recommend that you crack open the source if you have questions about the kinds of options that Boone’s Sortable Columns provides. But, as a quick introduction, here’s a simple example of how you might use the class in your own plugin. Let’s say you have a custom post type called ‘restaurant’, and you want to display a list of restaurants that is sortable by restaurant name, the date when the restaurant was added to the site, and the name of the person who submitted the restaurant (the post author). Here’s the code you might use for a simple table, with my comments and explanations inline.

// Include Boone's Sortable Columns. You only need to do this if you're not running it as a
// standalone plugin. Obviously, you'll need to put the proper path for your plugin.
require_once( WP_CONTENT_DIR . '/my-plugin-name/lib/boones-sortable-columns.php' );

// Define an array of column data.
// For more details on these (and more!) arguments, see the plugin's inline docs.
$cols = array(
	array(
		'name'		=> 'title',
		'title'		=> 'Restaurant Name',
		'css_class'	=> 'restaurant-name',
		'is_default'	=> true
	),
	array(
		'name'		=> 'author',
		'title'		=> 'Creator',
		'css_class'	=> 'creator'
	),
	array(
		'name'		=> 'date',
		'title'		=> 'Date Added',
		'css_class'	=> 'date-added',
		'default_order'	=> 'desc'
	)
);

// Create the sorting object based on this column data.
$sortable = new BBG_CPT_Sort( $cols );

// Use some of the data from the $sortable object to help you build a posts query.
// In this example, I've intentionally chosen sortable options that can be passed directly to the
// 'orderby' param, because they are accepted directly by WP_Query (see http://codex.wordpress.org/Function_Reference/WP_Query#Order_.26_Orderby_Parameters for more details).
// In real life, your query might require something more complex, like the building of a meta_query.
$query_args = array(
	'post_type'	=> 'restaurant',
	'orderby'	=> $sortable->get_orderby,
	'order'		=> $sortable->get_order
);

// Fire the query
$restaurants = new WP_Query( $query_args );

// Now let's create the table markup. Here's where the magic really happens.
?>

<?php if ( $restaurants->have_posts() ) : ?>
	<table>
		<thead>
		<tr>
		<?php /* Boone's Sortable Columns has a Loop syntax similar to WP's Loop */ ?>
		<?php if ( $sortable->have_columns() ) : ?>
			<?php while ( $sortable->have_columns ) : $sortable->the_column() ?>
				<?php /* Boone's Sortable Columns has some fancy methods to make life easy */ ?>
				<th class="<?php $sortable->the_column_css_class() ?>">
					<a href="<?php $sortable->the_column_next_link( 'url' ) ?>"><?php $sortable->the_column_title() ?></a>
				</th>
			<?php endwhile ?>
		<?php endif ?>
		<tr>
		</thead>

		<tbody>
		<?php /* Here's where you do whatever you'd normally do with your posts */ ?>
		<?php while ( $restaurants->have_posts() ) : $restaurants->the_post() ?>
			<tr>
				<td class="restaurant-name"><?php the_title() ?></td>

				<td class="creator"><?php the_author_link() ?></td>

				<td class="date-added"><?php the_date() ?></td>
			</tr>
		<?php endwhile ?>
		</tbody>
	</table>
<?php endif ?>

Boone’s Sortable Columns handles everything else for you. It figures out what the current orderby/order parameters are. It figures out what the href on the column headers should be. It even creates CSS selectors for the <th> element that match what WP itself uses in the ‘widefat’ tables on the Dashboard, so that you can take advantage of all the pretty JS and CSS built into the WP admin interface. In fact, if this were a Dashboard page, you could simplify the <thead> described above as follows:

<thead><tr>
<?php if ( $sortable->have_columns() ) : ?>
	<?php while ( $sortable->have_columns ) : $sortable->the_column() ?>
		<?php $sortable->the_column_th() ?>
	<?php endwhile ?>
<?php endif ?>
</tr></thead>

The method the_column_th() will build the markup for you. Ain’t that the bee’s knees?

Together with Boone’s Pagination

Boone’s Sortable Columns is made more scrumptious when combined with Boone’s Pagination. Here’s a compressed (uncommented) version of the example above, this time with some pagination code.

require_once( WP_CONTENT_DIR . '/my-plugin-name/lib/boones-sortable-columns.php' );
require_once( WP_CONTENT_DIR . '/my-plugin-name/lib/boones-pagination.php' );

$cols = array(
	array(
		'name'		=> 'title',
		'title'		=> 'Restaurant Name',
		'css_class'	=> 'restaurant-name',
		'is_default'	=> true
	),
	array(
		'name'		=> 'author',
		'title'		=> 'Creator',
		'css_class'	=> 'creator'
	),
	array(
		'name'		=> 'date',
		'title'		=> 'Date Added',
		'css_class'	=> 'date-added',
		'default_order'	=> 'desc'
	)
);

$sortable = new BBG_CPT_Sort( $cols );

$pagination = new BBG_CPT_Pagination();

$query_args = array(
	'post_type'	=> 'restaurant',
	'orderby'	=> $sortable->get_orderby,
	'order'		=> $sortable->get_order,
	'paged'		=> $pagination->get_paged,
	'per_page'	=> $pagination->get_per_page
);

$restaurants = new WP_Query( $query_args );

$pagination->setup_query( $restaurants );
?>

<?php if ( $restaurants->have_posts() ) : ?>
	<div class="pagination">
		<div class="currently-viewing">
			<?php $pagination->currently_viewing_text() ?>
		</div>

		<div class="pag-links">
			<?php $pagination->paginate_links() ?>
		</div>
	</div>

	<table>
		<thead>
		<tr>
		<?php if ( $sortable->have_columns() ) : ?>
			<?php while ( $sortable->have_columns ) : $sortable->the_column() ?>
				<th class="<?php $sortable->the_column_css_class() ?>">
					<a href="<?php $sortable->the_column_next_link( 'url' ) ?>"><?php $sortable->the_column_title() ?></a>
				</th>
			<?php endwhile ?>
		<?php endif ?>
		<tr>
		</thead>

		<tbody>
		<?php while ( $restaurants->have_posts() ) : $restaurants->the_post() ?>
			<tr>
				<td class="restaurant-name"><?php the_title() ?></td>
				<td class="creator"><?php the_author_link() ?></td>
				<td class="date-added"><?php the_date() ?></td>
			</tr>
		<?php endwhile ?>
		</tbody>
	</table>

	<div class="pagination">
		<div class="currently-viewing">
			<?php $pagination->currently_viewing_text() ?>
		</div>

		<div class="pag-links">
			<?php $pagination->paginate_links() ?>
		</div>
	</div>
<?php endif ?>

Sweet, huh? If you want to see some real-life, more complex examples of Boone’s Pagination and Boone’s Sortable Columns in use, check out Invite Anyone (where the data is a custom post type, as in the example above – see method invite_anyone_settings_mi_content()) or Unconfirmed (where the data actually comes from a custom query of the wp_signups table – look for the admin_panel_main() method).

You can get Boone’s Sortable Columns from the wordpress.org repo or follow its development on Github.

Related posts:

1. New WordPress plugin: Boone’s Pagination
2. New WordPress plugin: Unconfirmed
3. Working on a photoblog theme for WordPress

So I took a little time to write a reusable class for a lot of these common functions. It’s called – tada! – Boone’s Pagination. This is not so much a plugin in itself (though if you plan to use it a lot on a client site, you can activate it as a plugin) as it is a helper for people building themes and plugins. Here’s how you use it:

require_once( dirname(__FILE__) . '/boones-pagination.php' ); // You only need this if you don't activate it as a plugin

$pagination = new BBG_CPT_Pag;

$my_query_args = array(
	'post_type'	 => 'my_post_type',
	'paged'		 => $pagination->get_paged,
	'posts_per_page' => $pagination->get_per_page // This does all the work of fetching the pagination arguments out of the $_GET global
);

$my_query = new WP_Query( $my_query_args );
$pagination->setup_query( $my_query ); // Now that you've run the query, finish populating the object

if ( $my_query->have_posts() ) :
	while ( $my_query->have_posts() ); $my_query->the_post();
	the_title(); // Do whatever you'd normally do in The Loop
endif;

$pagination->currently_viewing_text(); // eg "Viewing 11-20 of 34"
$pagination->paginate_links(); // These are the links themselves

I’ll keep adding handy functions to the class as I think of them, but you should feel free to extend it yourself. I’ve also added plenty of inline docs, so crack open the source to learn more about it. Follow Boone’s Pagination on Github.

Related posts:

1. New WordPress plugin: Boone’s Sortable Columns
2. Working on a photoblog theme for WordPress
3. Using Github with wordpress.org plugin SVN

BuddyPress Docs edit screen

Today I am releasing the first public beta of a significant new BuddyPress plugin: BuddyPress Docs. BuddyPress Docs is a collaborative, front-end, rich-text, document editing tool for BuddyPress groups (individual user Docs are an upcoming feature). Read much more about the plugin’s features.

This plugin has been developed for the CUNY Academic Commons (though it won’t be live there for a few weeks). Today’s release is a pre-stable beta – it should run fine, but there are bound to be bugs, and you probably won’t want to run it on a production site quite yet.

You can follow the plugin’s development at http://github.com/boonebgorges/buddypress-docs.

Related posts:

1. BuddyPress Docs 1.1: Doc History
2. New BuddyPress plugin: Enhanced BuddyPress Widgets
3. New BuddyPress plugin: BuddyPress Group Email Subscription

CloudSponge is a paid service (though they have a free trial). If you decide to become a CloudSponge customer through Invite Anyone, I’ll receive a small portion of your membership fees as an affiliate bonus. You can think of this as a way to support future development on Invite Anyone, by making sure that I have money to purchase the beer and pizza that fuel so much of my code :)

Of course, CloudSponge is an optional add-on to Invite Anyone. The plugin itself, and all its existing features, will continue to be free. CloudSponge is a little something extra for those communities where a regular stream of new members is key to success.

Related posts:

1. Invite Anyone 0.9: Admin management and stats
2. New BuddyPress plugin: Invite Anyone
3. Big new version of Invite Anyone for BuddyPress

It’ll be in the wordpress.org repository soon enough, but for now you can read more and download it here.

Related posts:

1. Using Github with wordpress.org plugin SVN
2. New WordPress plugin: Add User Autocomplete
3. Introducing Anthologize, a new WordPress plugin

• The id attribute is required. The plugin should understand both the unique Prezi ids (the jumble of letters and numbers in the URL) and the entire URL of the presentation (eg http://prezi.com/hgjm18z36h75/why-should-you-move-beyond-slides/).

      [prezi id='http://prezi.com/hgjm18z36h75/why-should-you-move-beyond-slides/']
      [prezi id='hgjm18z36h75']
      

• The plugin also accepts optional width and height parameters:

    [prezi id='hgjm18z36h75' width='600' height='450']
    

Prezi WP was developed for the CUNY Academic Commons.

Download Prezi WP here.

Prezi WP has been downloaded 847 times. Are you using this plugin? Consider a donation.

No related posts.

I had a request or two to explain how I built the Group Announcements feature on the CUNY Academic Commons. Here goes.

Brief background: When the Commons was upgraded to BuddyPress 1.2, we got the benefit of interactive activity streams everywhere, including groups. This caused some confusion, however, as users were uncertain where conversation best fit into the Commons’s architecture: in the Forums (where it had been traditionally), or in the activity stream. In some communities this kind of fracturing might be okay or even welcome, but in ours it was confusing. At the same time, we wanted a way for group admins and mods to send important notices to the members of their groups. By taking the group activity updates and repurposing it as a Group Announcements section, I was able to kill two birds with one stone: providing an announcement space for mods, while focusing extended discussion in the forums.

You can download the CAC Group Announcements plugin here.

I’m not putting this in the repo at the moment because I don’t want to build a proper admin UI and support it :) For that reason, here is a primer on how the plugin works – if you want to customize or maintain it, you’re on your own, buster.

1. The CAC_Group_Announcements class is an instance of the BuddyPress Group Extension API. It is responsible for creating the Announcements tab markup and adding it to the nav. You’ll notice that the majority of the markup is created by including bp-default’s activity-loop.php and post-form.php templates. You could customize this more if you wanted.
2. bp_is_group_announcements() is a little template tag that can be used to test whether you’re looking at a group announcements page. This is needed for the activity filter, in step 3.
3. cac_set_announcement_filter() adds a filter to the bp_has_activities query string when you are looking at an announcements page, so that it only displays activity items of the type activity_update. In other words, when you are looking at the regular activity stream for the group, you see all of the associated group activity items (new members, forum posts, etc) but when you’re on the announcements page you only see activity updates (which, remember, have been repurposed as announcements).

As I look at the code, I see that there are things I would definitely change if I were going to make this into a distributed plugin. If you want to make those changes, be my guest. You’re welcome to help each other in the comment section, but I won’t be formally supporting this, as it is a very basic hack that should happen at the theme level anyway. Good luck!

Related posts:

1. New BuddyPress plugin: BuddyPress Group Email Subscription
2. New BuddyPress plugin: BP Group Reviews
3. New BuddyPress plugin: BP Group Management

Step 1: Anthologize, meet my format

Anthologize has what I like to think of as two internal APIs: the WordPress-facing API, and the theming API. The first step is to let Anthologize know that your format exists, which you’ll do by using the key function in the WP-facing API: anthologize_register_format(). (Check out how the WPAPI functions work in the source.) You should call anthologize_register_format() in a function hooked to anthologize_init, which ensures that it won’t fire before Anthologize is ready for it. Here’s a simple example:

function register_my_anthologize_format() {
	$name = 'example_format';
	$label = 'My Anthologize Format';
	$loader_file = dirname(__FILE__) . '/base.php';

	anthologize_register_format( $name, $label, $loader_file );
}
add_action( 'anthologize_init', 'register_my_anthologize_format' );

anthologize_register_format_option() takes three arguments. The first is the name that Anthologize will use internally as a unique key for your format. The second is the name that users will see on the Export screen radio button and elsewhere in the interface. (It’s a good idea to set a textdomain for your strings so that they can be translated – eg $label = __( 'My Anthologize Format', 'my-anthologize-plugin' );.) The third argument is the absolute server path of your main translator file, the file that will be loaded at export time.

You can read a more in-depth example, embedded in a loader class, in this bare-bones plugin that I built for testing purposes. And the definitive examples, of course, can be found in the way that Anthologize registers its native export formats (yum, we love eating our own dog food!).

What does this give you? First, it makes your format available as a format option on the second screen of the export process:



Second, it gives your format a Publishing Options page. Since we haven’t registered any options yet, we get the bare minimum, the shortcode toggle that all formats get:



Third – and this is the big thing – anthologize_register_format() tells Anthologize that, if the user has selected your format on the export screens, the TEI document containing the project data will be handed off to the translator file whose path you specified when you registered the format. That’s where the format translation itself happens.

Step 2: Gimme some options

One of the big thoughts behind the Anthologize plugin architecture is to model WordPress’s design philosophy, which is to provide relatively few options in the core product but to allow for arbitrarily extended functionality by plugins. That’s the purpose behind anthologize_register_format_option(), the second pillar of Anthologize’s WP-facing API. anthologize_register_format_option() gives a framework for plugins to register any kind of option associated with their custom format, provides all the integrated markup for presenting those options to users, and passes along the user’s choices to the Anthologize TEI document used for format translation.

Format options can also be loaded at anthologize_init, though you should be careful to load them after the format itself. I’ll do that by using an add_action priority:

function register_my_anthologize_format_options() {
	$website_name = 'website';
	$website_label = 'Website';
	$website_type = 'textbox';

	anthologize_register_format_option( 'example_format', $website_name, $website_label, $website_type );
}
add_action( 'anthologize_init', 'register_my_anthologize_format_options', 15 );

(Note that the first argument is the unique $name of the format I intend to associate the option with.) This registers a plain textbox with the label ‘Website’:



You can also register checkboxes, if you need a Boolean:

$option_name = 'include_dedication';
$option_label = 'Include Dedication?';
$option_type = 'checkbox';

anthologize_register_format_option( 'example_format', $option_name, $option_label, $option_type );

Or you can register dropdowns:

$fontface_format_name = 'example_format';
$fontface_option_name = 'font-face';
$fontface_label = 'Font Face';
$fontface_type = 'dropdown';
$fontface_values = array(
	'courier' => 'Courier',
	'georgia' => 'Georgia',
	'garamond' => 'Garamond'
);
$fontface_default = 'georgia';

anthologize_register_format_option( $fontface_format_name, $fontface_option_name, $fontface_label, $fontface_type, $fontface_values, $fontface_default );

This kind of option highlights some of the other possible arguments that anthologize_register_format_option() will take: an array of possible values, and a default selected value:

All the options you provide, and in particular the options selected by the user at export time, are handed to your main translator file at the very end of the Anthologize export process.

So that’s how you get your format and its options registered on the WordPress side of things. Stay tuned for a discussion of how translators might be built.

Are you a potential plugin developer with ideas about how this API might evolve to better suit your purposes? Hop onto the dev list.

Related posts:

1. Extending Anthologize: Part 1
2. Anthologize 0.4-alpha is released
3. Introducing Anthologize, a new WordPress plugin