May 25th, 1993

Degree:

Computer Science

Expertise:

• (X)HTML
• CSS
• C
• Photoshop

Learning:

• PHP
• MySQL
• JavaScript

Biography:

Hi, I’m Matt Emond and I’m the newest addition to the Techranger Team! I am currently a first-year student at UCF majoring in Computer Science and am also an active member of the UCF Robotics Club. Currently I am most familiar with (X)HTML and CSS, and a fair bit of C from my programming classes. I am also an Adobe Certified Associate in Photoshop CS4 & CS5, Dreamweaver CS4 & CS5, and Flash CS4. My focus for the coming years is putting to use my current skills, and learning new ones! Specifically, I am interested in learning about PHP, MySQL, and JavaScript.

05/30/1992

Degree:

Computer Science

Expertise:

• HTML
• CSS
• Photoshop
• Also comfortable with Java

Learning:

• Javascript
• PHP

Part 1 – Creating a Messaging System

This tutorial is designed to introduce you to the Fuel PHP framework by walking you through the creation of a simple messaging app.

Requirements

First and foremost, here’s what you’re going to need:

1. Fuel PHP framework (we’re using v1.01)
2. XAMPP (if you’re having trouble installing this, go here for a tutorial)
3. PHP Environment Variables Configured in Windows (for command line executions)
4. phpMyAdmin (it comes with XAMPP)
5. A basic understanding of the Model-View-Controller (MVC) pattern.

Before You Get Started

Keep in mind that the completed source code for this tutorial is available from the Fuel Crash Course GitHub repository.

Getting Configged Up

Put the Fuel files into a folder called “fuel_intro” in the htdocs folder of xampp.

Go to http://localhost/fuel_intro/public and you should see the “Successful install” page from Fuel

For this tutorial we’re going to be using an orm package, included in your install of fuel. To enable packages, you have to add the package name it to the packages array in the config file. Mosey on over to /fuel/app/config/config.php and uncomment the ‘orm’ package to the package array.

		'packages'	=> array(
			'orm',
		),

