All Readmes from PeoplePods.net

SDK Quick Start Guide

2009-12-03T03:59:10-08:00

This page is intended to give developers a quick overview of the basic functionality of PeoplePods. Links to further documentation are scattered throughout - we highly encourage you to explore further to get a good feel for the scope and power of PeoplePods.

Using the techniques below, you can layer PeoplePods functionality onto existing PHP-powered sites, or you can create new plugin pods which function within PeoplePods.

Creating a $POD

To access PeoplePods, you need to create a $POD object. You do this by including the library file, and calling PeoplePod's constructor. In order to do so in a manner compatible with the core pods and default theme, you need to call it like so:

include_once("$my_peoplepods_dir/PeoplePods.php");
$POD = new PeoplePod(array('authSecret'=>$_COOKIE['pp_auth']));

You may want to specify that the new feature you are creating can only be accessed by certain people. You can do this using the 'lockdown' parameter:

// only allow logged in people
$POD = new PeoplePod(array(
 'authSecret'=>$_COOKIE['pp_auth'],
  'lockdown'=>'login'
));

// only allow logged in people who have confirmed their email address
$POD = new PeoplePod(array(
  'authSecret'=>$_COOKIE['pp_auth'],
  'lockdown'=>'verified'
));

// only allow logged in people with the adminUser permission
$POD = new PeoplePod(array(
  'authSecret'=>$_COOKIE['pp_auth'],
  'lockdown'=>'adminUser'
));

Once you've got your $POD object, you can access the details about the current logged in user, if one exists, using $POD->isAuthenticated() and $POD->currentUser().

Creating Content

Creating a piece of PeoplePods content is as easy as creating an empty content object to store it using $POD->getContent(), then calling the save() function. At the bare minimum, a piece of content must have a headline and a type:

$new_content = $POD->getContent();
$new_content->headline = 'This is a new post';
$new_content->type = 'post';
$new_content->save();

Part of the magic of PeoplePods is that you can create any field you want, on the fly, and PeoplePods will automatically handle it as if it was a native field in your database. This allows you to create many types of content in many different configurations. We call this creating meta fields. But you don't need to know anything special to access this functionality - it all happens behind the scenes.

$new_content->new_field = 'foo';
echo $new_content->new_field;

PeoplePods automatically tracks a bunch of information about the content, including when it was created and who created it, so you can just worry about stuffing your website with cool content.

Once you've created your content, you can add tags, comments and files using simple object methods:

$content->addComment('my comment goes here');
$content->addTag('foo');
$content->addFile($filename,$_FILES[$filename]);

Combining all of these features, you can create and manage virtually any kind of web content, and can do so without any sort of pre-configuration.

// create a new piece of content of type 'post'
$new_post = $POD->getContent();
$new_post->type='post';
$new_post->headline='my new post';
$new_post->save();

// now create another piece of content of type 'receipt'
// the receipt will use a meta field to track what content was created
$receipt = $POD->getContent();
$receipt->type = 'receipt';
$receipt->headline='Created content';
$receipt->content_created = $new_post->get('id');
$receipt->cost = 500;
$receipt->save();

Finding and Displaying Stuff

PeoplePods provides a query interface to all of the stuff it manages, including your website content, users, groups, comments, files and tags. You can use this interface to generate customized and personalized lists of stuff, then output them into your pages. In this way, you can create blogs, sidebars, tag clouds, lists of attached files, comment streams, and many other configurations.

Each type of "stuff" PeoplePods manages has its own query function, but all of the functions take the same parameters:

$posts = $POD->getContents($conditions,$sort,$count,$offset);
$people = $POD->getPeople($conditions,$sort,$count,$offset);
$files = $POD->getFiles($conditions,$sort,$count,$offset);
$groups = $POD->getGroups($conditions,$sort,$count,$offset);
$tags = $POD->getTags($conditions,$sort,$count,$offset);
$comments = $POD->getComments($conditions,$sort,$count,$offset);

