models/behaviors/sortable.php

   1 <?php
   2 /**
   3  * Copyright (c) 2008, Dardo Sordi
   4  *
   5  * Licensed under The MIT License
   6  * Redistributions of files must retain the above copyright notice.
   7  *
   8  * @copyright           Copyright (c) 2008, Dardo Sordi
   9  * @license             http://www.opensource.org/licenses/mit-license.php The MIT License
  10  * @author      Dardo Sordi
  11  */
  12
  13 class SortableBehavior extends ModelBehavior {
  14
  15         var $__config = array();
  16
  17         function setup(&$model, $config = array()) {
  18                 $default = array('field' => 'order', 'enabled' => true, 'cluster' => false);
  19                 $this->__config[$model->name] = array_merge($default, (array)$config);
  20         }
  21
  22         function _config(&$model, $config = array()) {
  23                 if (is_array($config)) {
  24                         if (!empty($config)) {
  25                                 $this->__config[$model->name] = array_merge($this->__config[$model->name], $config);
  26                         }
  27                 } else {
  28                         return $this->__config[$model->name][$config];
  29                 }
  30
  31                 return $this->__config[$model->name];
  32         }
  33
  34         function _fullField(&$model) {
  35                 return $model->name . '.' . $this->_config($model, 'field');
  36         }
  37
  38         function beforeFind(&$model, $conditions = array()) {
  39                 extract($this->_config($model));
  40                 if (!$enabled) {
  41                         return $conditions;
  42                 }
  43                 if (is_string($conditions['fields']) && strpos($conditions['fields'], 'COUNT') === 0) {
  44                         return $conditions;
  45                 }
  46                 $order = $conditions['order'];
  47                 if (is_array($conditions['order'])) {
  48                         $order = current($conditions['order']);
  49                 }
  50                 if (empty($order)) {
  51                         $conditions['order'] = array(array($this->_fullField($model) => 'ASC'));
  52
  53                         if ($cluster !== false) {
  54                                 $conditions['order'] = array_merge(array($cluster => 'ASC'), $conditions['order']);
  55                         }
  56                 }
  57                 return $conditions;
  58         }
  59
  60         function beforeSave(&$model) {
  61                 extract($this->_config($model));
  62                 if ($enabled) {
  63                         $fixPosition = false;
  64                         $isInsert = !$model->id;
  65                         if (isset($model->data[$model->name][$field]) && !empty($model->data[$model->name][$field])) {
  66                                 $newPosition = $model->data[$model->name][$field];
  67                         } else {
  68                                 $newPosition = null;
  69                         }
  70                         $clusterId = $this->_clusterId($model);
  71                         $model->data[$model->name][$field] = $this->lastPosition($model, $clusterId) + 1;
  72                         $model->__fixPosition = $newPosition;
  73                 }
  74                 return true;
  75         }
  76
  77         function afterSave(&$model, $created) {
  78                 extract($this->_config($model));
  79                 if (!$enabled) {
  80                         return true;
  81                 }
  82                 $position = $model->data[$model->name][$field];
  83                 if ($model->__fixPosition) {
  84                         $position = $model->__fixPosition;
  85                         $model->__fixPosition = null;
  86                         $this->setPosition($model, $model->id, $position);
  87                 }
  88         }
  89
  90         function beforeDelete(&$model) {
  91                 extract($this->_config($model));
  92                 if ($enabled) {
  93                         $model->__fixPosition = $this->position($model);
  94                 }
  95                 return true;
  96         }
  97
  98         function afterDelete(&$model) {
  99                 extract($this->_config($model));
 100                 if (!$enabled) {
 101                         return true;
 102                 }
 103                 $fullField = $this->_fullField($model);
 104                 $position = $model->__fixPosition;
 105                 $model->__fixPosition = null;
 106                 $model->updateAll(array($fullField => "$fullField - 1"), array("$fullField >=" => $position));
 107         }
 108
 109         function moveTop(&$model, $id = null) {
 110                 $this->disableSortable($model);
 111                 if ($id) {
 112                         $model->id = $id;
 113                 }
 114                 extract($this->_config($model));
 115                 $position = $this->position($model);
 116                 $clusterId = $this->_clusterId($model);
 117                 $fullField = $this->_fullField($model);
 118
 119                 if ($position > 1) {
 120                         $newPosition = 1;
 121                         $conditions = $this->_conditions($model, $clusterId, array("$fullField <=" => $position, "$fullField >=" => $newPosition));
 122                         $model->updateAll(array($fullField => "$fullField + 1"), $conditions);
 123                         $model->saveField($field, $newPosition);
 124                 }
 125                 $this->enableSortable($model);
 126                 return true;
 127         }
 128
 129         function moveUp(&$model, $id = null, $step = 1) {
 130                 $this->disableSortable($model);
 131                 if ($id) {
 132                         $model->id = $id;
 133                 }
 134                 extract($this->_config($model));
 135                 $position = $this->position($model);
 136                 $clusterId = $this->_clusterId($model);
 137                 $fullField = $this->_fullField($model);
 138
 139                 if ($position > 1) {
 140                         $newPosition = $position - $step;
 141                         if ($newPosition < 1) {
 142                                 $newPosition = 1;
 143                         }
 144                         $conditions = $this->_conditions($model, $clusterId, array("$fullField <=" => $position, "$fullField >=" => $newPosition));
 145                         $model->updateAll(array($fullField => "$fullField + 1"), $conditions);
 146                         $model->saveField($field, $newPosition);
 147                 }
 148                 $this->enableSortable($model);
 149                 return true;
 150         }
 151
 152         function moveDown(&$model, $id = null, $step = 1) {
 153                 $this->disableSortable($model);
 154                 if ($id) {
 155                         $model->id = $id;
 156                 }
 157                 extract($this->_config($model));
 158                 $position = $this->position($model);
 159                 $clusterId = $this->_clusterId($model);
 160                 $id = $model->id;
 161                 $model->id = null;
 162                 $last = $this->lastPosition($model, $clusterId);
 163                 $fullField = $this->_fullField($model);
 164
 165                 if ($position < $last) {
 166                         $newPosition = $position + $step;
 167                         if ($newPosition > $last) {
 168                                 $newPosition = $last;
 169                         }
 170                         $conditions = $this->_conditions($model, $clusterId, array("$fullField >=" => $position, "$fullField <=" => $newPosition));
 171                         $model->updateAll(array($fullField => "$fullField - 1"), $conditions);
 172                         $model->id = $id;
 173                         $model->saveField($field, $newPosition);
 174                 }
 175                 $this->enableSortable($model);
 176                 return true;
 177         }
 178
 179         function moveBottom(&$model, $id = null) {
 180                 $this->disableSortable($model);
 181                 if ($id) {
 182                         $model->id = $id;
 183                 }
 184                 extract($this->_config($model));
 185
 186                 $position = $this->position($model);
 187                 $clusterId = $this->_clusterId($model);
 188                 $id = $model->id;
 189                 $model->id = null;
 190                 $last = $this->lastPosition($model, $clusterId);
 191                 $fullField = $this->_fullField($model);
 192
 193                 if ($position < $last) {
 194                         $newPosition = $last;
 195                         $conditions = $this->_conditions($model, $clusterId, array("$fullField >=" => $position, "$fullField <=" => $newPosition));
 196                         $model->updateAll(array($fullField => "$fullField - 1"), $conditions);
 197                         $model->id = $id;
 198                         $model->saveField($field, $newPosition);
 199                 }
 200                 $this->enableSortable($model);
 201                 return true;
 202         }
 203
 204         function setPosition(&$model, $id = null, $destination) {
 205                 $this->disableSortable($model);
 206                 if ($id) {
 207                         $model->id = $id;
 208                 }
 209                 extract($this->_config($model));
 210                 $position = $this->position($model);
 211                 $id = $model->id;
 212                 $model->id = null;
 213                 $delta = $position - $destination;
 214
 215                 if ($position > $destination) {
 216                         $this->moveUp($model, $id, $delta);
 217                 } elseif ($position < $destination) {
 218                         $this->moveDown($model, $id, -$delta);
 219                 }
 220                 $this->enableSortable($model);
 221                 return true;
 222         }
 223
 224         function disableSortable(&$model) {
 225                 $this->_config($model, array('enabled' => false));
 226         }
 227
 228         function enableSortable(&$model) {
 229                 $this->_config($model, array('enabled' => true));
 230         }
 231
 232         function position(&$model, $id = null) {
 233                 if ($id) {
 234                         $model->id = $id;
 235                 }
 236                 return $model->field($this->_config($model, 'field'));
 237         }
 238
 239         function _clusterId(&$model, $id = null) {
 240                 $cluster = $this->_config($model, 'cluster');
 241
 242                 if ($cluster === false) {
 243                         return null;
 244                 }
 245                 if ($id) {
 246                         $model->id = $id;
 247                 }
 248                 return $model->field($cluster);
 249         }
 250
 251         function lastPosition(&$model, $clusterId = null) {
 252                 $id = $model->id;
 253                 $model->id = null;
 254                 $field = $this->_config($model, 'field');
 255                 $fields = array($field);
 256                 $order = array($field => 'DESC');
 257                 $conditions = $this->_conditions($model, $clusterId);
 258                 $last = $model->find('first',  compact('fields', 'order', 'conditions'));
 259                 $model->id = $id;
 260
 261                 if (!empty($last)) {
 262                         return current(current($last));
 263                 }
 264
 265                 return false;
 266         }
 267
 268         function _conditions(&$model, $clusterId = null, $conditions = array()) {
 269                 $cluster = $this->_config($model, 'cluster');
 270
 271                 if (($cluster !== false) && !is_null($clusterId)) {
 272                         $conditions = array_merge($conditions, array($cluster => $clusterId));
 273                 }
 274
 275                 return $conditions;
 276         }
 277
 278         function findByPosition(&$model, $position, $clusterId = null) {
 279                 $field = $this->_fullField($model);
 280                 return $model->find($this->_conditions($model, $clusterId, array($field => $position)));
 281         }
 282
 283 }
 284
 285 ?>