The CakePHP welcome page gives little clues as to the power that it provides – you need to get stuck in.

CakePHP requires very little to get up and going. You will need a web server, such as Apache, PHP 4+ (preferably 5+), MySQL 4+ and an editor of your choice. At the time of writing the latest release of CakePHP is v1.3.8.

You can download the latest from http://github.com/cakephp/cakephp/downloads as a compressed release, or use Git to clone the repository: http://github.com/cakephp/cakephp. Once downloaded or cloned, place the contents of the cakephp package into your document root. Once completed, you should have a docroot /directory containing the folders /app, /cake, /plugins and /vendors and the files .htaccess, index.php and README.

Set up the database

The next step is to set up a database. We’re using MySQL, as it’s the most common of the free database engines available, so go ahead and do:le for the movie application:

CREATE DATABASE linux_format_tutorial;
CREATE TABLE `movies` (
  `id` CHAR(36) NOT NULL PRIMARY KEY,
  `title` VARCHAR(255),
  `genre` VARCHAR(45),
  `rating` VARCHAR(45),
  `format` VARCHAR(45),
  `length` VARCHAR(45),
  `created` DATETIME,
  `modified` DATETIME
);

Sure, it’s a simple table, but it’s all we need to get the basic information stored and a working application as a result.

Note we’ve used a CHAR(36) field for the ID of each record in the database. CakePHP identifies this, and when storing new records it generates and stores a UUID rather than a numeric ID. This is a handy habit to get into, as it makes it easier to merge data from various databases later. This is one of the convention-based approaches of CakePHP in its ‘Convention over Configuration’ approach to application development.

Another example of this approach can be seen in the created and modified fields in the table. You don’t need to implement any of your own code to enable created to be populated with the correct date and time for each record when it is created, nor do you need to implement any code for the modified field. CakePHP jumps into action and takes care of this for you, making your application remarkably quick and easy to build.

Because we’re using the field name title for the movie title, which matches one of the default column names for CakePHP record-name identifiers, we see more magic as CakePHP automatically uses this field to display the name for records in lists etc. Create the table before moving on to the next step.

Set up the database connection

Getting the database configured in CakePHP is easy. There’s a sample database configuration ready for you at /app/config/database.php.default. The quickest way to get going is to create a copy of this file at /app/config/database.php. Edit the file copy you have created to contain credentials that match your database connection. For this application, you just need to configure the $default connection. It should look similar to the following:

var $default = array(
	‘driver’ => ‘mysql’,
	‘persistent’ => ‘false’,
	‘host’ => ‘localhost’,
	‘port’ => ‘’,
	‘login’ => ‘username’,
	‘password’ => ‘password’,
	‘database’ => ‘linux_format_tutorial’,
	‘schema’ => ‘’,
	‘prefix’ => ‘’,
	‘encoding’ => ‘’
);

You can now load the CakePHP welcome page by browsing to the location you set up on your server. You will notice a number of green bars indicating the successful setup of CakePHP. If you have any configuration issues, these green bars will appear in yellow, and will provide a detailed error message to help you solve the problem. For the purposes of this application, you an ignore any information about the Security Salt, or Cipher Key warnings on the CakePHP welcome page, as they are not required for this application.

Let’s start coding in earnest by creating MoviesController in /app/controllers/movies_controller.php.

class MoviesController extends AppController {
	public $components = array(‘Session’);
}

We have included a Session component here to handle error messages from page to page.

One by one we’ll create actions that will be available to users browsing your movie database. Actions are publicly accessible functions on a controller. For all the operations we want to perform on a movie in our movie database, we’ll create the CRUD actions on the Movies controller. CRUD is an acronym for: Create, Read, Update and Delete. Our actions will be named: index, add, edit, view and delete.

Let’s start with the index action, which will list all the movies in the database. The controller has an instance object called Movie, which is a model. It’s automatically included by CakePHP to match the controller name. We can call find() on this model and CakePHP converts those calls into database queries, meaning we don’t have to write a single line of SQL to retrieve data. Awesome! Below we call the find() method with the type all, and make the result available for the view to display.

class MoviesController extends AppController {
	public $components = array(‘Session’);
	public function index() {
		$movies = $this->Movie->find(‘all’);
		$this->set(‘movies’, $movies);
	}
}

That’s all we need for the index action. I know it looks simple, but that’s the beauty of CakePHP – there’s no point overcomplicating things.

Create your first view

With the action complete on the controller, its time to create the view so we can see the data and interact with it. Views in CakePHP are simple PHP files with a ctp file extension. You can use regular old PHP in your view files.

The movie list

Create your first view in /app/views/movies/index.ctp. You will need to create the directory movies under the /app/views directory first. Add the following code:

<div>
	<h2>Movies</h2>
	<table cellpadding="0" cellspacing="0">
		<tr>
			<th>Title</th>
			<th>Genre</th>
			<th>Rating</th>
			<th>Format</th>
			<th>Length</th>
			<th>Actions</th>
		</tr>
	<?php foreach ($movies as $movie): ?>
	<tr>
		<td><?php echo $movie['Movie']['title']; ?> </td>
		<td><?php echo $movie['Movie']['genre']; ?> </td>
		<td><?php echo $movie['Movie']['rating']; ?> </td>
		<td><?php echo $movie['Movie']['format']; ?> </td>
		<td><?php echo $movie['Movie']['length']; ?> </td>
		<td>
			<?php echo $this->Html->link('View',
array('action' => 'view', $movie['Movie']['id'])); ?>
			<?php echo $this->Html->link('Edit',
array('action' => 'edit', $movie['Movie']['id'])); ?>
			<?php echo $this->Html->link('Delete',
array('action' => 'delete', $movie['Movie']['id']),
null, sprintf('Are you sure you want to delete %s?', $movie['Movie']['title'])); ?>
		</td>
	</tr>
	<?php endforeach; ?>
	</table>
</div>
<div>
	<h3>Actions</h3>
	<ul>
		<li><?php echo $this->Html->link('New Movie', array('action' => 'add')); ?></li>
	</ul>
</div>