Most of the time, you'll be concerned with the $conditions parameter. This is an array of field=>value pairs that describe the content you want to load. This might be as simple as specifying the type of content or the id of the content's owner, or it might involve a combination of several fields. You can read about stack parameters here.

The return value of these functions is a list of objects, or what we call a stack. You can do all sorts of things with stacks, including iterating over them, searching them, and outputting them to the page.

Each object also has its own output function, which uses a template file located in one of the themes. You can also output individual fields using write() and other related functions.

// get recent posts
$posts = $POD->getContents(array('type'=>'post'));

// get recent posts by a specific author
$posts = $POD->getContents(array('type'=>'post','userId'=>6));

// use foreach to iterate over the results
foreach ($posts as $post) { 
  $post->output();
}

// use while to iterate over the results
while ($post = $posts->getNext()) {
  $post->output();
}

// just output the entire list, with automatically generated headers and footers
$posts->output();

You can query any of the different object types using any field in their object definition as well as any fields you create using the meta fields technique. You can also query fields in related objects, like the author of a post, members of groups, or a comment's parent content. Using this capability, you can create virtually any view of your website that you can imagine.

// get all comments that are attached to content in a specific group
$comments = $POD->getComments(array('d.groupId'=>5));

// get all files created by an admin user
$files = $POD->getFiles(array('u.adminUser'=>1));

Once you have the stuff you want, you can access related stuff without more queries. Each type of object comes with predefined stacks:

$comments = $content->comments();
$author = $content->author();
$files = $content->files();
$content = $comment->parent();
$people = $group->members();

Creating Relationships Between People and Content

You can create relationships between 2 people, or between a person and a piece of content using flags:

// add $content to $user's favorites
$content->addFlag('favorite',$user);

// add $friend as $user's friend
$friend->addFlag('friend',$user);

You can then query the content and people using those flags:

// load my favorites
$favorites = $POD->getContents(array(
  'flag.name'=>'favorite',
   'flag.userId'=>$user->id
));

// load my friends
$friends = $POD->getPeople(array(
  'flag.name'=>'friend',
  'flag.userId'=>$user->id
));

Luckily, PeoplePods provides a bunch of built in flag management for favorites, friends, followers, and comment subscriptions.

Groups

We believe the future of online community revolves around small groups. Groups for clubs, groups for interests, groups for neighborhoods, and group for groups! Thus, we've built basic group handling right into the core of PeoplePods.

// create a group
$new_group = $POD->getGroup();
$new_group->group_name = 'Scoobies';
$new_group->description = 'For vampire hunters';
$new_group->save();

// add a piece of content to a group
$new_group->addContent($post);

// add a user to the group
$new_group->addMember($user);

$person->addFile()

2009-12-03T02:47:36-08:00

$person->addFile('img',$_FILES['img'],'optional caption goes here');

Takes an uploaded file and attaches it a person. This function is designed to handle rows out of the $_FILES array which PHP automatically provides when a file has been uploaded via an HTTP POST.

// store all files that were uploaded
foreach ($_FILES as $file_name => $file) { 
	$person->addFile($file_name,$file);
	if (!$person->success()) { 
	  echo $person->error();
	}
}

Image files will be automatically resized upon upload.

$content->addFile()

2009-12-03T02:46:53-08:00

$content->addFile('img',$_FILES['img'],'optional caption goes here');

Takes an uploaded file and attaches it to the piece of content. This function is designed to handle rows out of the $_FILES array which PHP automatically provides when a file has been uploaded via an HTTP POST.

// store all files that were uploaded
foreach ($_FILES as $file_name => $file) { 
	$content->addFile($file_name,$file);
	if (!$content->success()) { 
	  echo $content->error();
	}
}

Image files will be automatically resized upon upload.

$file->output()

2009-12-03T02:42:10-08:00

Outputs the current file using a template.

By default, this function will use the files/output.php file in the current theme. This can be overridden by passing in a template name:

