Gestion automatique d’une colonne de tri avec un Comportement

<?php
/**
 * Fichier de la classe OrdonnableBehavior - 16 mai 2008.
 *
 * @filesource
 * @author Pierre-Emmanuel Fringant
 * @link http://www.formation-cakephp.com/
 * @version	0.3
 * @license	http://www.opensource.org/licenses/mit-license.php The MIT License
 * @package app
 * @subpackage app.models.behaviors
 */
/**
 * Comportement de modèle pour prendre en charge automatiquement
 * une colone de tri numérique.
 *
 * @package app
 * @subpackage app.models.behaviors
 */
class OrdonnableBehavior extends ModelBehavior
{
	/**
	 * Initialisation du Comportement avec les options par défaut.
	 * 
	 * Options disponibles :
	 * - field :    nom du champ numérique de la base qui va contenir les valeurs de l'indice
	 * - addToEnd : booléen, si vrai un nouvel enregistrement sera ajouté au dernier rang de l'index d'ordre,
	 *              si faux le nouvel enregistrement sera ajouté au premier rang.
	 *
	 * @param object $model Le modèle sur lequel va être appliqué le Comportement
	 * @param array $config Les options définies dans le modèle (prioritaires sur les options par défaut)
	 */
	function setup(&$model, $config = array())
	{
		$settings = array_merge(
			array(
				'field' => 'ordre',
				'addToEnd' => true
			),
			(array)$config
		);
 
		$this->settings[$model->alias] = $settings;
	}
 
	/**
	 * Méthode appelée après chaque sauvegarde.
	 * Si c'est un ajout, on regarde la valeur de l'option $addToEnd
	 * et on met à jour la valeur de l'ordre de l'enregistrement concerné.
	 *
	 * @param object $model Le modèle relié au Comportement
	 * @param boolean $created Vrai s'il s'agit d'un ajout (INSERT), faux si c'est une mise à jour (UPDATE)
	 * @return boolean Renvoie vrai si succès, faux en cas d'erreur
	 */
	function afterSave(&$model, $created)
	{
		extract($this->settings[$model->alias]);
 
		if(!$created)
		{
			return;
		}
 
		if($addToEnd)
		{
			// Indice le plus élevé
			list($order) = array_values(
				$model->find(
					'first',
					array(
						'conditions' => '1=1',
						'fields' => 'MAX(' . $field . ') AS ' . $field,
						'recursive' => -1
					)
				)
			);
 
			// Nouvel indice
			$new =
				empty($order[$field])
				? 1
				: $order[$field]+1;
 
		}
		else
		{
			// Décalage de tous les indices (+1 à tous)
			$this->__offset($model);
 
			// Nouvel indice
			$new = 1;
		}
 
		return $this->__updateOrder($model, $model->id, $new);
	}
 
	/**
	 * Méthode appelée avant chaque suppression.
	 * On décale d'un cran les enregistrements suivant celui à supprimer
	 *
	 * @param object $model Le modèle relié au Comportement
	 * @return boolean Renvoie vrai si succès, faux en cas d'erreur
	 */
	function beforeDelete(&$model)
	{
		extract($this->settings[$model->alias]);
 
		$start = $model->field($field);
 
		return $this->__offset($model, $start, -1);
	}
 
	/**
	 * Monter d'un certain nombre de crans
	 *
	 * @param object $model Modèle relié au Comportement
	 * @param integer $id Id de l'enregistrement à monter
	 * @param integer $delta Nombre de crans
	 * @return boolean Renvoie vrai si succès, faux en cas d'erreur
	 */
	function moveUp(&$model, $id = null, $delta = -1)
	{
		return $this->__move($model, $id, $delta);
	}
 
	/**
	 * Descendre d'un certain nombre de crans
	 *
	 * @param object $model Modèle relié au Comportement
	 * @param integer $id Id de l'enregistrement à descendre
	 * @param integer $delta Nombre de crans
	 * @return boolean Renvoie vrai si succès, faux en cas d'erreur
	 */
	function moveDown(&$model, $id = null, $delta = +1)
	{
		return $this->__move($model, $id, $delta);
	}
 
	/**
	 * Affecter un nouvel indice à un enregistrement
	 *
	 * @param object $model Modèle relié au Comportement
	 * @param integer $id Id de l'enregistrement à descendre
	 * @param integer $new Nouvel indice
	 * @return boolean Renvoie vrai si succès, faux en cas d'erreur
	 */
	function moveTo(&$model, $id = null, $new = 1)
	{
		extract($this->settings[$model->alias]);
 
		$model->id = $id;
		$old = $model->field($field);
 
		if($new <= 0)
		{
			$new = 1;
		}
 
		return $this->__move($model, $id, $new - $old);
	}
 
	/**
	 * Monter ou descendre d'un certain nombre de crans
	 *
	 * @param object $model Modèle relié au Comportement
	 * @param integer $id Id de l'enregistrement à modifier
	 * @param integer $delta Nombre de crans
	 * @return boolean Renvoie vrai si succès, faux en cas d'erreur
	 * @access private
	 */
	function __move(&$model, $id = null, $delta = +1)
	{
		extract($this->settings[$model->alias]);
 
		$model->id = $id;
		$old = $model->field($field);
 
		$new = $old + $delta + ($delta > 0);
 
		if($new <= 0)
		{
			return false;
		}
 
		$return = $this->__offset($model, $new);
 
		if($return)
		{
			$return = $this->__updateOrder($model, $id, $new);	
		}
		if($return)
		{
			$return = $this->__reIndex($model);
		}
 
		return $return;
	}
 