This will look familiar to anyone who has used HTML and PHP previously. What differs is the use of CakePHP view helpers to output information such as links. The HTML helper allows us to pass array-based information for the View, Edit and Delete actions. These are transformed into URLs such as: http://mysite.com/movies/view/1234 (in the case of a view link).

The view iterates over the $movies variable, which was set by the MoviesController earlier, and outputs all of the entries in a table (this is tabular data, after all).

You can now browse to the /movies/index URL on your server and see the output from your new view. If you have set up the server to host only the CakePHP application we are developing, you can browse to your site address as follows: http://mysite.com/movies/index. Or, if you have set up this CakePHP application in a subdirectory, simply browse to that directory on your server: http://mysite.com/my_directory/movies/index.

For the moment there are no movies in the database. Let’s push on to create the movie addition functionality. We’re on the clock here!

Create the add action and view

Next we’ll build on our existing movies controller to include an add action. It will be used to process the addition of new movies to the database. We need to check to see if any form data has ben submitted, and if so, process that information and store it after checking for errors. That sounds like a lot to achieve, but CakePHP makes it easy, as you can see in the following listing:

class MoviesController extends AppController {
	// .. components ..
	// .. index action ..

	public function add() {
		if (!empty($this->data)) {
			$this->Movie->create($this->data);
			if ($this->Movie->save()) {
				$this->Session->setFlash('The movie has been saved');
				$this->redirect(array('action' => 'index'));
			} else {
				$this->Session->setFlash
('The movie could not be saved. Please, try again.');
			}
		}
	}
}

Adding a movie with the Add view. Yes it’s simple, but the cool this is that it took so little code to produce.

The add view takes advantage of the CakePHP form helper, which makes light work of generating forms for all types of situations. Here we simply define what model we’re creating a form for (in this case, the Movie model), and what fields we want available to the users.

Create the following in /app/views/movies/add.ctp:

<div class=”movies form”>
<?php
echo $this->Form->create(‘Movie’);
echo $this->Form->inputs(array(‘title’, ‘genre’, ‘rating’, ‘format’, ‘length’));
echo $this->Form->end(‘Add’);
?>
</div>

<div class=”actions”>
	<h3>Actions</h3>
	<ul>
		<li><?php echo $this->Html->link(‘List Movies’, array(‘action’ => ‘index’));?></li>
	</ul>
</div>

The real form creation power of this view file is achieved in the three PHP echo lines at the top. The rest is HTML layout and a link to go back to the list of movies. You’re now able to view the CakePHP ‘movie add’ form by visiting the /movies/add URL, or by clicking on the New Movie link we added to the movie index page.

Brilliant! Now you can go ahead and add a couple of movies. The example in the next screenshot is adding Spider-Man 3 in Blu-ray format. As you add each entry, you are redirected back to the index view, which will show each new movie as it is added to the database.

Enable movie deletion

Perhaps you added a movie that you no longer have, or otherwise want to remove an entry from your database. We’ve created links in the views already that point to a delete action, so we’ll implement that one. The delete action does not require a view, as we don’t require any output as part of the process. The action will process the deletion, and then immediately redirect with an appropriate message.

Add the delete action to your Movies controller:

class MoviesController extends AppController {
	// .. components ..
	// .. index action ..
	// .. add action ..
	public function delete($id = null) {
		if (!$id) {
			$this->Session->setFlash(‘Invalid id for movie’);
			$this->redirect(array(‘action’ => ‘index’));
		}
		if ($this->Movie->delete($id)) {
			$this->Session->setFlash(‘Movie deleted’);
		} else {
			$this->Session->setFlash(__(‘Movie was not deleted’,
 true));
		}
		$this->redirect(array(‘action’ => ‘index’));
	}
}

We’ve already added ‘delete’ links to the index page in the previous steps. You can now remove entries from your database using the delete links! You will notice that on our index action, the code to implement the delete link was longer than the View and Edit actions. This is because we included a JavaScript alert mechanism to make sure that the user really wanted to delete that record. This is a safety mechanism to give the user a chance to back out, as there is no view associated with the action to prevent an accidental deletion.

We’ve added a delete confirmation box

<?php echo $this->Html->link(‘Delete’, array(‘action’ =>
 ‘delete’, $movie[‘Movie’][‘id’]), null,
sprintf(‘Are you sure you want to delete %s?’, $movie[‘Movie’][‘title’])); ?>

Editing your data

Even the best of us makes mistakes, so it’s a good idea to have an edit action available to jump in and correct any issues or changes with records as necessary. This action is very similar to the add action, with the main difference being the management of the existing record ID. In fact, they are so similar that seasoned CakePHP developers will combine the add and edit actions into a single action. Here’s the code:

class MoviesController extends AppController {
	// .. components ..
	// .. index action ..
	// .. add action ..
	// .. delete action ..

	function edit($id = null) {
		if (!$id && empty($this->data)) {
			$this->Session->setFlash('Invalid movie');
			$this->redirect(array('action' => 'index'));
		}
		if (!empty($this->data)) {
			if ($this->Movie->save($this->data)) {
				$this->Session->setFlash('The movie has been saved');
				$this->redirect(array('action' => 'index'));
			} else {
				$this->Session->setFlash('The movie could not be saved. Please, try again.');
			}
		}
		if (empty($this->data)) {
			$this->data = $this->Movie->read(null, $id);
		}
	}
}

The main difference between the add and edit actions is that the edit action passes an ID to the action, and does not call the create() method on the Movie object. This is because it needs to retain any existing data for the record when saving to the database.

Creating your edit view

It should all be looking familiar by now. The edit view we’re about to create looks almost identical to the add form. Again, developers that have been exposed to CakePHP for some time will integrate the add and edit form to save repeating code. The only difference is the inclusion of an input for the id field in the form, and the label on the submit button.

Create the following in /app/views/movies/edit.ctp:

<div class=”movies form”>
<?php
echo $this->Form->create(‘Movie’);
echo $this->Form->inputs(array(‘id’, ‘title’, ‘genre’, ‘rating’, ‘format’, ‘length’));
echo $this->Form->end(‘Edit’);
?>
</div>
<div class=”actions”>
	<h3>Actions</h3>
	<ul>
		<li><?php echo $this->Html->link(‘List Movies’,
array(‘action’ => ‘index’));?></li>
	</ul>