// output the file using the default template 'output'
$file->output();

// output the file using an alternative template:
$file->output('short');

Within the template, you can access the file's information using the $file variable, and the POD using the $POD variable. So, you can do something like this:

$p = $POD->currentUser();
$p->output('tiny');

And then, in files/tiny.php in your theme directory:

// people/tiny.php template
<? $file->write('resized'); ?>

$POD->getFile()

2009-12-03T02:40:24-08:00

Returns one specific File Object. This function can be used to load existing content from the database, or create a new piece of content.

Loading Files

To load an existing file, pass in it's database id:

$file = $POD->getFile(array(
  'id'=>12
));

Creating Files

To create files, use the $content->addFile() and $person->addFile() functions.

Errors

Be sure to check for errors! In some instances, the content object may not be created properly, and will throw an error.

if (!$file->success()) {
  echo $file->error();
}

$POD->getFiles()

2009-12-03T02:36:39-08:00

$POD->getFiles($conditions,$sort,$count,$offset);

Get a stack of file objects that match the parameters you pass in.

Parameters

$conditions	An associative array of stack parameters that describe the files you want to load. See the stack parameters document for constructing these arrays.
$sort	A SQL style sort statement. Defaults to 'date DESC'
$count	Maximum number of pieces of content to return. Defaults to 100
$offset	Offset results by this many files. (for use in paging)

Examples

Get a simple list of the most recent files.

$most_recent = $POD->getFiles();

Get a simple list of the most recent files by a specific person.

$most_recent = $POD->getFiles(array(
  'userId'=>$person->get('id')
));

Get a simple list of the most recent files on a piece of content:

$most_recent = $POD->getFiles(array(
  'contentId'=>$content->get('id')
));

The above example is essentially the same thing as using the $content->files() function.

Get files from a group.

$group_files = $POD->getFiles(array(
	'd.groupId'=>$group->get('id')
));

Be sure to check out the stack documentation for all the functionality the resulting stack will have!

$file->src()

2009-12-03T02:34:07-08:00

$src = $file->src($max_width,$square=false);

This function will resize the image to $max_width pixels wide and return the URL for the new image. If $square is true, the image will also be cropped into a square.

This function caches the resulting image, so it will only be generated once.

// get a 100 pixel wide image
$src = $image->src(100);

// get a 50 pixel square image
$src = $image->src(50,true);

Note: If the image is smaller than $max_width, no resizing will occur.

$file->download()

2009-12-03T02:29:29-08:00

// download original file
$file->download();

// download resized image file
$file->download('resized');

// download thumbnail image file
$file->download('thumbnail');

Cause the contents of the file to be sent to the browser, complete with mime-type headers. The file will download with the original uploaded file's name.

$file->isImage()

2009-12-03T02:24:56-08:00

Returns true if the file is an image file, false if it is any other kind of file.

Image files include jpg, gif and png files.

README

2009-10-29T02:30:20-07:00

Welcome to the PeoplePods documentation! Below, we've collected links to the high level documentation. Many more pages of documentation, including descriptions of every object and every function, can be found by following these links. If you cannot find an answer to your question, visit the forum.

Getting Started

What is PeoplePods?

Installing PeoplePods

Core Pods

SDK Quick Start Guide

ALL of the documentation on ONE GIANT PAGE - handy if you need to quickly search for something.

Developing with PeoplePods

Themes

SDK Documentation

Object Definitions

Tutorials

Creating new pods

Creating new content types

$POD->registerPOD()

2009-09-11T11:00:12-07:00

Creating a new content type

2009-09-07T10:21:25-07:00

To create a new content type, use the core_usercontent pod as an example. This pod contains several files, including generic handlers for adding and editing content, viewing permalinks, viewing lists of content, adding comments, add accepting votes.

You can customize the content type by editing a simple config file and creating a few templates in your theme! However, you'll probably want to dig deeper into the code to add special functionality.

