Welcome to The Cookbook

When working with associated models, it is important to realize that saving model data should always be done by the corresponding CakePHP model. If you are saving a new Post and its associated Comments, then you would use both Post and Comment models during the save operation.

If neither of the associated model records exists in the system yet (for example, you want to save a new User and their related Profile records at the same time), you'll need to first save the primary, or parent model.

To get an idea of how this works, let's imagine that we have an action in our UsersController that handles the saving of a new User and a related Profile. The example action shown below will assume that you've POSTed enough data (using the FormHelper) to create a single User and a single Profile.

<?php
function add() {
	if (!empty($this->data)) {
		// We can save the User data:
		// it should be in $this->data['User']
 
		$this->User->save($this->data);
 
		// Now we add this information to the save data
		// and save the Profile.
 
		// The ID of the newly created user has been set
		// as $this->User->id.
		$this->data['Profile']['user_id'] = $this->User->id;
 
		// Because our User hasOne Profile, we can access
		// the Profile model through the User model:
		$this->User->Profile->save($this->data);
	}
}
?>

1. <?php
2. function add() {
3. if (!empty($this->data)) {
4. // We can save the User data:
5. // it should be in $this->data['User']
7. $this->User->save($this->data);
9. // Now we add this information to the save data
10. // and save the Profile.
12. // The ID of the newly created user has been set
13. // as $this->User->id.
14. $this->data['Profile']['user_id'] = $this->User->id;
16. // Because our User hasOne Profile, we can access
17. // the Profile model through the User model:
18. $this->User->Profile->save($this->data);
19. }
20. }
21. ?>

As a rule, when working with hasOne, hasMany, and belongsTo associations, its all about keying. The basic idea is to get the key from one model and place it in the foreign key field on the other. Sometimes this might involve using the $id attribute of the model class after a save(), but other times it might just involve gathering the ID from a hidden input on a form that’s just been POSTed to a controller action.

This function helps you caching the count of related data. Instead of counting via SELECT (i.e. using find('count')), the model itself tracks any addition/deleting towards the associated $hasMany model and increases/decreases a dedicated integer field within the parent model table.

The name of the field consists of the singular model name followed by a underscore and the word "count".

Let's say you have a model called "ImageAlbum" and a model called "Image", you would add an INT-field to the "image_album" table and name it "image_count". Or if your names are more complex, here is another example: With "BlogEntry" and "BlogEntryComment", the name of the field would be "blog_entry_comment_count" and needs to be added to "blog_entries".

Once you have added the counter field you are good to activate this functionality by adding the "counterCache" key to the "$belongsTo" association array and set the value to "true".

class ImageAlbum extends AppModel {
    var $hasMany = array(
        'Image'
    )
}

class Image extends AppModel {
    var $belongsTo = array(
        'ImageAlbum' => array('counterCache' => true);
    )
}

1. class ImageAlbum extends AppModel {
2. var $hasMany = array(
3. 'Image'
4. )
5. }
6. class Image extends AppModel {
7. var $belongsTo = array(
8. 'ImageAlbum' => array('counterCache' => true);
9. )
10. }

Now every time you add a new "Image" to "ImageAlbum" the number within "image_count" will increase (or decrease if you do a delete).

Saving models that are associated by hasOne, belongsTo, and hasMany is pretty simple: you just populate the foreign key field with the ID of the associated model. Once that's done, you just call the save() method on the model, and everything gets linked up correctly.

With HABTM, you need to set the ID of the associated model in your data array. We'll build a form that creates a new tag and associates it on the fly with some recipe.

The simplest form might look something like this (we'll assume that $recipe_id is already set to something):

<?php echo $form->create('Tag');?>
    <?php echo $form->input(
        'Recipe.id', 
        array('type'=>'hidden', 'value' => $recipe_id)); ?>
    <?php echo $form->input('Tag.name'); ?>
    <?php echo $form->end('Add Tag'); ?>

1. <?php echo $form->create('Tag');?>
2. <?php echo $form->input(
3. 'Recipe.id',
4. array('type'=>'hidden', 'value' => $recipe_id)); ?>
5. <?php echo $form->input('Tag.name'); ?>
6. <?php echo $form->end('Add Tag'); ?>

In this example, you can see the ‘Recipe.id’ hidden field whose value is set to the ID of the recipe we want to link the tag to. The controller action that handles saving this form, is very simple:

function add() {
    
    //Save the association
    if ($this->Tag->save($this->data)) {
        //do something on success            
    }
}

1. function add() {
3. //Save the association
4. if ($this->Tag->save($this->data)) {
5. //do something on success
6. }
7. }

And just like that, our new Tag is created and associated with a Recipe, whose ID was set in $this->data['Recipe']['id'].