</div>

The movie detal view.

Save your view.

Time to take it for a test drive. Load up your index action in your browser as before, and click through to the edit action of one of your movies. You will be presented with a screen that contains all the inputs and data for your record. Note that the id field is not shown. This is included as a hidden field, so the user cannot tamper with this information. Our final controller action and view will provide a detail view of each movie. It will contain all the information we didn’t show in the index view such as ‘created’ and ‘modified’ times. When browsing to the view action, an ID is passed in the URL to indicate what movie ID we want to view. Add the following view action to your Movies controller:

class MoviesController extends AppController {
	// .. components ..
	// .. index action ..
	// .. add action ..
	// .. delete action ..
	// .. edit action ..

	function view($id = null) {
		if (!$id) {
			$this->Session->setFlash(‘Invalid movie’);
			$this->redirect(array(‘action’ => ‘index’));
		}
		$this->set(‘movie’, $this->Movie->findById($id));
	}
}

Create the detail view

Our last view is a simple table displaying all the movie information. Create this view in the following location: /app/views/movies/view.ctp – here’s the the code:

<div>
<h2>Movie</h2>
	<dl>
		<dt>Title</dt>
		<dd><?php echo $movie['Movie']['title']; ?></dd>
		<dt>Genre</dt>
		<dd><?php echo $movie['Movie']['genre']; ?></dd>
		<dt>Rating</dt>
		<dd><?php echo $movie['Movie']['rating']; ?></dd>
		<dt>Format</dt>
		<dd><?php echo $movie['Movie']['format']; ?></dd>
		<dt>Length</dt>
		<dd><?php echo $movie['Movie']['length']; ?></dd>
		<dt>Created</dt>
		<dd><?php echo $movie['Movie']['created']; ?></dd>
		<dt>Modified</dt>
		<dd><?php echo $movie['Movie']['modified']; ?></dd>
	</dl>
</div>

<div>
	<h3>Actions</h3>
	<ul>
		<li><?php echo $this->Html->link
('Edit Movie', array('action' => 'edit', $movie['Movie']['id'])); ?> </li>
		<li><?php echo $this->Html->link
('Delete Movie', array('action' => 'delete', $movie['Movie']['id']),
null, sprintf('Are you sure you want to delete # %s?', $movie['Movie']['id'])); ?> </li>
		<li><?php echo $this->Html->link
('List Movies', array('action' => 'index')); ?> </li>
		<li><?php echo $this->Html->link
('New Movie', array('action' => 'add')); ?> </li>
	</ul>
</div>

The last action we linked on the index page is now operational! Click through the ‘view’ link on one of the movies in your database to see the result of the detail view we have just created. Notice that it also includes a useful list of relevant actions for the current record.

As you edit information and create new records, you’ll see the created and modified fields for those records being updated by CakePHP for you. This is part of the automatic functionality that the framework provides. Edit a couple of records to see these fields change.

Where to now?

You now have a completely functional movie database application that you can host at home, or online. All in under 20 minutes. The next big issue you face is what you are going to do with all your spare time now that CakePHP is doing all the heavy lifting. Good luck, and be sure to let us know what you do with CakePHP at www.linuxformat.com/forums – whatever you do, I hope you save lots of precious time!

We’ll be following this up with more CakePHP tutorials soon – stay tuned!

For each file, we want to associate it with a user for ownership, but we also want to be able to associate it with many other users for sharing (read access). So we need to define two separate associations from file to user. We’re going to manage the sharing access with an association called “Has and belongs to many” or HABTM for short. HABTM utilises a join table to associate the two records, and has a standard within CakePHP that we’ll follow so the framework can do all the heavy lifting for us:

CREATE DATABASE `fileshare`;
USE `fileshare`;

CREATE TABLE `uploads` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`user_id` CHAR(36) NOT NULL,
	`title` VARCHAR(45) NOT NULL,
	`description` TEXT,
	`filename` VARCHAR(255) NOT NULL,
	`filesize` INT(11) UNSIGNED NOT NULL DEFAULT 0,
	`filemime` VARCHAR(45) NOT NULL DEFAULT 'text/plain',
	`created` DATETIME,
	`modified` DATETIME
);

CREATE TABLE `users` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`username` VARCHAR(45) NOT NULL,
	`password` VARCHAR(255) NOT NULL,
	`email` VARCHAR(255) NOT NULL,
	`created` DATETIME,
	`modified` DATETIME
);

The join table we mentioned identifies users that have been allowed access to specified files. The standards specify that a join table for a HABTM association is to be the tables in their plural form, joined with an underscore and listed in alphabetical order:

CREATE TABLE `uploads_users` (
  `id` CHAR(36) NOT NULL PRIMARY KEY,
  `upload_id` CHAR(36) NOT NULL,
  `user_id` CHAR(36) NOT NULL
);

Create your tables in a new database, and we’ll push on to baking the project and getting the basics running.

Ready, set… bake!

Bake is a special console command that ships with CakePHP, and is run from the console. In order for this to work effectively the cake/console path within the CakePHP package needs to be in your PATH environment variable. You can achieve this with the following in your shell: $ export PATH=”$PATH:/path/to/cakephp/cake/console” And of course you’ll need PHP available on the command line (usually available in a php-cli package, or similar). To create the skeleton structure for your project, run the following in your shell:

$ cake bake project fileshare
$ cd fileshare

Next, configure the app to connect to the database. Change the settings as shown in the following code in your config/database.php file to the appropriate settings for your databaseL

class DATABASE_CONFIG {
	var $default = array(
		'driver' => 'mysql',
		'persistent' => false,
		'host' => 'localhost',
		'login' => 'username',
		'password' => 'password',
		'database' => 'fileshare',
		'prefix' => '',
	);
}

Setting up the “default” connection is enough. And while we’re baking and having CakePHP handle all the hard work, lets bake the controllers, models and views to get the basis of our project in place.

$ cake bake all user
$ cake bake all upload