1) Copy core_usercontent pod to a new name

cp -R core_usercontent content_post

2) Edit the content_type.php file. This file contains information used by all the other files.

Set the $content_type variable to a short name for the new content type. No spaces!

	$content_type ='post';

Set the $permamlink variable tp first part of the permalink. This will be used to make links to each piece of content, as well as to the list of most recent content. We'll use "blog." This means we can get a list of new posts at /blog and each post will be located at /blog/title-of-post

	$permalink = 'blog';

Set the edit/add url. This means I can go to /edit to create a new post.

$edit_link = "edit";

Change the name of the edit form template. This template will be located in the theme/content folder and will be used on the add/edit page

	$input_template = 'postform';

Change the name of the default output template for the content permalink:

	$output_template = 'post';

Change the $pod_dir variable to the same name as the folder you created in step 1.

	$pod_dir = "content_post";

3) Go into your theme content directory. Copy editform.php to the new template you referenced in step 2.

cp editform.php postform.php

4) Make changes to the form design and fields.

You can create meta fields by naming them meta_fieldname

You can attach files by simply creating file inputs. The files will be named the same as thing as the input.

For example, if we wanted to add a meta field named "Via" we could add this to our form:

<input type="text" name="meta_via" value="" />

5) Copy output.php to the the new template you referenced in step 2.

cp output.php post.php

6) Load the PeoplePods Command Center, go to Options->Plugin Pods and turn on your new custom content type pods. They'll be called contenttype_YOURCONTENTTYPE_add, contenttype_YOURCONTENTTYPE_edit, and contenttype_YOURCONTENTTYPE_list.

7) Navigate to your new add/edit screen. You should see your new form. Create your first test post!

8) Your new post should show up at the top of your content list. Click on it. You should see that it goes to a new permalink url as descrived in step 2. But the template is the generic template!

9) Go back to your theme directory and customize post.php

VOILA!

You may want to change the access restrictions on your new content type pods. For example, you may want to restrict the add/edit pod to admin users. You can do this by changing the 'lockdown' parameter in the pod files.

Creating New Pods

2009-09-07T02:36:35-07:00

Pods are reusable modules that define areas of functionality on a PeoplePods site. Each pod lives in it's own folder, and contains the following elements:

A file called 'settings.php' which contains an API call that describes the pod and how it works to PeoplePods.
One or more script files containing PHP code and SDK calls.
Any custom template files referenced within the scripts.

In this tutorial, we will explain each of these components and walk you through the creation of a new pod. This example pod will create a welcome page that displays a personalized message to the visitor.

Set Up Your New Pod

The first step to creating a new pod is to create a new folder in your PeoplePod's installation under the pods/ folder. The name of the folder should match the name of your new pod. For our example, we'll create a folder called "custom_welcome"

Inside this folder, immediately create two files blank files: settings.php and index.php.

Once you're done, you should have a file structure something like this:

/mywebsite/peoplepods/pods/custom_welcome/settings.php

/mywebsite/peoplepods/pods/custom_welcome/index.php

Settings.php

The settings.php file tells PeoplePods how to integrate the pods functionality into the site. It tells PeoplePods what the pods name is, describes it's functionality, sets up the path to the new functionality, and defines any system-wide variables the pod requires.

This file should contain just one command, a call to $POD->registerPOD().

For our example pod, we'll put the following code:

$POD->registerPOD(
  'custom_welcome',
  'display a custom welcome page',
  array(
    '^welcome'=>'custom_welcome/index.php'
  ),
  array()
);

SWEET FANCY MOSES, that looks complicated! But don't fret! Let's break it down.

The first parameter we pass to registerPOD is the name of the pod. This is the same as the name of the folder you created above.

The second parameter is a short description of the pod. This is what will be displayed in the admin tools.

The third parameter is where we start to get tricky. This parameter is an array that defines the URL mapping, which is then used to build one or more mod_rewrite rules that tell your web server what to do. For each URL pattern you want to map, you'll add a value to this array.

