Welcome to The Cookbook

Cuando estamos trabajando con modelos asociados, es importante tener en cuenta que al guardar los datos de un modelo hay que hacerlo con el correspondiente modelo de CakePHP. Si estás guardando un nuevo Post y sus comentarios asociados, entonces deberías usar ambos modelos, Post y Comment, durante la operación de guardado.

Si ninguno de los registros de los modelos asociados existe aún ( por ejemplo, quieres guardar registros de un nuevo Usuario [User] y su Perfil [Profile] relacionado a la vez ), primero necesitas guardar el modelo primario o padre.

Para tener una idea de cómo funciona ésto, imaginemos que tenemos una acción en nuestro controlador de usuarios [UsersController] que maneja el guardado de un nuevo usuario y su perfil [Profile] correspondiente. En la acción de ejemplo mostrada abajo se da por hecho que se han POSTeado sufientes datos (usando el FormHelper) para crear un único Usuario [User] y un único Perfil [Perfil].

<?php
function add() {
    if (!empty($this->data)) {
        //Podemos guardar los datos del usuario[User]
        //deberían estar en: $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.

        //El ID del nuevo usuario creado ahora está
        //$this->User->id.
        $this->data['Profile']['user_id'] = $this->User->id;

        //Como nuestro usuario [User] tiene un [hasOne] perfil [Profile]
        //podemos acceder al modelo del perfil [Profile]
        // a través del modelo del usuario [User]


        $this->User->Profile->save($this->data);
    }
}

?>

1. <?php
2. function add() {
3. if (!empty($this->data)) {
4. //Podemos guardar los datos del usuario[User]
5. //deberían estar en: $this->data['User']
6. $this->User->save($this->data);
7. //Now we add this information to the save data
8. //and save the Profile.
9. //The ID of the newly created user has been set
10. //as $this->User->id.
11. //El ID del nuevo usuario creado ahora está
12. //$this->User->id.
13. $this->data['Profile']['user_id'] = $this->User->id;
14. //Como nuestro usuario [User] tiene un [hasOne] perfil [Profile]
15. //podemos acceder al modelo del perfil [Profile]
16. // a través del modelo del usuario [User]
17. $this->User->Profile->save($this->data);
18. }
19. }
20. ?>

Como norma general, cuando trabajamos con asociaciones "tiene un", "tiene muchos", y "pertenece a" ( hasOne, hasMany, belongsTo, respectivamente ), todo es cuestión de las claves. La idea básica es coger la clave de un modelo y ponerla cómo clave foránea en el otro. A veces esto puede implica usar el atributo $id de la clase del modelo después de guardar [save()], pero otras veces puede implicar obtener el ID desde un campo oculto de un formulario POSTeado a la acción del controlador

This function helps you caching the count of related data. Instead of counting via SELECT (i.e. using findCount), 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 "counter".

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'].