What we have at this stage is a completely ready-to-use website that associates users with many uploads and enables us to populate the database in an easy-to-use manner. But thus far, there’s no actual file upload capability, so we need to modify what CakePHP has baked for us to provide additional functionality processing the file uploads and to prevent people from adding and modifying other users’ information. Further to that, we want to secure the whole application so that only authenticated users can modify data.

Locking things down

We already have a ‘users’ table, and the user addition is working as part of the baking process if you browse to your application and append users to the URL. For example: http://localhost/fileshare/users. So what do we need to do? Well, passwords at this stage are being stored in cleartext, and we don’t seem to be asked to log in. Open up the app_controller.php file in the root of your project. This is an empty controller from which all the other controllers in the application inherit functionality. Anything we implement here will be used in all our controllers, so this is the perfect place to enforce logins. Add the Auth and Session components. Your AppController will now look like this:

<?php
class AppController extends Controller {
  var $components = array(‘Auth’, ‘Session’);
}
?>

If you try to refresh your users list, you’ll be presented with an error indicating that the login action doesn’t exist. If you look carefully, the URL has also been changed to /users/login. Fortunately all the juicy hard stuff has been implemented in CakePHP for us, so all we need to do is provide the action (function) on the controller, and a login form for users to view. Open up controllers/users_controller.php and add the login action:

function login() {
}

That’s not a mistake, it’s an empty function, and it’s all we need for authentication to log in on the controller side.

Before we get too ahead of ourselves, we need to ensure that we can register a user in case you have not already registered one. Since we’re about to complete the user authentication section, we’d be locked out of all functionality and if we didn’t make an exception for the user registration page, we’d never be able to get into our funky new system. Create a beforeFilter method on the users controller, and add the following to tell the Auth component that we’re allowed to visit the register page even if we have not yet logged in:

function beforeFilter() {
  $this->Auth->allow(‘add’);
  return parent::beforeFilter();
}

Create the login view in a new file: views/users/login.ctp, as described here:

<div>
<?php echo $this->Form->create('User');?>
	<fieldset>
 		<legend><?php __('Login'); ?></legend>
	<?php
	echo $this->Form->input('username');
	echo $this->Form->input('password');
	?>
	</fieldset>
<?php echo $this->Form->end(__('Submit', true));?>
</div>

Refresh the page that was giving an error message, and you’ll be presented with a login form. Notice that you will be allowed to visit the /users/add page, but everything else will be redirected to the /users/login page. Feel free at this point to register yourself a user. It will be useful in testing further points in the application. Take a moment to check out your database. You’ll notice that the password is hashed for us automatically. Awesome! It’s also handy to clean up some of the automatically generated fields and inputs that we won’t be using, to ensure that users only have access to things we permit. So remove the following input from both the user add and edit views in views/users/add.ctp and views/users/edit.ctp:

echo $this->Form->input(‘Upload’);

The user index is accessible until authentication is added.

Enabling file uploads

It’s high time we got some file uploading action happening. First up, let’s make an uploads directory under the project directory to place our uploaded files, then assign ownership to the user running your web server. On some distributions this user is www-data, on others it’s apache or www. You’ll need to specify the appropriate user for your system.

$ mkdir uploads
$ chown www-data uploads

Time to dive into some code! Let’s start by adjusting the upload add page to accept files, and store them in a safe manner. The bake process has generated a fairly good form for us, but we’re going to remove a couple of the automatically generated fields and replace them with a file upload field. The columns we defined in our database are primarily for automatic population. The file upload will provide all the data we need. Remove the filename, filesize and filemime inputs from the upload add view in views/uploads/add.ctp, and add in a file input. We didn’t create a column called file in the database, so CakePHP isn’t going to do all the fancy behind-the-scenes work for that field, and we also need to tell it what type that field needs to be for the file input to be generated correctly. The other small change we’re making is to remove the user_id input that CakePHP had generated for us. Instead, we’ll add some code in our controller to automatically assign files to the user who is currently logged in. Your form inputs should now look like this:

<?php echo $this->Form->create(‘Upload’, array(‘type’ => ‘file’));?>
  <fieldset>
     <legend><?php __(‘Add Upload’); ?></legend>
  <?php
  echo $this->Form->input(‘title’);
  echo $this->Form->input(‘description’);
  echo $this->Form->input(‘file’, array(‘type’ => ‘file’));
  echo $this->Form->input(‘User’);
  ?>
  </fieldset>
<?php echo $this->Form->end(__(‘Submit’, true));?>

Enabling file uploads is simple.

Processing the uploaded file