In our example above, we are mapping the url /welcome to the code contained within the index.php script. That is, once this pod is enabled, the url "http://mywebsite.com/welcome" will actually execute the code inside this pod.

This pattern can contain multiple parameters, and may include wildcards. This allows you to define patterns that actually define many dynamic pages, such as content permalink pages. Read the registerPOD() page for information on how to construct these patterns.

The final parameter is an optional array of key/value pairs that will be available to all of PeoplePods when this pod is enabled. For this example pod, we don't need anything here. This parameter is most often used to define the permalink structure for new content types.

Index.php

The index.php file contains the actual code of the module. You may have all of your code in one file, or you may have multiple files that provide different pieces of the functionality. Regardless, each file will follow the same basic structure.

The first thing we need to put in this file is a call to include the PeoplePods library and boot up the $POD object. As part of the boot up, we pass in the authentication cookie that identifies the current user, a parameter that describes the minimum access level a person must have to access the pod, and a debug level. These options are described in more detail here. In this example, we are not putting any access restrictions on this page, and we're turning off the debug information.

include_once("../../PeoplePods.php");
$POD = new PeoplePod(array(
  'authSecret'=>$_COOKIE['pp_auth'],
  'lockdown'=>null,
  'debug'=>0
));

After the $POD has been created, you'll want to actually do something with it. We'll start off by calling the header() and footer() functions which will wrap the pod's output in the site's header and footer:

include_once("../../PeoplePods.php");
$POD = new PeoplePod(array(
  'authSecret'=>$_COOKIE['pp_auth'],
  'lockdown'=>null,
  'debug'=>0
));

$POD->header('Welcome!');

// the pod's main code will go here

$POD->footer();

Now, all that's left is to write the custom code that will power the pod. Like any PHP script, you can put code and HTML markup here, though most of the markup should live in template files. For this example, we'll start by putting everything in the pod file, then later we'll move some of it into a new template file.

For our example, we're going to do something really, really basic: print a personalized welcome message to the current visitor. The visitor may be a member of the site, or they may be anonymous - that is, not logged in. So we'll have to tap into the PeoplePods library to do some basic logic - checking to see if the person is authenticated, then printing one of two messages. Put this code in between the calls to header() and footer().

if ($POD->isAuthenticated()) { 
  echo "Welcome back, ";
  $POD->currentUser()->write('nick');
} else {
  echo "Hello stranger!  Welcome to PeoplePods.";
}

At this point, you've got a fully functioning pod! Save the index.php file and the settings.php file, and load up your PeoplePods admin tool. Navigate to Options -> Plugin Pods, and you should the name and description of your new pod in the list. Click "Turn On" to enable the pod. If everything has been set up correctly, you should now be able to navigate to "http://mywebsite.com/welcome" and see the output of the new pod, which should look something like this:

Welcome back, admin

Wow! Wow!

Ok, it is a bit boring. Let's give the visitor a little something extra to look at. How about a list of the most recent content posted to the site? Easy! We'll just use the getContents() function. (This is a very simple use of this function - check the function page for more information on customizing what content you load.) This code will load the most recent content of any type, then print out a paragraph for each post with a link to the post and a timestamp. Add it underneath the code you just added:

$recent_posts = $POD->getContents();
foreach($recent_posts as $post) {
  echo "<p>";
  $post->permalink();
  echo ", posted ";
  $post->write('timesince');  
  echo "</p>"
}

Now, you're output will look something like this:

Welcome back, admin

Post #5, posted 15 minutes ago

Post #4, posted 20 minutes ago

Post #3, posted 1 hour ago

Post #2, posted 1 day ago

Post #1, posted 5 days ago

Not too shabby! But having the markup of the content list in the pod is a bit messy, and will make the pod more difficult to manage in the future when modifications to the output styles are required. We can fix this by moving the markup for the content into a new template file.

