AOOSStorageDevice.php

   1 <?php
   2 require_once("AOOSException.php");
   3 require_once("AOOSModule.php");
   4
   5 /**
   6  * AOOSStorageDevice
   7  * Provides an interface for handling data on database or file basis.
   8  * @author Sebastian Skejø
   9  */
  10 class AOOSStorageDevice extends AOOSModule
  11 {
  12     private $_storageObject = null;
  13     private $_table = null;
  14     private $_sort = null;
  15
  16     /**
  17      * Check wether $storageObject() is set
  18      */
  19     private function _checkDevice()
  20     {
  21         if ($this->storageObject() == null)
  22         {
  23             throw new AOOSException($this->core(), $this->tr("storage_type_not_set"));
  24             return false;
  25         }
  26         return true;
  27     }
  28
  29     /**
  30      * Check if we can use $array as an array
  31      */
  32     private function _checkArray($array)
  33     {
  34         // Is it actually an array?
  35         if (!is_array($array))
  36         {
  37             throw new AOOSException($this->core(), $this->tr("not_array"));
  38             return false;
  39         }
  40
  41         // Check if length of array keys and array values match
  42         if (count(array_keys($array)) != count(array_values($array)))
  43         {
  44             throw new AOOSException($this->core(), $this->tr("array_keys_value_different_length"));
  45             return false;
  46         }
  47         return true;
  48     }
  49
  50     /**
  51      * Check both $key and $value to see if we can use them as a value pair
  52      */
  53     private function _checkValue($key, $value)
  54     {
  55         // Are we dealing with strings?
  56         if ((!is_string($key) && !is_int($key)) || (!is_string($key) && !is_int($value)))
  57         {
  58             throw new AOOSException($this->core(), $this->tr("not_string_or_int"), "<strong>Key:</strong>".$key."<br /><strong>Value:</strong> ".$value);
  59             return false;
  60         }
  61
  62         // Are the strings empty?
  63         if (empty($key) || empty($value))
  64         {
  65             throw new AOOSException($this->core(), $this->tr("strings_empty"));
  66             return false;
  67         }
  68
  69         // Ok, we completed the tests - let's return true!
  70         return true;
  71     }
  72
  73     /**
  74      * Check if we have a valid model
  75      */
  76     private function _checkModel(&$model)
  77     {
  78         if (!$model instanceof AOOSModel)
  79         {
  80             throw new AOOSException($this->core(), $this->tr("not_AOOSModel"));
  81             return false;
  82         }
  83         return true;
  84     }
  85
  86     /**
  87      * Check if the given where-clause can be used as a where clause
  88      */
  89     private function _checkWhere(&$where)
  90     {
  91         if (is_array($where))
  92         {
  93             $tmp = array();
  94             foreach ($where as $key => $value)
  95             {
  96                 $tmp[] = sprintf("%s = %s", $key, $value);
  97             }
  98             $where = implode(" AND ", $tmp);
  99             return true;
 100         }
 101
 102         // Is it a string? We know it isn't an array
 103         if (!is_string($where))
 104         {
 105             throw new AOOSException($this->core(), $this->tr("not_string_or_array"));
 106             return false;
 107         }
 108
 109         // Does it match a pattern?
 110         if (!preg_match("/[[:alnum:]]+\s*=\s*[[:alnum:]]+/", $where))
 111         {
 112             throw new AOOSException($this->core(), $this->tr("where_not_valid"));
 113             return false;
 114         }
 115
 116         return true;
 117     }
 118
 119     /**
 120      * Check if the given limit-clause is valid
 121      */
 122     private function _checkLimit($limit)
 123     {
 124         if (!is_string($limit))
 125         {
 126             throw new AOOSException($this->core(), $this->tr("not_string"));
 127             return false;
 128         }
 129
 130         // Does it match a limit-pattern?
 131         if (!preg_match("/[0-9]+\s*,\s*[0-9]+/", $limit))
 132         {
 133             throw new AOOSException($this->core(), $this->tr("limit_not_valid"));
 134             return false;
 135         }
 136
 137         return true;
 138     }
 139
 140     /**
 141      * Sets the table in which data should be added, updated or deleted from
 142      * @param string $table Table name
 143      * @return bool
 144      */
 145     public function setTable($table)
 146     {
 147         if (!$this->_checkDevice())
 148         {
 149             return false;
 150         }
 151
 152         if (!is_string($table))
 153         {
 154             throw new AOOSException($this->core(), $this->tr("not_string"));
 155             return false;
 156         }
 157
 158         $this->_table = $table;
 159         $this->storageObject()->setTable($table);
 160         return true;
 161     }
 162
 163     /**
 164      * Sets type of storage device
 165      * @param string $type Type of storage device
 166      * @return bool
 167      */
 168     public function setStorageType($type)
 169     {
 170         if (!is_string($type))
 171         {
 172             throw new AOOSException($this->core(), $this->tr("not_string"));
 173             return false;
 174         }
 175
 176         $type = strtolower($type);
 177         switch ($type)
 178         {
 179         case ("mysql"):
 180             require_once("lib/AOOSStorageDeviceMySQL.php");
 181             $this->_storageObject = new AOOSStorageDeviceMySQL($this->core());
 182             break;
 183         default:
 184             throw new AOOSException($this->core(), $this->tr("storage_type_not_supported"));
 185             return false;
 186         }
 187     }
 188
 189     /**
 190      * Returns the storage object
 191      * @return AOOSStorageDevice
 192      */
 193     public function storageObject()
 194     {
 195         return $this->_storageObject;
 196     }
 197
 198     /**
 199      * Inserts a model to $this->_table
 200      * @param AOOSModel $model Model
 201      * @return bool
 202      */
 203     public function insertModel(&$model)
 204     {
 205         if (!$this->_checkDevice() || !$this->_checkModel($model))
 206         {
 207             return false;
 208         }
 209
 210         $data       = $model->data(true);
 211         $result     = false;
 212         $escape     = $model->escape() ? null : true;
 213         foreach ($data as $row)
 214         {
 215             $result = $this->insertArray($row, $escape);
 216         }
 217
 218         return $result;
 219     }
 220
 221     /**
 222      * Inserts an array to $this->_table
 223      * @param array $a Array
 224      * @return bool
 225      */
 226     public function insertArray($array, $escape = null)
 227     {
 228         if (!$this->_checkDevice() || !$this->_checkArray($array))
 229         {
 230             return false;
 231         }
 232
 233         $result     = false;
 234         $result     = $this->storageObject()->insert(array_keys($array), array_values($array), $escape);
 235
 236         return $result;
 237     }
 238
 239     /**
 240      * Inserts a single value to the field of name $key in $this->_table
 241      * @param $key Fieldname
 242      * @param $value Value
 243      * @return bool
 244      */
 245     public function insertValue($key, $value, $escape = null)
 246     {
 247         if (!$this->_checkDevice() || !$this->_checkValue($key, $value))
 248         {
 249             return false;
 250         }
 251
 252         return $this->storageObject()->insert(array($key), array($value), $escape);
 253     }
 254
 255     /**
 256      * Removes a number of rows from $this->_table
 257      * @param int $count Number of rows to delete
 258      * @return bool
 259      */
 260     public function removeRows($count = 1)
 261     {
 262         if (!$this->_checkDevice())
 263         {
 264             return false;
 265         }
 266
 267         if(!is_int($count))
 268         {
 269             throw new AOOSException($this->core(), $this->tr("not_integer"));
 270             return false;
 271         }
 272     }
 273
 274     /**
 275      * Selects values from the table and puts them into a model
 276      * @param array|* $fields Fields to select
 277      * @param string $where A where-clause of the form \code field = 'value' \code
 278      * @param string $limit A limit-clause of the from \code start, end \code
 279      * @param AOOSModel $model If given a model the values will be put directly into that model.
 280      * @return AOOSModel
 281      */
 282     public function selectModel($fields, $where = null, $limit = null, $order = null, &$model = null)
 283     {
 284         $first = true;
 285
 286         if (!$this->_checkDevice())
 287         {
 288             return false;
 289         }
 290
 291         if ($fields != "*")
 292         {
 293             if (!$this->_checkArray($fields))
 294             {
 295                 return false;
 296             }
 297         }
 298
 299         // Do we have a valid where and limit-clause?
 300         if (($where != null && !$this->_checkWhere($where)) || ($limit != null && !$this->_checkLimit($limit)))
 301         {
 302             return false;
 303         }
 304
 305         // Make sure we have a model to put data into.
 306         if ($model == null)
 307         {
 308             $model = new AOOSModel($this->core());
 309         }
 310         elseif (!$this->_checkModel($model))
 311         {
 312             return false;
 313         }
 314
 315         while ($row = $this->storageObject()->select($fields, $where, $limit, $order, $this->_sort))
 316         {
 317             if ($first)
 318             {
 319                 $model->setColumnIndex(array_keys($row));
 320                 $first = false;
 321             }
 322             $model->addRow();
 323
 324             foreach($row as $key => $value)
 325             {
 326                 $model->setData($value, -1, $key);
 327             }
 328         }
 329
 330         if ($model->rows() == 0) {
 331             return false;
 332         }
 333         return $model;
 334     }
 335
 336     /**
 337      * Updates values in the table from the given model
 338      * @param AOOSModel $model The model
 339      * @param string|string $where A valid where clause. If "auto" is given where clauses will be made automatically.
 340      * @return bool
 341      */
 342     public function updateFromModel(&$model, $where)
 343     {
 344         if (!$this->_checkDevice() || !$this->_checkModel($model) || !$this->_checkWhere($where))
 345         {
 346             return false;
 347         }
 348
 349         if (strtolower($where) == "auto")
 350         {
 351             $f = $model->columnIndex();
 352             $keys = array();
 353             $values = $this->selectModel(array($f[0]))->getColumn($f[0], 0, $model->rows()-1);
 354             foreach ($values as $i)
 355             {
 356                 $keys[] = $f[0];
 357             }
 358             unset($f);
 359         }
 360         else
 361         {
 362             if (!$this->_checkWhere($where) && !is_array($where))
 363             {
 364                 return false;
 365             }
 366
 367             if (!is_array($where))
 368             {
 369                 $split = explode("=", $where);
 370                 $keys = array(trim(rtrim($split[0])));
 371                 $values = array(trim(rtrim($split[1])));
 372                 unset($split);
 373             }
 374             else
 375             {
 376                 $keys = array_keys($where);
 377                 $values = array_values($where);
 378             }
 379         }
 380
 381         // We only want to loop as long as we have where-clauses
 382         $c = count($keys);
 383         for ($i = 0; $i<$c; $i++)
 384         {
 385             $key = array_shift($keys);
 386             $val = array_shift($values);
 387             $w = $key." = ".$val;
 388             unset($key);
 389             unset($val);
 390             $this->updateFromArray($model->getRow($i), $w);
 391         }
 392
 393         return true;
 394     }
 395
 396     /**
 397      * Updates values in the table based on the given array.
 398      * Each element in the array is translated into a 'key = value' pair based on the array keys and values.
 399      * @param array $array The array
 400      * @param string $where A valid where clause
 401      * @return bool
 402      */
 403     public function updateFromArray(&$array, $where)
 404     {
 405         if (!$this->_checkDevice() || !$this->_checkArray($array))
 406         {
 407             return false;
 408         }
 409
 410         return $this->storageObject()->update(array_keys($array), array_values($array), $where);
 411     }
 412
 413     /**
 414      * Deletes each row from the table which is equal to a row in the model
 415      * @param AOOSModel $model The model
 416      * @param int $limit Maximum times a matching row can be deleted
 417      * @return bool
 418      */
 419     public function deleteFromModel(&$model, $limit = null)
 420     {
 421         if (!$this->_checkDevice() || !$this->_checkModel($model))
 422         {
 423             return false;
 424         }
 425
 426         for($i = 0; $i < $model->rows(); $i++)
 427         {
 428             $this->deleteFromArray($model->getRow($i), $limit);
 429         }
 430         return true;
 431     }
 432
 433     /**
 434      * Deletes a row from the table if a row matches the array in a such way that array keys matches field names and the corresponding array values matches the corresponding field values.
 435      * @param array $array The array
 436      * @param int $limit Maximum times a matching row can be deleted
 437      * @return bool
 438      */
 439     public function deleteFromArray(&$array, $limit = null)
 440     {
 441         if (!$this->_checkDevice() || !$this->_checkArray($array) || ($limit != null && !is_int($limit)))
 442         {
 443             return false;
 444         }
 445
 446         $sep = array();
 447         $merged = "";
 448         foreach($array as $key => $value)
 449         {
 450             $sep[] = $key." = ".$value;
 451         }
 452         $merged = implode(" AND ", $sep);
 453         return $this->storageObject()->delete($merged, $limit);
 454     }
 455
 456     /**
 457      * Sets a query if the selected storage type support it.
 458      * @return bool
 459      */
 460     public function setQuery($query)
 461     {
 462         if (!is_string($query))
 463         {
 464             throw new AOOSException($this->core(), $this->tr("not_string"));
 465             return false;
 466         }
 467
 468         // Check if it supports it.
 469
 470         if (!$this->storageObject()->setQuery($query))
 471         {
 472             $str = $this->tr("query").": ".$query."<br />".
 473                 $this->tr("error").": ".mysql_error();
 474             throw new AOOSException($this->core(), $this->tr("query_failed"), $str);
 475             return false;
 476         }
 477         return true;
 478     }
 479
 480     /**
 481      * Returns row count
 482      * @param string $where An optional, valid where clause
 483      * @return int|false
 484      */
 485     public function numRows($where = null)
 486     {
 487         if ($where != null && !$this->_checkWhere($where))
 488         {
 489             return false;
 490         }
 491
 492         return $this->storageObject()->numRows($where);
 493     }
 494
 495     public function setSort($sort) {
 496         $sort = strtoupper($sort);
 497         if ($sort != "ASC" && $sort != "DESC") {
 498             throw new AOOSException($this->core(), $this->tr("not_ASC_or_DESC"), "", true, 1);
 499             return false;
 500         }
 501         $this->_sort = $sort;
 502         return true;
 503     }
 504 }
 505 ?>