	/**
	 * Appliquer un décalage de plusieurs lignes à partir d'un indice.
	 *
	 * @param object $model Modèle relié au Comportement
	 * @param integer $start Indice à partir duquel appliquer le décalage
	 * @param integer $offset Grandeur du décalage
	 * @return boolean Renvoie vrai si succès, faux en cas d'erreur
	 * @access private
	 */
	function __offset(&$model, $start = 1, $offset = +1)
	{
		extract($this->settings[$model->alias]);
 
		return $model->updateAll(
			array(
				$model->escapeField($field) => $model->escapeField($field) . '+' . $offset
			),
			array(
				$model->escapeField($field) . " >= "  => $start
			)
		);
	}
 
	/**
	 * Réindexer la colonne de tri.
	 *
	 * @param object $model Modèle relié au Comportement
	 * @param integer $start Indice à partir duquel réinitialiser le compteur
	 * @return boolean Renvoie toujours vrai
	 * @access private
	 */
	function __reIndex(&$model, $start = 1)
	{
		extract($this->settings[$model->alias]);
 
		$fromStart = $model->find(
			'all',
			array(
				'fields' => array(
					$model->primaryKey,
					$field
				),
				'conditions' => array(
					"$field >= " => $start
				),
				'order' => array(
					$field => 'asc'
				),
				'recursive' => -1
			)
		);
 
		foreach($fromStart as $row)
		{
			if($row[$model->alias][$field] != $start)
			{
				$this->__updateOrder($model, $row[$model->alias][$model->primaryKey], $start);
			}
			$start++;
		}
 
		return true;
	}
 
 
	/**
	 * Echanger les ordres de deux enregistrements
	 *
	 * @param object $model Modèle relié au Comportement
	 * @param integer $one_id Id du premier enregistrement
	 * @param integer $two_id Id du deuxième enregistrement
	 * @return boolean Renvoie vrai si succès, faux en cas d'erreur
	 * @access private
	 */
	function __switch(&$model, $one_id, $two_id)
	{
		extract($this->settings[$model->alias]);
 
		$one = $model->find(
			'first',
			array(
				'fields' => array(
					$model->primaryKey,
					$field
				),
				'conditions' => array(
					$model->primaryKey => $one_id
				),
				'recursive' => -1
			)
		);
 
		$two = $model->find(
			'first',
			array(
				'fields' => array(
					$model->primaryKey,
					$field
				),
				'conditions' => array(
					$model->primaryKey => $two_id
				),
				'recursive' => -1
			)
		);
 
		if(empty($one) or empty($two))
		{
			return false;
		}
 
		list($one) = array_values($one);
		list($two) = array_values($two);
 
		$return = $model->__updateOrder($model, $one[$model->primaryKey], $two[$field]);
 
		if($return)
		{
			$return = $model->__updateOrder($model, $two[$model->primaryKey], $one[$field]);
		}
 
		return $return;
	}
 
	/**
	 * Mise à jour de l'indice d'un enregistrement
	 *
	 * @param object $model Modèle relié au Comportement
	 * @param integer $id Id de l'enregistrement
	 * @param integer $order Nouvel indice
	 * @param boolean $validate Vrai si on doit valider les données
	 * @return boolean Renvoie vrai si succès, faux en cas d'erreur
	 */
	function __updateOrder(&$model, $id = null, $order = 0, $validate = false)
	{
		extract($this->settings[$model->alias]);
 
		$model->id = $id;
 
		return $model->saveField($field, $order, $validate);
	}
}
?>

// {app}/models/diplome.php
class Diplome extends AppModel
{
	var $name = 'Diplome';
 
	var $displayField = 'libelle';
 
	var $actsAs = array(
		'Ordonnable' => array(
			'field' => 'ordre',
			'addToEnd' => true
		)
	);
}

// {app}/controllers/diplomes_controller.php
class DiplomesController extends AppController
{
	var $name = 'Diplomes';
 
	function index()
	{
		$diplomes = $this->Diplome->find(
			'all',
			array('order' => 'Diplome.ordre ASC')
		);
		$this->set(compact('diplomes'));
	}
 
	function monter($id = null)
	{
		if($id)
		{
			$this->Diplome->moveUp($id);
			$this->redirect('index');
		}
	}
 
	function descendre($id = null)
	{
		if($id)
		{
			$this->Diplome->moveDown($id);
			$this->redirect('index');
		}
	}
 
	function deplacer()
	{
		if(!empty($this->data))
		{
			$this->Diplome->moveTo(
				$this->data['Diplome']['id'],
				$this->data['Diplome']['indice']
			);
			$this->redirect('index');
		}
	}
}

// {app}/views/diplomes/index.ctp
<?php
e($html->tableHeaders('Ordre actuel', 'Libellé', 'Monter', 'Descendre', 'Déplacer'));
foreach ($diplomes as $row): ?> 
<tr>
	<td><?php e($row['Diplome']['ordre']); ?></td>
 
	<td><?php e($row['Diplome']['libelle']); ?></td>
 
	<td><?php e($html->link("Monter", 'monter/'.$row['Diplome']['id'])); ?></td>
 
	<td><?php e($html->link("Descendre", 'descendre/'.$row['Diplome']['id'])); ?></td>
 
	<td>
	<?php e($form->create('Diplome', array('action' => 'deplacer'))); ?> 
	<?php e($form->input('id', array('value' => $row['Diplome']['id']))); ?> 
	<?php e($form->input('indice', array('label' => false, 'div' => false, 'size' => 3, 'value' => $row['Diplome']['ordre']))); ?> 
	<?php e($form->submit('ok', array('div' => false))); ?> 
	<?php e($form->end()); ?> 
	</td>
</tr>
<?php endforeach; ?> 
</table>