Custom Template Files

PeoplePods allows you to create template files for any bit of markup or code you are going to use or reuse. This allows you to separate the application logic from your presentation.

Template files are located inside of themes, which are located in the themes/ folder of your PeoplePods installation. By default, PeoplePods uses a theme called default, located in themes/default/.

Inside each theme are many template files, spread across a few folders. Template files for outputting a person object are inside the people/ folder, whereas template files for outputting a content object are inside the content/ folder.

For this example, we are going to create a new template file inside the content/ folder called "recent_post.php" So, when you're done, your file structure should be:

/mywebsite/peoplepods/themes/default/content/recent_post.php

Inside this file, we want to put the code and markup that represents the output of one piece of content. This code and markup will then be re-used for each item in the $recent_posts list. Inside the template, we still have access to the $POD variable, and we also have a new variable called $content which represents the piece of content that is being displayed. So, inside of recent_post.php, put the following code:

  echo "<p>";
  $content->permalink();
  echo ", posted ";
  $content->write('timesince');  
  echo "</p>"

Save the new template file. Now, go back to your pod's index.php file and strip out the markup that you just moved to the template, and replace it with a call to the content object's output() function. Notice that we pass in the name of the new template file to the output function.

foreach ($recent_posts as $post) {
  $post->output('recent_post');
}

Save your index.php file, and reload the welcome page in your browser. The output should look exactly the same as before!

If we wanted to be extra clever, we could shorten this code even further by using stack object's output() function. This is just like the content object's output function, except that it will cause each item in the stack to output itself without having to use the foreach() loop:

$recent_posts->output('recent_post');

Again, the output should be exactly the same as before.

It should be noted that, theoretically, we could also move the actual welcome message to a template within the people/ folder, and instead of printing it in the pod's code, simply call the output() function on the person object. However, since we're not going to be reusing that markup anywhere, and because it only appears once on the page, it's not necessary to add another template file in this case.

Our completed pod code should now look like this:

include_once("../../PeoplePods.php");
$POD = new PeoplePod(array(
  'authSecret'=>$_COOKIE['pp_auth'],
  'lockdown'=>null,
  'debug'=>0
));

$POD->header('Welcome!');

if ($POD->isAuthenticated()) { 
  echo "Welcome back, ";
  $POD->currentUser()->write('nick');
} else {
  echo "Hello stranger!  Welcome to PeoplePods.";
}

$recent_posts = $POD->getContents();
$recent_posts->output('recent_post');

$POD->footer();

At this point, you've got a fully functioning custom pod! You can turn it on and off via the admin tools, and you can customize its display by modifying the recent_post template file instead of hacking into the pod's code. You can even share this pod with other PeoplePod's sites by simply zipping up the custom_welcome/ folder and sending it to other developers.

Core Pods

2009-09-07T02:36:24-07:00

core_api_simple provides a simple RESTful JSON api to many of the common functions you'll need to implement Ajax controsl.

core_authentication provides everything you need to enable visitors to join your site, verify their accounts, and manage their security preferences.

core_feeds provides a flexible method for producing lists and feeds of documents that match certain conditions.

core_files handles file attachements.

core_friends provides a friend management interface with friends, followers, and recommended friends.

core_groups provides an interface for members to create and join groups.

core_invite provides an email invitation tool so that members can invite their friends.

core_newest provides a simple list of the newest posts on the site.

core_private_messaging provides the ability for members to send messages to one another on the site, and to manage these conversations in an onsite inbox.

core_profiles provides member with ability to create and modify personal profiles.

core_search provides an interface for searching the content and the members of the site.

core_usercontent provides a default handler for generic content. creates the add/edit screen, the permalink pages, and the reverse cron list of content. Can be customized to create new content types!

dashboard provides a customized activity dashboard for members including new content from their friends, as well as new comments on content they're interested in.

Admin Tools

2009-09-07T02:36:09-07:00

Installing PeoplePods