Sure, we’ve got a file in place, but we actually need to handle the file in some manner to show up an error when the file is not correctly uploaded, and to save it in our prepared writable uploads folder when it’s been completed successfully. For this we open up controllers/uploads_controller.php in the baked project, and modify the function add() to process the file if it’s available. On the third line of this function, the code attempts to save the model data. Modify the if statement to call a function that we’ll write in a moment called uploadFile(): if ($this->uploadFile() && $this->Upload->save($this->data)) {

Sounds easy enough, doesn’t it? Now let’s create the uploadFile() function in the same controller:

function uploadFile() {
  $file = $this->data[‘Upload’][‘file’];
  if ($file[‘error’] === UPLOAD_ERR_OK) {
    $id = String::uuid();
    if (move_uploaded_file($file[‘tmp_name’], APP.’uploads’.DS.$id)) {
      $this->data[‘Upload’][‘id’] = $id;
      $this->data[‘Upload’][‘user_id’] = $this->Auth->user(‘id’);
      $this->data[‘Upload’][‘filename’] = $file[‘name’];
      $this->data[‘Upload’][‘filesize’] = $file[‘size’];
      $this->data[‘Upload’][‘filemime’] = $file[‘type’];
      return true;
    }
  }
  return false;
}

Again, we’re keeping things simple. We upload the file, and if we’re able to move it successfully into place, we return true. In the process of doing this, we are manually generating an ID which we use as a safe filesystem name for storage. This eliminates any issues that users may attempt to introduce with weird and potentially system-damaging filenames that would otherwise be directly stored on your filesystem. Manually generating the UUID with String::uuid() removes this security hole, and ensures a safe file upload, while maintaining the original filename in the database to send to the user when downloading.

The next thing we’re going to integrate is the ability to download files. But before going too far, try adding a couple of files. You’ll see them successfully being added to the database, and if you look at the uploads directory we created, matching ID named files start appearing within. If you experience any issues at this point, ensure that your web server user has write access to the uploads directory.

The other cool thing we’re doing here is assigning the user with $this->Auth->user(‘id’) which is the ID of the currently logged-in user. Since we locked down the security earlier, we know that users need to be logged in to reach this page, so the value will always be present and valid.

Cleaning up associations

You’ll notice that we’ve doubled up on our associations for both the User and Upload model. Take for example the User model in models/user.php; CakePHP has generated a hasMany and a hasAndBelongsToMany association both with the index Upload. This just won’t do, because the clash in naming will cause incorrect data to output in the views. Change the hasAndBelongsToMany association in the User model to be SharedUpload. And similarly for the Upload model in models/upload.php, change the HABTM association to be SharedUser:

// User Model
var $hasAndBelongsToMany = array(
  ‘SharedUpload’ => array(
    ‘className’ => ‘Upload’,
    ...

// Upload Model
var $hasAndBelongsToMany = array(
  ‘SharedUser’ => array(
    ‘className’ => ‘User’,
      ..

In order for these association key changes to correctly render in the views, you’ll need to change the index referenced on the views in the related section at the bottom of the view indexes. In views/users/view.ctp, the following two lines:

<?php if (!empty($user[‘pload’])):?>
foreach ($user[‘Upload’] as $upload):

are changed to:

<?php if (!empty($user[‘SharedUpload’])):?>
foreach ($user[‘SharedUpload’] as $upload):

At this point you can register a new user, log in to the system, upload files and assign users. We’ve achieved a massive amount of functionality for minimal code and effort. Give the system a good test before moving on the the next step.

Viewing and downloading files

If you have played around with the navigation in the views we have already, you’ll have come across the view page for one of your uploaded files. It shows all the meta information about the file, but at this point you can’t retrieve the file itself. Let’s tweak a few things to enable downloads so we can get at the files. The first thing to do is add a link to the view file views/uploads/view.ctp. You can add this wherever you like (I prefer to add it at the bottom of the existing data):

<dt<?php if ($i % 2 == 0) echo $class;?>><?php __(‘Download’); ?></dt>
<dd<?php if ($i++ % 2 == 0) echo $class;?>>
  <?php echo $this->Html->link(__(‘Download’, true), array(‘action’ => ‘download’, $upload[‘Upload’][‘id’])); ?>

</dd>

With the link created, it’s time to get our hands dirty again and put together the action for the controller to handle the file download. Open up your UploadsController in controllers/uploads_controller.php one more time and add the following download function. This forces download, and returns the file to the user with the original filename that was present when the file was uploaded. Here’s the code:

function download($id = null) {
	if (!$id) {
		$this->Session->setFlash(__('Invalid id for upload', true));
		$this->redirect(array('action' => 'index'));
	}
	$this->Upload->bindModel(array('hasOne' => array('UploadsUser')));
	$upload = $this->Upload->find('first', array(
		'conditions' => array(
			'Upload.id' => $id,
			'OR' => array(
				'UploadsUser.user_id' => $this->Auth->user('id'),
				'Upload.user_id' => $this->Auth->user('id'),
			),
		)
	));
	if (!$upload) {
		$this->Session->setFlash(__('Invalid id for upload', true));
		$this->redirect(array('action' => 'index'));
	}
	$this->view = 'media';
	$filename = $upload['Upload']['filename'];
	$this->set(array(
		'id' => $upload['Upload']['id'],
		'name' => substr($filename, 0, strrpos($filename, '.')),
		'extension' => substr(strrchr($filename, '.'), 1),
		'path' => APP.'uploads'.DS,
		'download' => true,
	));
}

You can now try out your download link, and you’ll get the file being downloaded via your browser! There’s a fair bit going on in this function, but believe me, there’s far more being taken care of by CakePHP that you don’t need to worry about. We’re first inspecting the ID to ensure it was supplied. Next, we try to lookup an upload record from the database with that ID, and while we’re in there, we ensure that the ID of the upload is associated with the currently logged-in user, or that the file was originally uploaded by the user who is logged in. In either case, we are allowed access. If that query failed, the user is attempting to access a file to which they have not specifically been granted permission, so we redirect them to the index list of files.

Showing only what users can access

In order to make the file list make sense for all users, you’ll also need to modify the index() action on the Uploads controller, to perform similar filtering to show only the files that are permitted in the users rendered list, otherwise it’ll clog up with files they don’t actually have access to see! Adjust the index action thus:

function index() {
  $this->Upload->bindModel(array(‘hasOne’ => array(‘UploadsUser’)), false);
  $this->paginate = array(
    ‘conditions’ => array(
      ‘OR’ => array(
        ‘UploadsUser.user_id’ => $this->Auth->user(‘id’),
        ‘Upload.user_id’ => $this->Auth->user(‘id’),
      ),
    )
  );
  $this->set(‘uploads’, $this->paginate());
}

We’ve had to add the false parameter on the bindModel() call this time to ensure that the pagination result came out correctly. Pagination takes two separate database results to return the data. The first of these determines the number of elements in the table that match the query, and the second actually retrieve the data. The false parameter tells CakePHP to retain the binding beyond a single query. The simple rule, of course, is that if you are using bindModel and pagination, you need to add false on the end.

The view() action also benefits from the same filtering:

function view($id = null) {
  if (!$id) {
    $this->Session->setFlash(__(‘Invalid upload’, true));
$this->redirect(array(‘action’ => ‘index’));
  }

  $this->Upload->bindModel(array(‘hasOne’ => array(‘UploadsUser’)));
  $upload = $this->Upload->find(‘first’, array(
    ‘conditions’ => array(
      ‘Upload.id’ => $id,
      ‘OR’ => array(
        ‘UploadsUser.user_id’ => $this->Auth->user(‘id’),
        ‘Upload.user_id’ => $this->Auth->user(‘id’),
      ),
    )
  ));
  if (!$upload) {
    $this->Session->setFlash(__(‘Invalid upload’, true));
    $this->redirect(array(‘action’ => ‘index’));
  }
  $this->set(‘upload’, $upload);
}

Wrapping it up

The only last nicety that would be required to take this site live is a logout function. And I’ll be kind enough to give you the code to put on the UsersController for logout:

public function logout() {
  $this->redirect($this->Auth->logout());
}

There’s no view required, and redirection happens as soon as the user hits the /users/logout URL, after destroying the session and logging out the user.

So we’ve built a secure, file-uploading, multi-user sharing web application, and it’s only taken 20 minutes or so to get it all done. From here, you can add extra functionality such as thumbnail icons to preview content that users have uploaded, or a different sharing mechanism to select users without exposing the complete user list to everyone. You can also enable email notifications for users that you are sharing files with. I hope you’ve enjoyed this tutorial, and I hope it’s useful for you either as a case study, or as a deployable solution for client file sharing.

The additional link enables us to download files that have been uploaded.

We’re jumping in the deep end, and build a bookmarking site that will not only store URLs and associated information for us, but generate some pretty sweet thumbnails and store those for use too. Because we’re a social community these days, we’ll include some nifty tools from a useful plugin to enable quick and easy social network sharing and publishing to get the word out about a URL that we’ve published.

As always, we put in some time ensuring that our database fits the CakePHP conventions and standards so that the heavy lifting later on is handled by CakePHP. Don’t stress though, if you want to deviate from the standards or structure here, it’s extremely easy to customise, depending on what you’re changing. Check out http://book.cakephp.org/view/901/CakePHP-Conventions for a list of the conventions adopted by the core, and for information on what you need to do to break free and go your own way.

Take a moment to consider the data we need to store. We’ll need: URLs, users and ratings, so that when we share the bookmarked URLs via Twitter, Facebook or whatever our preferred social network giant is, people can rate the content if they like it.

CREATE DATABASE `bookmark`;
USE `bookmark`;
CREATE TABLE `urls` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`user_id` CHAR(36) NOT NULL,
	`name` VARCHAR(128) NOT NULL,
	`url` TEXT,
	`created` DATETIME,
	`modified` DATETIME
);
CREATE TABLE `users` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`username` VARCHAR(45) NOT NULL,
	`password` VARCHAR(255) NOT NULL,
	`email` VARCHAR(255) NOT NULL,
	`created` DATETIME,
	`modified` DATETIME
);

Hang on a moment… surely that can’t be all the tables we need? That list of information we wanted to include for each bookmark was pretty long. And it doesn’t look like there are enough fields in that table to hold all the data – except that each plugin is capable of distributing database information that it needs in a segregated way to ensure that you have all the functionality you need packaged in the plugin that provides it, including the database storage requirements.

Okay, but how does it work? Its done by using either the ‘Schema’ shell, which comes with CakePHP, or by using the ‘Migrations’ plugin, which is developed by the Cake Development Corporation. We’ll run through the migrations plugin, because it provides much more functionality, while still remaining easy to use.

Time to hit the oven, baking time!

Bake is a console command for CakePHP, and it enables you to generate code, run migrations, run tests and much more. In order for this to work effectively from your console, the cake/console path within the CakePHP package needs to be in your PATH environment variable. You can achieve this with the following in your shell:

$ export PATH="$PATH:/path/to/cakephp/cake/console"

The only other requirement is that you have PHP available on your command line. Most distros have a php-cli package or similar to provide a command line interface PHP binary.

Bake a new project to create the skeleton structure we need to get moving. Run the following in your shell:

$ cake bake project bookmark
$ cd bookmark

CakePHP has created a basic app structure for you to use. This includes the directories and some basic initial files for you to use to serve static pages. Feel free to dig around and see exactly what has been produced for you. It’s a good idea to get familiar with the file structure that CakePHP adopts.

Before we bake, let’s tell CakePHP how to connect to our database. Take a copy of the /config/database.php.default file and rename it to /config/database.php. Enter in your database configuration to match the user details for your local database install. Here’s what my config shows:

<?php
class DATABASE_CONFIG {
	var $default = array(
		'driver' => 'mysql',
		'persistent' => false,
		'host' => 'localhost',
		'login' => 'dev',
		'password' => 'dev',
		'database' => 'bookmark',
		'prefix' => '',
	);
}

You’ll note that I have removed the test database configuration from the file. The test configuration is used for unit testing, and in this tutorial we won’t be touching on it.

Let’s get cracking on the baking of models, views and controllers for the database tables we created earlier. Baking will generate all the code we need to get the common functionality working, and will enable us to customise from there, saving a whole lotta time.

$ cake bake all user
$ cake bake all url

Don’t be alarmed by the amount of output text from the bake command; the more it outputs, the more time it has saved you through generating code. If you take a look at the output, you’ll see file paths and names to all the files that have been created for you. You now have a user and URL management system, and can browse through to add and edit that information. Try browsing to /users on your site. For example, I baked into my webroot, and so the URL I use is: http://localhost/bookmark/users. You’ll be greeted with the users index page, and from here you can navigate around to add and edit users.

Enabling authentication

We’ll quickly run through locking the system down so we can create users and log in, but not access anything else until we are logged in. This is a great way to secure your system, and its dead easy to do!

Open up the app_controller.php file in the root of your project. This is an empty controller from which all the other controllers in the application inherit functionality. Anything we implement here will be used in all our controllers, so this is the perfect place to enforce user authentication, and keep out nasty guests from editing data. Add the “Auth” and “Session” components. Your AppController will now look like this:

<?php
class AppController extends Controller {
	var $components = array('Auth', 'Session');
	function beforeFilter() {
		$this->set('authUser', $this->Auth->user());
		return parent::beforeFilter();
	}
}

You’ll note we snuck in a set call in the function beforeFilter there. This will ensure that we have access to the current user information in the views throughout the site. If there is no user currently logged in, this will be set to null.

Next, open up /controllers/users_controller.php and add a login action. This can be empty, as CakePHP handles the tricky stuff behind the scenes. While we’re digging around, also add the logout function for logging out users:

function login() {
}

function logout() {
	return $this->redirect($this->Auth->logout());
}

Finally, on the controller side, we want to ensure that we don’t have to log in to create a user, otherwise we’d be stuck with no users, and no way to create one! Add the following to your users controller:

function beforeFilter() {
	$this->Auth->allow('add');
	return parent::beforeFilter();
}

The final piece of this puzzle is the view file, which isn’t created with the CakePHP bake tool. This will take the username and password and enable users to log in. Create the login view in a new file: /views/users/login.ctp:

<div>
<?php echo $this->Form->create('User', array('url' => array('action' => 'login')));?>
	<fieldset>
 		<legend><?php __('Login'); ?></legend>
	<?php
	echo $this->Form->input('username');
	echo $this->Form->input('password');
	?>
	</fieldset>
<?php echo $this->Form->end(__('Login', true));?>
</div>

Browse back to your users list (http://localhost/bookmark/users) and you’ll immediately be redirected to the user login form. Now, try visiting the user addition page (http://localhost/bookmark/users/add) and you’ll note that you are allowed to view this page, and thus not redirected away to log in. Brilliant! It couldn’t get any easier!

Time for a fresh coffee and a pat on the back. Your data is secure, and your site works. Take a spin around the app and create a new user. Log in and test that it works correctly, and add a URL or two. Once you are happy with how that is operating and you are familiar with the site, we’ll move on to including plugins, and getting the cool stuff working!

Back in school they’d kick you out for it.. But here you’re welcome to grab people’s code and use it in your project to enhance functionality, or just save time. Just remember to check the licensing of the plugins you choose to use, as they may not be compatible with the project you are building.

How to cheat

Let’s go hunting for plugins, grab what we need and set up the directories in /app/plugins. For the purposes of this plugin installation, I’m going to assume that you have Git installed. Using Git will speed up the download and organisation of our application plugins for usage. And while you’re at it, its a great way to get used to using Git for version control if you’re not already familiar with it.

Run the following Git commands in your console:

git clone https://github.com/CakeDC/migrations.git plugins/migrations
git clone https://github.com/CakeDC/ratings.git plugins/ratings
git clone https://github.com/CakeDC/search.git plugins/search
git clone https://github.com/predominant/cake_social.git plugins/cake_social
git clone https://github.com/predominant/goodies.git plugins/goodies

You’ve just saved yourself months of development time. No kidding. You’re utilising a bunch of open source plugins that are available to any CakePHP developer who wants to use it, to cover the common functionality in your application. This saves time and money and lets you get on to leisure time quicker than the rest of the developers. Bonus!

Running migrations

Earlier I mentioned that we had a lack of database tables, but that would be taken care of by database migrations. That time has come, and you’ll see how simple database table creation can be for plugins and code reuse through projects. Not all plugins need or have migrations. Those that do will have a migrations directory in their config directory. For example, you will see the directory /plugins/ratings/config/migrations. You can check through to see what needs migrations, or just run them all, and you’ll get an error message for those that didn’t actually have migrations available, which is fine.

Run the following to complete the table setup for the plugins we’ve introduced:

$ cake migration -plugin ratings all

You should now have all the tables you need for the site!

Let’s start by enabling ratings. We want those accessible for URLs only. Adding the component is really easy. Open up the UrlsController in /controllers/urls_controller.php and add the Ratings component. Your resulting code will now look like the following:

class UrlsController extends AppController {
	var $components = array('Ratings.Ratings');
		// ... existing code ...
}

What’s super cool about this is that the component we’ve just added takes care of including the helper that you need to display the ratings form, as well as handles the saving and loading of ratings information for you. So all you need to do is set up your view as you like it to show the form for ratings, through the ratings helper, and the rating itself. Now being a truly portable and flexible plugin, the ratings information isn’t averaged or calculated for you on load, since that would be making the assumption that we know what maths you need applied for your specific situation. So some effort is required to get the right value showing, and to get the form showing only when users have not yet rated it.

The next section of code is pretty big;

<?php
$rated = Set::extract('/Rating[user_id=' . $authUser['User']['id'] . ']', $url);
if (empty($rated)): ?>
	<dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Rate'); ?></dt>
	<dd<?php if ($i++ % 2 == 0) echo $class;?>>
	<?php echo $this->Rating->display(array(
	    'item' => $url['Url']['id'],
	    'type' => 'radio',
	    'stars' => 5,
	    'createForm' => array(
			'url' => array_merge(
				$this->passedArgs,
				array(
					'rate' => $url['Url']['id'],
					'redirect' => true))
			)
	)); ?>

	</dd>
<?php else: ?>
	<dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Rating'); ?></dt>
	<dd<?php if ($i++ % 2 == 0) echo $class;?>>
		<?php
		$ratings = Set::extract('/Rating/value', $url);
		echo array_sum($ratings) / count($ratings); ?>

	</dd>
<?php endif; ?>

There are two main sections to the code: the first shows the form if you have not already rated the current bookmark, and the second displays our rating. Both sections of code use the Set class, which makes it easy to handle larger collections of data, and enables filtering. Add the code just after the dl tag at the start of your URLs view in /views/urls/view.ctp.

Browsing to a URL now shows a set of radio buttons, and a Rate Submission button. Sweet! Give it a go, rate a URL – you’ll be redirected to the same page, and the resulting rating will be displayed for you. Feel free to test this out some more by using another user, and see how the resulting rating changes to be the average of all the rates submitted. Pretty darn cool!

Using gravatars

The URL view page is pretty bland. There, I said it! What we really should do is at least include some more imagery and items to represent the information on the page in a more rapid manner for visitors. We’ll leave the complexities of CSS and styling the page to perfection to the web designers, but we will make their job easy through using gravatars to show user icons from the user information we have for each URL. A gravatar is a global avatar, and is provided for free through http://gravatar.com. We included a Goodies plugin when we cloned all the plugins, and the gravatar helper is just one of the awesome things that this plugin provides.

Enough sales talk.. Lets get some gravatars showing. If you have not done already, head over to the gravatar website, register your account for free, and set up a gravatar. Next, open up the URLs view (/views/urls/view.ctp). Scroll down to where the User information is output. The line we’re going to replace is:

<?php echo $this->Html->link($url['User']['id'], array('controller' => 'users', 'action' => 'view', $url['User']['id'])); ?>

Replace this with a similar code link, but this time, include the output of the gravatar helper:

<?php echo $this->Html->link(
	$this->Gravatar->image($url['User']['email']),
	array('controller' => 'users', 'action' => 'view', $url['User']['id']),
	array('escape' => false)); ?>
<?php echo $url['User']['username']; ?>

Finally, include the helper in your AppController in /app_controller.php:

class AppController extends Controller {
	var $helpers = array('Html', 'Form', 'Session', 'Goodies.Gravatar');
	// ... existing code ...
}

This will show the user’s gravatar based on their email address supplied at registration time, and also their username, instead of that ugly UUID string. Go ahead, refresh the page or browse to another URL to view it, and the gravatar will be shown in place of the user information.

Adding a social sharing widget

Let’s do one more step to fancy up the extra information and add some social sharing capabilities to promote more people to visit our site, and to enable users to share the bookmarks they really like. This functionality comes from the CakeSocial plugin we added at the beginning. The CakeSocial plugin includes a helper for the “ShareThis” service, which makes social sharing really simple. So a simple plugin for a simple service, should be super simple, right? Judge for yourself. Add the helper to the AppController in /app_controller.php:

class AppController extends Controller {
	var $helpers = array('Html', 'Form', 'Session', 'Goodies.Gravatar', 'CakeSocial.ShareThis');
	// ... existing code ...
}

And just before the closing tag on your view for URLSs /views/urls/view.ctp include the following:

<dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Share'); ?></dt>
<dd<?php if ($i++ % 2 == 0) echo $class;?>>
	<?php echo $this->ShareThis->display(); ?>

</dd>

Whoa! There are five lines of code for that view, but only one is doing the social output. The rest is wrapping styles for the output, and a label. Reload your page and you’ll have the ShareThis social helpers appear, and you can share on a list of default services.

Icing on the cake: Web thumbnails

Since we saved so much time using plugins and getting these awesome features included, we have some spare time to include a cool feature like thumbnailing. Wouldn’t it be cool to have a small picture of the website pop up when we’re looking at the view page for a URL? That really would be the icing on the cake.

We’re going to take advantage of another helper from the Goodies plugin to grab the thumbnail from the Thumboo service (http://www.thumboo.com). Fetching on each view is not loading your server, as the request is handled by the external service, and it ensures that your thumbs are always up to date!

Head over to Thumboo (http://www.thumboo.com) and create an account for free. You’ll be given an API Access key. Hold on to that, you’ll need it later.

Once more unto the breach! Or, once more we’ll edit the AppController `/app_controller.php`, and add a helper. Add the Thumboo helper from the Goodies plugin:

class AppController extends Controller {
	var $helpers = array('Html', 'Form', 'Session', 'Goodies.Gravatar', 'CakeSocial.ShareThis', 'Goodies.Thumboo');

	// ... existing code ...
}

Almost there! Switch back to the view for urls `/views/urls/view.ctp` and add the following immediately after the heading at the top of the file:

<?php echo $this->Thumboo->image($url['Url']['url']); ?>

We’ve used the smallest form possible to call the helper, and we have not yet supplied that extremely easy to remember API key that Thumboo has provided us with. For this, we’re going to create a configuration file, and CakePHP will load this up as it needs it to read the key value. Using this method lets you keep configuration separate from code, and its a great way to kep your secure information safe.

Create a new file in `/config/thumboo.php` and add the following, replacing the key value with what you were supplied after signup:

<?php
$config = array(
	'Thumboo' => array(
		'Key' => 'MY KEY HERE',
	)
);

Reload your page and revel in the beauty of what has been achieved in such a short period of time. You’ve earned yourself a beer.

Where to now? The app you have built today is a good example of how quickly you can build apps with CakePHP, and the quality of the plugins that are available for free within the community. The current app has a lot of potential to expand to provide extra details like private URLs, a REST service for integration, a bookmarklet that uses Ajax that you can include for your browser, some styling, and removal of some default data and pages. The possibilities are endless!

once you optimize your php code then your applicationa and website will be very fast
this will make quality code. Hi php programmer don’t forget these rules if you want to
be good in php and want to work in MNC because all mnc and all good companies follow
these rules strictly even this is gud question for interview for php. best of luck.

What is the process for PHP code Optimisation.

Use the Zend Optimizer and a code cache

Use the comma operator to join arguments when calling echo

Priorities optimisation of tight loops for the most payback

Pre-increment where possible

Don’t rely on references without testing; they are rarely as effective as you’d think

Get a good understanding of how garbage collection works

Listen to all errors, big and small – they slow things down

Store a local pointer to an array element to save indexing into the array each time you need it

Compress your output to save network bandwidth

Try to avoid using PHP in CGI mode

Avoid calling the dl() function

Use persistent resource where appropriate

Optimise compilation of your PHP binary if possible

Avoid mod_access if you can

Don’t fret about Apache 2.0

As a last resort, try inlining function

mysql_connect() and mysql_pconnect() both are working for database connection but with small difference. In mysql_pconnect(), ‘p’ stands for persistence connection.

But in case of mysql_pconnect() function,
first, when connecting, the function would try to find a (persistent) connection that’s already open with the same host, username and password. If three is found, an identifier for it will be returned in lieu of opening a new connection.
Second, the connection to the SQL server won’t be closed when the execution of the script ends. In lieu, the connection will remain open for future use (mysql_close() won’t close connection established by mysql_pconnect()).

Mysql_pconncet() is useful when you have a lot of traffic on your site. At that time for every request it won’t open a connection but will take it from the pool. This will increase the efficiency of your site. But for general use mysql_connect() is best.

If you code a script to find all hyperlinks, it will use &amp instead of &, especially using a regular expression search.

It is hard to detect because when you output the url to the browser it renders the html. To fix, add a line to replace the &amp with &.

But here is the catch, you may want to make sure curl connects to the server under the same session as the browser. So naturally you pass the session cookie through the curl system either by the cookie jar system, or through the query string in the path.

This is where you will get stuck. PHP will need write access to the same session file simultaneously!! causing serious hanging issues!

This is why you should close off your session before you make curl take a page snapshot!