After doing that, go to phpmyadmin (http://localhost/phpmyadmin) and create a database called “fuel_intro”. Leave this database blank for now, because we’re going to eventually unleash fuel on its emptiness.

Go into the /fuel/app/config/db.php file and fill out the following (this is assuming that you have a fresh install of XAMPP and you have not created or modified the default MySQL configuration):

return array(
	'active' => Config::get('environment'),
	Fuel::DEVELOPMENT => array(
		'type'			=> 'mysql',
		'connection'	=> array(
			'hostname'   => 'localhost',
			'database'   => 'fuel_dev',
			'username'   => 'root',
			'password'   => '',
			'persistent' => false,
		),
		'table_prefix' => '',
		'charset'      => 'utf8',
		'caching'      => false,
		'profiling'    => false,
	),

We renamed the database to “fuel_intro”, but left all the rest of the stuff as it was since the defaults will work fine for what we’re doing. Notice we’re only editing the Fuel::DEVELOPMENT environment and not touching Fuel::PRODUCTION.

Oil Slick

Fuel has a cool command line utility called Oil that lets you set up a lot of your controllers and tables automatically.

Bring up Command Prompt, type in the file path of your Fuel installation, and then run “php oil”. You should see a bit of oil usage documentation.

Seeing this means that Oil is successfully installed and working! Now let’s get to business.

Every Building Needs A Scaffold

Scaffolding in fuel allows you to quickly create a related controller, model (using ORM), and view for manipulating information.

What we want to end up with after creating the scaffold is a table with the following fields:

The ‘ID’, ‘created on’, and ‘updated on’ columns are made automatically, so all we have to tell oil to do is make the name and messages fields.

The only two weird things about this are the name of the scaffold has to be singular, and the “string” type for the name is a shortcut that is really var_char(255).

If you look at your document tree, you can see that the a controller, model, and view were created and populated with default content.

If you look at your database, you’ll notice that no table has been created, that’s because we need to migrate the database.

Migra-wha?

A migration is like a version control scheme for your database. If you open up the file /fuel/app/migrations/001_create_messages.php you can see what is going to be generated when the migration runs. Checking the file before you run the migration is a good idea, at least to check for typos.

<?php
namespace Fuel\Migrations;
class Create_messages {
	public function up()
	{
		\DBUtil::create_table('messages', array(
			'id' => array('constraint' => 11, 'type' => 'int', 'auto_increment' => true),
			'name' => array('constraint' => 255, 'type' => 'varchar'),
			'message' => array('type' => 'text'),
			'created_at' => array('constraint' => 11, 'type' => 'int'),
			'updated_at' => array('constraint' => 11, 'type' => 'int'),
		), array('id'));
	}
	public function down()
	{
		\DBUtil::drop_table('messages');
	}
}

Now that we know what the migration is going to create, go ahead and run it.

Now the table has been created, and you can add messages to it! Take a look at your database, you should see something like the screenshot from before.

Prettying Up The Code

Navigate to “http://localhost/fuel_intro/public/messages” and add a message.

If you look at the message, you’ll notice that all the layout is done using a table, so take a minute and make the code semantic.

Go into /fuel/app/views/messages/index.php and do the following:

Before:

<h2 class="first">Listing Messages</h2>
<table cellspacing="0">
	<tr>
		<th>Name</th>
		<th>Message</th>
		<th></th>
	</tr>
	<?php foreach ($messages as $message): ?>	<tr>
		<td><?php echo $message->name; ?></td>
		<td><?php echo $message->message; ?></td>
		<td>
			<?php echo Html::anchor('messages/view/'.$message->id, 'View'); ?> |
			<?php echo Html::anchor('messages/edit/'.$message->id, 'Edit'); ?> |
			<?php echo Html::anchor('messages/delete/'.$message->id, 'Delete', array('onclick' => "return confirm('Are you sure?')")); ?>		</td>
	</tr>
	<?php endforeach; ?></table>
<br />
<?php echo Html::anchor('messages/create', 'Add new Message'); ?>

After:

<h2 class="first">Listing Messages</h2>
	<ul>
	<?php foreach ($messages as $message): ?>
		<li><?php echo $message->name; ?>
			<ul>
				<li><?php echo $message->message; ?></li>
				<li><?php echo Html::anchor('messages/view/'.$message->id, 'View'); ?></li>
				<li><?php echo Html::anchor('messages/edit/'.$message->id, 'Edit'); ?></li>
				<li><?php echo Html::anchor('messages/delete/'.$message->id, 'Delete', array('onclick' => "return confirm('Are you sure?')")); ?></li>
			</ul>
		</li>
	<?php endforeach; ?>
	</ul>
<br />
<?php echo Html::anchor('messages/create', 'Add new Message'); ?>

Now your code is more semantic, if not more understandable (If you don’t like the bullets or the list view, you can take them away using CSS).

New Landing Page

Remember the successful install page you visited immediately after installing fuel? What you were seeing on that page comes from a view as well. Through routing, fuel can redirect the browser to display views outside of the default structure. These routing directions are stored in /fuel/app/config/routes.php.

By default there are two routes: the landing page and the 404 page.

<?php
return array(
	'_root_'  => 'welcome/index',  // The default route
	'_404_'   => 'welcome/404',    // The main 404 route
	/**
	 * This is an example of a BASIC named route (used in reverse routing).
	 * The translated route MUST come first, and the 'name' element must come
	 * after it.
	 */
	// 'foo/bar' => array('welcome/foo', 'name' => 'foo'),
);

What you need to do is have fuel redirect the browser to the messages view when going to http://localhost/fuel_intro/public instead of the successful install page. To do that, simply edit the value for the _root_ key like so:

return array(
	'_root_'  => 'messages/index',  // The default route

In the next section we will deal with creating comments for the messages.

• Continue to Part 2 »

Part 2 – Adding Comments

New Comments

Now that we have pretty semantic messages, we need to add a way for users to add comments to those messages.

The first step is to create our controllers and views for the comments. We will be using oil’s generate command again to do this. Let’s watch:

As you can see, a controller was generated called “comments” with the actions create and edit. Two views were also created, both associated with the comments controller (edit.php and create.php).

Open the controller and see what was made.

Controlling the Power

The comments controller should look like this:

<?php
class Controller_Comments extends Controller_Template {
	public function action_edit()
	{
		$this->template->title = 'Comments &raquo; Edit';
		$this->template->content = View::factory('comments/edit');
	}
	public function action_create()
	{
		$this->template->title = "Comments &raquo; Create";
		$this->template->content = View::factory('comments/create');
	}
}
/* End of file comments.php */

Defaults

The default class name for the controller is Controller_NAME, and the default actions are action_NAME. So if you’re making your own actions or controllers, you should follow the conventions that are set forth in this file.

Let’s go ahead and make a new action to illustrate this.

We want to create a controller that’s not associated with any view in order to handle deleting a comment. So, we would write the deletion function under the current actions:

		public function action_create()
		{
			$this->template->title = "Comments » Create";
			$this->template->content = View::factory('comments/create');
		}
		public function action_delete()
		{
		}

This controller isn’t going to have any code in it yet, we can save that for later.

Form Templates

If you look at the Messages views, you will see a file called “_form.php”. This is a form template that all of the views in messages can share by calling and is something that should be recreated for the comments views as well.

Go ahead and create /fuel/app/views/comments/_form.php.

First and foremost, you’re going to need to open a new form, and rather than using straight HTML, Fuel has classes for HTML elements. To open a new form you write:

<?php echo Form::open(); ?>

This is analogous to writing “<form action="http://localhost/fuel_intro/public/index.php/comments/create" accept-charset="utf-8" method="post">” so it’s a good idea to use these HTML elements when possible.

Next, create a name field for the comment:

<?php echo Form::open(); ?>
	<p>
		<?php echo Form::label('Name', 'name'); ?>
		<?php echo Form::input('name', Input::post('name', isset($comment) ? $comment->name : '')); ?>
	</p>

• Form::label() takes (in order) the text that will be displayed to the user, and the id which should match the name attribute of the input field.
• Form::input() takes (in order) the name attribute of the form and the default value of that form element.

You can repeat this code for the comment text as well. The only difference is that instead of Form::input, you’ll need to use Form::textarea(). Which takes in the same parameters.

<?php echo Form::open(); ?>
	<p>
		<?php echo Form::label('Name', 'name'); ?>
		<?php echo Form::input('name', Input::post('name', isset($comment) ? $comment->name : '')); ?>
	</p>
	<p>
		<?php echo Form::label('Comment', 'comment'); ?>
		<?php echo Form::textarea('comment', Input::post('comment', isset($comment) ? $comment->comment : ''), array('cols' => 60, 'rows' => 8)); ?>
	</p>

Did you notice the extra bit at the end? The last parameter for the label, input, or textarea tags is an array of attributes. So when we write “array('cols' => 60, 'rows' => 8));” at the end of the textarea function, it’s the same as saying “<textarea cols="60" rows="8"></textarea>“

Next we just need to add the submit button and close the form:

<?php echo Form::open(); ?>
	<p>
		<?php echo Form::label('Name', 'name'); ?>
		<?php echo Form::input('name', Input::post('name', isset($comment) ? $comment->name : '')); ?>
	</p>
	<p>
		<?php echo Form::label('Comment', 'comment'); ?>
		<?php echo Form::textarea('comment', Input::post('comment', isset($comment) ? $comment->comment : ''), array('cols' => 60, 'rows' => 8)); ?>
	</p>
	<?php echo Form::hidden('mid', Input::post('mid', isset($message) ? $message : '')); ?>
	<div class="actions">
		<?php echo Form::submit(); ?>	</div>
<?php echo Form::close(); ?>

Now open up fuel/app/views/comments/create.php, write the following:

<h2 class="first">New Comment</h2>
<?php echo render('comments/_form'); ?>
<p><?php echo Html::anchor('comments', 'Back'); ?></p>

Go to http://localhost/fuel_intro/public/comments/create/ and take a look at the form. You should see this:

Modeling

This is the easy part of the tutorial. All you need to do is run the following into command line for oil to use (make sure the model name is singular!):

This created comment.php in the fuel/app/classes/model folder. If you open up the file you should see something like this (it should be exactly like this, actually):

<?php
class Model_Comment extends Orm\Model {
	protected static $_observers = array(
		'Orm\Observer_CreatedAt' => array('before_insert'),
		'Orm\Observer_UpdatedAt' => array('before_save'),
	);
}
/* End of file comment.php */

Why It’s So Small

Notice that there’s not much code there? That’s because the comment model extends a class called ORM, or the Object-relational mapper. You can take a look at some of the more complicated things ORM can do, but for now we’re just going to stick to the defaults.

Since we made another model, we’re going to have to migrate to the newest version:

Quick Note: If an error is encountered when migrating, you can fix any typos in your migration file by going to /fuel/app/migrations/###_create_NAME.php and editing the file.

Adding to the Database

We can now edit the controller for comments to actually add our comments to the database. So go ahead and open the /fuel/app/classes/controller/comments.php file.

First and foremost, an $id variable is going to be taken in, so we need to add that as an attribute to the action_create function:

	public function action_create($id = null)
	{
		$this->template->title = "Comments";
		$this->template->content = View::factory('comments/create');
	}

Notice that we are setting the $id to null by default. Now we need to check to make sure that they’ve completed the form, so we add an if statement:

	public function action_create($id = null)
	{
		if (Input::method() == 'POST')
		{
		}
		$this->template->title = "Comments";
		$this->template->content = View::factory('comments/create');
	}

This is using Fuel’s Input class, but we could have just as easily used "if($_POST) {” as well.

But what about going to the form before submitting?

	public function action_create($id = null)
	{
		if (Input::method() == 'POST')
		{
		}
		else
		{
			$this->template->set_global('message', $id, false);
		}
		$this->template->title = "Comments";
		$this->template->content = View::factory('comments/create');
	}

This means if they didn’t post anything, take the $id and turn it into a variable called $message that the view can use.

Now we need to build what we need to from the Comment Model.

	public function action_create($id = null)
	{
		if (Input::method() == 'POST')
		{
			$comment = Model_Comment::factory(array(
				'name' => Input::post('name'),
				'comment' => Input::post('comment'),
				'mid' => Input::post('mid'),
			));
		}
		else
		{
			$this->template->set_global('message', $id, false);
		}
		$this->template->title = "Comments";
		$this->template->content = View::factory('comments/create');
	}

$comment is now an object that has the comment information in it, so we need to try and save the comment:

	public function action_create($id = null)
	{
		if (Input::method() == 'POST')
		{
			$comment = Model_Comment::factory(array(
				'name' => Input::post('name'),
				'comment' => Input::post('comment'),
				'mid' => Input::post('mid'),
			));
			if ($comment and $comment->save())
			{
			}
		}
		else
		{
			$this->template->set_global('message', $id, false);
		}
		$this->template->title = "Comments";
		$this->template->content = View::factory('comments/create');
	}

‘And’ is used here instead of ‘&’ because it’s part of the Fuel coding standards.

If the if statement is successful, it will save the comment to the database, so we should now set a flash to show that to the user. Session Flashes are for information with a limited lifespan, such as presenting success or failure information.

So we can set our flash and redirect them back to the message they were viewing:

	public function action_create($id = null)
	{
		if (Input::method() == 'POST')
		{
			$comment = Model_Comment::factory(array(
				'name' => Input::post('name'),
				'comment' => Input::post('comment'),
				'mid' => Input::post('mid'),
			));
			if ($comment and $comment->save())
			{
				Session::set_flash('notice', 'Added comment #' . $comment->id . '.');
				Response::redirect('messages/view/'.$id);
			}
		}
		else
		{
			$this->template->set_global('message', $id, false);
		}
		$this->template->title = "Comments";
		$this->template->content = View::factory('comments/create');
	}

or else we set the flash to say that the comment couldn’t be saved

	public function action_create($id = null)
	{
		if (Input::method() == 'POST')
		{
			$comment = Model_Comment::factory(array(
				'name' => Input::post('name'),
				'comment' => Input::post('comment'),
				'mid' => Input::post('mid'),
			));
			if ($comment and $comment->save())
			{
				Session::set_flash('notice', 'Added comment #' . $comment->id . '.');
				Response::redirect('messages/view/'.$id);
			}
			else
			{
				Session::set_flash('notice', 'Could not save comment.');
			}
		}
		else
		{
			$this->template->set_global('message', $id, false);
		}
		$this->template->title = "Comments";
		$this->template->content = View::factory('comments/create');
	}

Creating A Comment from A Message

Now we’re going to add a link to the view.php file in the messages view, so you can add a comment to that message.

Go to /fuel/app/views/messages/view.php and add:

<p>
	<strong>Name:</strong>
	<?php echo $message->name; ?></p>
<p>
	<strong>Message:</strong>
	<?php echo $message->message; ?></p>
<p><?php echo Html::anchor('comments/create/'.$message->id, 'Add new Comment'); ?></p>
<?php echo Html::anchor('messages/edit/'.$message->id, 'Edit'); ?> |
<?php echo Html::anchor('messages', 'Back'); ?>

Go ahead and add a comment so we can pull it up from the messages.

Now that we have a Comment…

Since there is a comment in the database now, we can add functions to the controller to manipulate that comment. First off, we need a way to be able to edit that comment in /fuel/app/classes/controller/comments.php.

The edit function will take in two parameters instead of just the one. It will take in the comment id and the message id.

	public function action_edit($id, $mid)
	{
		$this->template->title = 'Comments » Edit';
		$this->template->content = View::factory('comments/edit');
	}

Now we use the comment model to find the comment, based on it’s id

	public function action_edit($id, $mid)
	{
		$comment = Model_Comment::find($id);
		$this->template->title = 'Comments » Edit';
		$this->template->content = View::factory('comments/edit');
	}

The rest of the code is pretty much the same as creating a comment with a few minor tweaks, here it is in bulk:

	public function action_edit($id = null, $mid = null)
	{
		$comment = Model_Comment::find($id);
		if (Input::method() == 'POST')
		{
			$comment->name = Input::post('name');
			$comment->comment = Input::post('comment');
			$comment->mid = $mid;
			if ($comment->save())
			{
				Session::set_flash('notice', 'Updated comment #' . $id);
				Response::redirect('messages/view/'.$comment->mid);
			}
			else
			{
				Session::set_flash('notice', 'Could not update comment #' . $id);
			}
		}
		else
		{
			$this->template->set_global('comment', $comment, false);
		}
		$this->template->title = "Comments";
		$this->template->content = View::factory('comments/edit');
	}

The action $comment->save() will update the comment if it already exists in the database, or adds it if it doesn’t.

Deletion

Deleting the comment is just as easy as saving it, all you need to do is call $comment->delete() instead of $comment->save()

	public function action_delete($id, $mid)
	{
		if ($comment = Model_Comment::find($id))
		{
			$comment->delete();
			Session::set_flash('notice', 'Deleted comment #' . $id);
		}
		else
		{
			Session::set_flash('notice', 'Could not delete comment #' . $id);
		}
		Response::redirect('messages/view/'.$mid);
	}

For the next section we can accomplish two things, showing the number of comments that a message has, and showing the comments in a list when we view the message.

Number of Comments

Open up the messages controller (at this point you should probably be pretty good at navigating the file tree, so I’m going to stop giving you the path names to things we’ve already visited) and take a look at the index:

	public function action_index()
	{
		$data['messages'] = Model_Message::find('all');
		$this->template->title = "Messages";
		$this->template->content = View::factory('messages/index', $data);
	}

There’s not too much there except a command to find all the messages, which needs to be changed to $messages instead of $data['messages'].

Go to the top of the function and add this:

	public function action_index()
	{
		$view = View::factory('messages/index');
		$messages = Model_Message::find('all');
		$this->template->title = "Messages";
		$this->template->content = View::factory('messages/index', $data);
	}

That way we have an object for the view that we can set variables for, which will come later.

Just under the messages object we’re going to declare an array called $comments, and then loop through the messages object:

	public function action_index()
	{
		$view = View::factory('messages/index');
$messages = Model_Message::find('all');
		$comments = array();
		foreach ($messages as $message)
		{
		}
		$this->template->title = "Messages";
		$this->template->content = View::factory('messages/index', $data);
	}

We need to do a database call to get all of the comments associated with a particular message, so we call on the Comment_Model:

	public function action_index()
	{
		$view = View::factory('messages/index');
		$messages = Model_Message::find('all');
		$comments = array();
		foreach ($messages as $message)
		{
			$query = Model_Comment::find()->where("mid", $message['id']);
		}
		$this->template->title = "Messages";
		$this->template->content = View::factory('messages/index');
	}

This is analogous to “SELECT * FROM 'comments' WHERE mid = $message[id]“, but it’s an easier way to read it and it uses fuels built in classes.

Now we just need to count the number of results and add that number to the $comments array. For ease of parsing, we’re going to make the comment array key match the message id:

	public function action_index()
	{
		$view = View::factory('messages/index');
		$messages = Model_Message::find('all');
		$comments = array();
		foreach ($messages as $message)
		{
			$query = Model_Comment::find()->where("mid", $message['id']);
			$comments[$message['id']] = $query->count();
		}
		$this->template->title = "Messages";
		$this->template->content = View::factory('messages/index');
	}

The next bit is really for syntax purposes. If there is one comment display ’1 Comment’, no comments displays ‘View’, and more than one comment displays ‘# Comments’:

	public function action_index()
	{
		$view = View::factory('messages/index');
		$messages = Model_Message::find('all');
		$comments = array();
		foreach ($messages as $message)
		{
			$query = Model_Comment::find()->where("mid", $message['id']);
			$comments[$message['id']] = $query->count();
			if ($comments[$message['id']] == 1) {
				$comments[$message['id']] .= " Comment";
			}
			else if($comments[$message['id']] == 0)
			{
				$comments[$message['id']] = "View";
			}
			else {
				$comments[$message['id']] .= " Comments";
			}
		}
		$this->template->title = "Messages";
		$this->template->content = View::factory('messages/index');
	}

Now we just need to set the variables to the view (which is why we declared the view at the top of the function, and change the content to be the view object:

public function action_index()
	{
		$view = View::factory('messages/index');
		$messages = Model_Message::find('all');
		$comments = array();
		foreach ($messages as $message)
		{
			$query = Model_Comment::find()->where("mid", $message['id']);
			$comments[$message['id']] = $query->count();
			if ($comments[$message['id']] == 1) {
				$comments[$message['id']] .= " Comment";
			}
			else if($comments[$message['id']] == 0)
			{
				$comments[$message['id']] = "View";
			}
			else {
				$comments[$message['id']] .= " Comments";
			}
		}
		$view->set('comments', $comments);
		$view->set('messages', $messages);
		$this->template->title = "Messages";
		$this->template->content = $view;
	}

Now that we are passing the number of comments to the messages view, we need to modify the html to display it.

What we did was modify the “View” message link to include the number of comments, if any are present. At the moment, there shouldn’t be any.

Now if you go to http://localhost/fuel_intro/public/index.php/messages/ you should see the number of comments each message has.

Showing the Comments

To actually show the comments for each view, you need to get all the comments associated with a message in the messages controller:

public function action_view($id = NULL)
	{
		$data['message'] = Model_Message::find($id);
		$comments = Model_Comment::find()->where('mid', $id)->get();
		$data['comments'] = $comments;
		$this->template->title = "Message";
		$this->template->content = View::factory('messages/view', $data);
	}

The ->get() command returns the comments associated with the message as an object, which is passed to the view when added to the $data array.

Now all we need to do is show it on the view.php page of the message views:

	<strong>Message:</strong>
	<?php echo $message->message; ?></p>
<h3>Comments</h3>
<ul>
<?php
foreach ($comments as $comment) {  ?>
	<li>
		<ul>
			<li><strong>Name:</strong> <?php echo $comment->name; ?></li>
			<li><strong>Comment:</strong><br /><?php echo $comment->comment; ?></li>
			<li><p><?php echo Html::anchor('comments/edit/'.$comment->id.'/'.$message->id, 'Edit'); ?>|
	<?php echo Html::anchor('comments/delete/'.$comment->id.'/'.$message->id, 'Delete', array('onclick' => "return confirm('Are you sure?')")); ?></li>
		</ul>
	</li>
<?php } ?>
</ul>

The final section will deal with Logging and and creating users.

• « Back to Part 1
• Continue to Part 3 »

Part 3 – Adding a Login System

Creating Users and Login

Now that we’ve done messages and comments, we don’t want just anyone to be able to edit/delete messages, and it would be nice if messages were associated with some kind of username, so we’re going to make a simple and generic user system for our messages.

First add the ‘auth’ package to the package list in the config file

		'packages'	=> array(
			'orm',
			'auth',
		),

Then we need to create a controller for our login:

Notice that we used ‘g’ instead of ‘generate’, Oil has a lot of short tags that we can now use because you’re familiar with the long way to do it.

Now we need to build the models:

The only thing that should be explained on this line is groups. Here’s the default group number definitions:

-1 =

Banned

0 =

Guests

1 =

Users

50 =

Moderators

100 =

Administrators

This way you can check a users access in bulk, like people below this number can’t access something.

Finally, migrate to the new version (using the short tag “r” instead of “refine”).

Changing the Defualt Table

The auth package is expecting a table called “simpleusers” created to base it’s database controls on, but we named ours “users”. So, we’re going to change their default rather than change our table.

/fuel/packages/auth/config/simpleauth.php:

	/**
	 * DB table name for the user table
	 */
	'table_name' => 'users', // Old: 'table_name' => 'simpleusers',

Registration

Now that we have a model, controller, and views, we need to add a link to the registration so people can actually sign up! Since this should be on the top of all the pages, we need to edit the template page for the entire site. So go to /fuel/app/views/template.php and add the following:

<body>
	<div id="wrapper">
		<h1><?php echo $title; ?></h1>
		<?php
			if(isset($user_info))
			{
				echo $user_info;
			}
			else
			{
				$link = array(Html::anchor('users/login', 'Login'), Html::anchor('users/register', 'Register'));
				echo Html::ul($link);
			}
			echo $content;
		?>

This checks to see if a user is logged in (we’ll call the object with the user’s info in it $user_info), if they’re not logged in, then it builds an unordered list that links to a registration page.

Registration Model

We’re going to create the registration form using the model and passing it with the controller. Create a function at the bottom of the users model. It’s going to have and empty form passed into it, and this form will be a Fieldset, which is kind of like a form that has validation attached to it:

<?php
class Model_User extends Orm\Model {
	protected static $_observers = array(
		'Orm\Observer_CreatedAt' => array('before_insert'),
		'Orm\Observer_UpdatedAt' => array('before_save'),
	);
	public static function register(Fieldset $form)
	{
	}
}

Now we need to attach fields to this form, and send it back to the controller.

	public static function register(Fieldset $form)
	{
		$form->add('username', 'Username:')->add_rule('required');
		$form->add('password', 'Choose Password:', array('type'=>'password'))->add_rule('required');
		$form->add('password2', 'Re-type Password:', array('type' => 'password'));
		$form->add('email', 'Email:')->add_rule('required')->add_rule('valid_email');
		$form->add('submit', ' ', array('type'=>'submit', 'value' => 'Register'));
		return $form;
	}

The add() function adds a certain field with the field’s name, label, and attributes in that order. The add_rule() function adds a validation rule to the field. All the rules available by default can be found here: http://fuelphp.com/docs/classes/validation/validation.html#rules_table.

User Controller Registration Function

Now we’re going to go to the action_register function within the user controller.

We are going to change it from this:

public function action_register()
{
	$this->template->title = 'Users » Register';
	$this->template->content = View::factory('users/register');
}

To this:

	public function action_register() {
		$auth = Auth::instance();
		$view = View::factory('users/register');
		$form = Fieldset::factory('register');
		Model_User::register($form);
	}

$auth is going to be our way of Authenticating users, $view is the view that will be passed to the user, $form is the fieldset that we’re sending to the model. Model_User::register($form) just populates the form with the fields.

If we build the form in the view, we can see how this will work:

	public function action_register()
	{
		$auth = Auth::instance();
		$view = View::factory('users/register');
		$form = Fieldset::factory('register');
		Model_User::register($form);
		$view->set('reg', $form->build(), false);
		$this->template->title = 'User » Register';
		$this->template->content = $view;
	}

Then go to the register view and add:

<?php echo $reg; ?>

Once you do this, you should see the registration form if you go to http://localhost/fuel_intro/public/index.php/users/register.

Validating the Registration

Now what happens when someone actually fills out the form? We need to have their registration validated. So we need to repopulate the form field with the values that the user typed in, and then send the whole form and authentication to a validation controller:

		Model_User::register($form);
		if($_POST)
		{
			$form->repopulate();
			$result = Model_User::validate_registration($form, $auth);
		}
		$view->set('reg', $form->build(), false);
		$this->template->title = 'User » Register';
		$this->template->content = $view;
	}

On the model side it needs to take in the form and authentication:

	public function validate_registration(Fieldset $form, $auth)
	{
	}
}
/* End of file user.php */

Then we need to add a rule to the password field that it must match what the user has typed in for the password2 field:

public function validate_registration(Fieldset $form, $auth)
{
	$form->field('password')->add_rule('match_value', $form->field('password2')->get_attribute('value'));
}

And now we need to create a validation object and set messages to display what we want if the user enters in something incorrectly:

public function validate_registration(Fieldset $form, $auth)
{
$form->field('password')->add_rule('match_value', $form->field('password2')->get_attribute('value'));
	$val = $form->validation();
	$val->set_message('required', 'The field :field is required');
	$val->set_message('valid_email', 'The field :field must be an email address');
	$val->set_message('match_value', 'The passwords must match');

For a full explanation of the set message feature, look at Fuel’s documentation on error messages.

Next, we try to run the validation to see if it passes or fails

public function validate_registration(Fieldset $form, $auth)
{
$form->field('password')->add_rule('match_value', $form->field('password2')->get_attribute('value'));
	$val = $form->validation();
	$val->set_message('required', 'The field :field is required');
	$val->set_message('valid_email', 'The field :field must be an email address');
	$val->set_message('match_value', 'The passwords must match');
	if($val->run())
	{
	}
	else
	{
		$errors = $val->show_errors();
		return array('e_found' => true, 'errors' => $errors);
	}

So, if the validation doesn’t pass, the show_errors() function turns the errors into an HTML list, and we return that and a Boolean saying that errors were found.

What if they Pass?

If the user passes validation, then we get their username, password, and email from the form:

if($val->run())
{
	$username = $form->field('username')->get_attribute('value');
	$password = $form->field('password')->get_attribute('value');
	$email = $form->field('email')->get_attribute('value');
}

Try to create the user in the database:

if($val->run())
{
	$username = $form->field('username')->get_attribute('value');
	$password = $form->field('password')->get_attribute('value');
	$email = $form->field('email')->get_attribute('value');
	try
	{
		$user = $auth->create_user($username, $password, $email);
	}

And catch an errors if we find them:

if($val->run())
{
	$username = $form->field('username')->get_attribute('value');
	$password = $form->field('password')->get_attribute('value');
	$email = $form->field('email')->get_attribute('value');
	try
	{
		$user = $auth->create_user($username, $password, $email);
	}
	catch (Exception $e)
	{
		$error = $e->getMessage();
	}

We’re going to be nice here and log the user in once they register, so if they $user object is present, we can use the $auth object we passed in to log the person in:

if($val->run())
{
	$username = $form->field('username')->get_attribute('value');
	$password = $form->field('password')->get_attribute('value');
	$email = $form->field('email')->get_attribute('value');
	try
	{
		$user = $auth->create_user($username, $password, $email);
	}
	catch (Exception $e)
	{
		$error = $e->getMessage();
	}
	if(isset($user))
	{
		$auth->login($username, $password);
	}

And if the login didn’t work, then we can create an unordered list and return both that and the error’s found array:

public function validate_registration(Fieldset $form, $auth)
{
$form->field('password')->add_rule('match_value', $form->field('password2')->get_attribute('value'));
	$val = $form->validation();
	$val->set_message('required', 'The field :field is required');
	$val->set_message('valid_email', 'The field :field must be an email address');
	$val->set_message('match_value', 'The passwords must match');
if($val->run())
{
	$username = $form->field('username')->get_attribute('value');
	$password = $form->field('password')->get_attribute('value');
	$email = $form->field('email')->get_attribute('value');
	try
	{
		$user = $auth->create_user($username, $password, $email);
	}
	catch (Exception $e)
	{
		$error = $e->getMessage();
	}
	if(isset($user))
	{
		$auth->login($username, $password);
	}
	else
	{
		if(isset($error))
		{
			$li = $error;
		}
		else {
			$li = 'Something went wrong with creating the user!';
		}
		$errors = Html::ul(array($li));
		return array('e_found' => true, 'errors' => $errors);
	}
}
else
{
	$errors = $val->show_errors();
	return array('e_found' => true, 'errors' => $errors);
}
}

Two more things to do. First, go to action_register() on the users controller and and add a check for errors, if there are no errors found, log the user in and redirect to the homepage:

if($_POST)
	{
		$form->repopulate();
		$result = Model_User::validate_registration($form, $auth);
		if($result['e_found'])
		{
			$view->set('errors', $result['errors'], false);
		}
		else
		{
			Session::set_flash('notice', 'User created.');
			Response::redirect('./');
		}
	}

Second, go to the register view and check for errors:

	<?php if(isset($errors)){echo $errors;}?>
	<?php echo $reg; ?>

There, now you should be able to register and be logged in automatically.

Regular Logging In and Out

Based on what we’ve done so far, I should be able to just give you the code for this and you can understand it:

Users Controller:

	public function action_login()
	{
		$view = View::factory('users/login');
		$form = Form::factory('login');
		$auth = Auth::instance();
		$form->add('username', 'Username:');
		$form->add('password', 'Password:', array('type' => 'password'));
		$form->add('submit', ' ', array('type' => 'submit', 'value' => 'Login'));
		if($_POST)
		{
			if($auth->login(Input::post('username'), Input::post('password')))
			{
				Session::set_flash('notice', 'Successfully logged in! Welcome '.$auth->get_screen_name());
				Response::redirect('messages/');
			}
			else
			{
				Session::set_flash('notice', 'Username or password incorrect.');
			}
		}
		$view->set('form', $form, false);
		$this->template->title = 'User » Login';
		$this->template->content = $view;
	}
	public function action_logout()
	{
		$auth = Auth::instance();
		$auth->logout();
		Session::set_flash('notice', 'Logged out.');
		Response::redirect('messages/');
	}

Don’t forget to echo the form in the login view!

Finishing Touches

Now we just need to add the name of the person making the message (instead of letting them type it in themselves), and give them editing rights to their own posts.

Go to the _form.php files in both the comments and the messages and replace the name input field with the user’s name:

From this:

<?php echo Form::open(); ?>
	<p>
		<?php echo Form::label('Name', 'name'); ?>
<?php echo Form::input('name', Input::post('name', isset($message) ? $message->name : '')); ?>
	</p>

To this:

<?php echo Form::open(); ?>
	<p>
		<?php echo 'Name: '.Auth::instance()->get_screen_name(); ?>
	</p>

And this:

<?php echo Form::open(); ?>
	<p>
		<?php echo Form::label('Name', 'name'); ?>
		<?php echo Form::input('name', Input::post('name', isset($comment) ? $comment->name : '')); ?>
	</p>

To this:

<?php echo Form::open(); ?>
	<p>
		<?php echo 'Name: '.Auth::instance()->get_screen_name(); ?>
	</p>

And on the message & comment controllers replace the posted name with the user name:

	'name' => Auth::instance()->get_screen_name(), //Old: 'name' => Input::post('name'),

Now, go the the message view and check to see if the person looking at the post is the person who created it, and give them editing/deletion right:

<p>
	<strong>Name:</strong>
	<?php echo $message->name; ?></p>
<p>
	<strong>Message:</strong>
	<?php echo $message->message; ?></p>
<?php if($message->name == Auth::instance()->get_screen_name()) {?>
	<p><?php echo Html::anchor('messages/edit/'.$message->id, 'Edit'); ?> |
		<?php echo Html::anchor('messages/delete/'.$message->id, 'Delete', array('onclick' => "return confirm('Are you sure?')")); ?>
	</p>
<?php } ?>
<?php echo Html::anchor('messages', 'Back'); ?>
<p><?php echo Html::anchor('comments/create/'.$message->id, 'Add new Comment'); ?></p>

And then in the list under the comment:

	<?php if($comment->name == Auth::instance()->get_screen_name()) {?>
	<li><p><?php echo Html::anchor('comments/edit/'.$comment->id.'/'.$message->id, 'Edit'); ?>|
<?php echo Html::anchor('comments/delete/'.$comment->id.'/'.$message->id, 'Delete', array('onclick' => "return confirm('Are you sure?')")); ?></li>
	<?php } ?>

This is the Last Thing, I promise

The very last thing we’re going to do is to check if they user is logged in. If they are, allow them to make a message or comment.

Near the bottom of the message view that we were last on:

<?php if(Auth::instance()->check()) { ?>
<p><?php echo Html::anchor('comments/create/'.$message->id, 'Add new Comment'); ?></p>
<?php } ?>

At the bottom of the message’s index view:

<?php if(Auth::instance()->check()) {
 echo Html::anchor('messages/create', 'Add new Message');
}?>

Finished!

Congratulations! You now have a working understanding of Fuel and have this neat little messaging system!

• « Back to Part 2
• Back to Tutorials

October 13th

Degree:

Computer Engineering B.S.

Expertise:

• XHTML
• PHP
• MySQL
• Flash/Actionscript 2
• Audio/Video Editing

Not exactly an expert with:

• jQuery/Javascript
• Python/Django
• CSS
• Photoshop

Biography:

I started my career with CDL’s own New Media team developing custom Flash pieces and PHP-based web applications. After graduating in 2006, I spent a few years in private industry doing web development, marketing, and multimedia development. I have returned to UCF to become the Techrangers Team Lead. I enjoy photography, marksmanship, playing video games, and being a know-it-all.

• January 8th

Degree:

• Digital Media

Expertise:

• XHTML
• CSS

Learning:

• JavaScript
• PHP
• Flash

Biography: I’m a UCF senior seeking a degree in Digital Media.  When I’m not working, I like to play and listen to music, bike, play videogames, and hang out with my friends.

This workshop held by the Center for Distributed Learning Techrangers focused on accessibility and how content creators can ensure their online material is accessible to all users, including those with disabilities.

Section 508 requires that Federal agencies’ electronic and information technology is accessible to people with disabilities (See: Section508.gov). The Techrangers will walk UCF staff and faculty through analyzing and applying Section 508 compliance to online documents. There are a lot of simple principles you can apply to make your content as accessible as possible.

FLYER

This is a workshop for UCF staff and faculty only, we hope to open this up to the rest of the UCF community at a later time.

Participants will need to know basic HTML to fully participate in this workshop. Bring your laptop, if possible!

In the PowerPoint presentation (linked below), there are techniques, tips, and resources available on how to be the most effective moderator.

Web Usability Training Power Point.

This workshop held by the Center for Distributed Learning Techrangers will focus on accessibility and how content creators can ensure their online material is accessible to all users, including those with disabilities.

Section 508 requires that Federal agencies’ electronic and information technology is accessible to people with disabilities (See: Section508.gov).  The Techrangers will walk UCF staff and faculty through analyzing and applying Section 508 compliance to online documents.  There are a lot of simple principles you can apply to make your content as accessible as possible.

FLYER

This is a workshop for UCF staff and faculty only, we hope to open this up to the rest of the UCF community at a later time.

Participants will need to know basic HTML to fully participate in this workshop. Bring your laptop, if possible!