2009-09-07T02:36:00-07:00

To install PeoplePods, you will need a web server, a MySQL database server, and a copy of the PeoplePods code.

NOTE: The PeoplePods archive contains a README.txt file which may have more up-to-date instructions!

Download the latest version of PeoplePods from PeoplePods.net.

Upload the archive to your web server and place it in whatever directory you want PeoplePods to live in.

All of the PeoplePods code will live in a sub-folder of your website called "peoplepods/" that is created when you uncompress the tarball. Thus, if you want PeoplePods functionality to be present on the homepage of your site, you'd place the tarball in the root directory of your site. If you want PeoplePods functionality to live in a sub-folder such as myurl.com/community, place the tarball into that folder.

Example

My web root is: /var/www/httpdocs
My domain is: http://myurl.com

If I want PeoplePods to control the homepage and other root
 elements of my site, I decompress my tarball into my webroot,
 and end up with:

PeoplePods folder is: /var/www/httpdocs/peoplepods
PeoplePods admin tool: http://myurl.com/peoplepods/
PeoplePods homepage: http://myurl.com

If I want PeoplePods to live in a sub-folder of my site, I would
 decompress my tarball into that subfolder, and end up with:

PeoplePods folder is: /var/www/httpdocs/my_sub_folder/peoplepods
PeoplePods admin tool: http://myurl.com/my_sub_folder/peoplepods/
PeoplePOds homepage: http://myurl.com/my_sub_folder/

Uncompress your PeoplePods tarball into your web folder
```
      > tar -zxvf peoplepods-0.667.tar.gz
```
This will create a new folder called peoplepods/ inside of which lives all of the PeoplePods code and configuration.
Create a fresh, empty database on your MySQL server. Note the name of the database as well as the username and password.
Before running the install, you will need to set the permissions on several folders. Change the permissions on files/ and lib/etc to 777:
```
      > chmod -R 777 peoplepods/files
      > chmod 777 peoplepods/lib/etc
```
Visit your new PeoplePods installaton in a browser. Load http://myurl.com/peoplepods
The automatic installation process should take over. Enter details about the site and about the database.
Once the installation has completed, visit the PeoplePods admin tool and turn on some built in functionality by using the Options -> Plugin Pods menu. NOTE: The site will not be functional until you turn on some of the built in pods!
Visit your new PeoplePods powered site!

SDK Documentation

2009-09-02T03:01:26-07:00

If you are anxious to get hacking, we recommend the SDK Quick Start Guide.

At the core of PeoplePods is an object oriented programming library that provides much of the functionality required for building today's modern social applications. It provides a generic interface to create and manage content, members, and member activities.

If you are not familiar with the basics of object oriented programming, take some time to read up before proceeding. In short, object oriented programming, or OOP, allows you to bundle pieces of data and functionality together into logical units. PeoplePods provides a variety of different objects that represent different kinds of information.

For example, in PeoplePods, each member is represented by a person object. The object contains information about the member, such as the name and email address used to sign up, as well as functions available to that member, such as adding a friend or bookmarking a page. Here is a tiny snippet of code to illustrate this concept:

// get my person object from the main POD object
$member = $POD->currentUser();

// write out some information about this person
echo "My email address is:";
$member->write('email');

// add some content to this person's favorite list
$member->addFavorite($post);

All of the functionality within a PeoplePods application originates from a single PeoplePods object. We recommend developers name their parent object $POD, as this convention is used within many of the templates and sub-functions in the library.

$POD = new PeoplePod();
$content = $POD->getContent();
$person = $POD->getPerson();

Core Concepts

Generic Interfaces One of the main ideas behind PeoplePods is that it should be provide access to all sorts of content using the same set of functions. That is, you can use the same function with the same syntax to load blog posts as you would to load calendar events. Similarly, a generic system has been provided so that new types of relationships between memberships can be defined - friends, enemies, family, etc - that use the same syntax and provide the same access methods. What this means is, you only have to master a few simple functions to gain access to all of the power of PeoplePods.

This generic access is provided by the core objects such as $Stack, as well as the flagging module.

Ad Hoc Data Definition PeoplePods is different from many content management systems in that it does not require you to pre-define your content types or database schema. It uses a generic schema and the powers of it's underlying relational database system to allow you to create new fields on any content type at any time, and to define new content types on the fly. The admin tools will automatically adapt to the new content types you create.

This functionality is provided by the meta field module.

Building New Functionality

Unlike many website building systems available today, PeoplePods was not designed to create a specific type of website - a blog, for example. There are no limits to the type of pages present on the site, and there is no predefined structure inherent to a PeoplePods site. This allows developers to freely define new types of content and areas of functionality by building plugin pods, or by using PeoplePods functionality in other scripts.

Plugin Pods

PeoplePods has a simple plugin structure called "Pods" which allows developers to create reusable modules that define different functions of the site. It is helpful to think of each pod as defining a specific page type.

For example, one pod creates member profiles. Another creates content permalink pages. Yet another creates a personalized dashboard page.

Using the pod plugin system has a variety of advantages, and is the recommended method for creating new functionality within your PeoplePods site. Pods automatically map their functionality to friendly URLs, provide role-based security, and can be toggled on and off within the admin tools.

We highly recommend using one of the core pods as the basis for any new pods you create. Doing this will provide you with a template for all the necessary components.

Read the instructions for creating new pods, or the more specific instructions on create a pod that will create a new content type.

Stand Alone Scripts

If you don't want to play by our rules, you can use PeoplePods in normal PHP scripts. All one must do is include the PeoplePods library into the script:

require_once("$podlib/PeoplePods.php");
$POD = new PeoplePod();

After creating the $POD object, all of the power of PeoplePods is available for use in that script. This makes it easy to add PeoplePods functionality to existing scripts - such as creating dynamic and personalized sidebars.

It is important to note that the difference between a stand alone script and a full pod is relatively minor - a pod simply provides extra information on how the script should be integrated into the site, whereas a stand alone script is just a script. This might mean the difference between having a pretty URL like "mysite.com/people/chester" and and ugly one like "mysite.com/scripts/profilescript.php?username=chester" Of course, talented developers can fix this problem using mod_rewrite.

Hack Yourself Crazy

We highly recommend that you explore the code of the SDK library. We have made every effort to make our code as readable and well organized as possible with the hopes that skilled developers will be able to modify and expand the provided functionality as necessary. In many cases, creating custom functionality may be as easy as cutting and pasting a few lines of code, then tweaking a parameter or two.

$Stack->sortBy()

2009-09-02T02:56:02-07:00

$Stack->sortBy($field,$reverse=false);

Resort the contents of the stack by $field. You can also sort by meta fields!

$Stack->totalCount()

2009-09-02T02:55:00-07:00

Returns the total number of items available to the stack in the database.

$Stack->count()

2009-09-02T02:54:22-07:00

Returns the number of items currently in the stack.

All Readmes from PeoplePods.net

SDK Quick Start Guide

Creating a $POD

Creating Content

Finding and Displaying Stuff

Creating Relationships Between People and Content

Groups

$person->addFile()

$content->addFile()

$file->output()

$POD->getFile()

Loading Files

Creating Files

Errors

$POD->getFiles()

Parameters

Examples

$file->src()

$file->download()

$file->isImage()

README

Getting Started

Developing with PeoplePods

Tutorials

$POD->registerPOD()

Creating a new content type

Creating New Pods

Set Up Your New Pod

Settings.php

Index.php

Custom Template Files

Further Reading

Core Pods

Admin Tools

Installing PeoplePods

SDK Documentation

Core Concepts

Building New Functionality

Plugin Pods

Stand Alone Scripts

Hack Yourself Crazy

$Stack->sortBy()

$Stack->totalCount()

$Stack->count()