Deps needed to be stripped before exploding

[AOOS.git] / AOOSModel.php

<?php
define("AOOSMODEL_TYPE_STRING"         , 1);
define("AOOSMODEL_TYPE_INTEGER"        , 2);
define("AOOSMODEL_TYPE_ARRAY"          , 4);
define("AOOSMODEL_TYPE_AOOSMODEL"      , 8);
define("AOOSMODEL_TYPE_UNKNOWN"        , 16);
define("AOOSMODEL_TYPE_EMAIL"           , 32);

define("AOOSMODEL_PROP_DATA_INCREASING"     , 1);
define("AOOSMODEL_PROP_DATA_QUOTES"         , 4);
define("AOOSMODEL_PROP_DATA_ESCAPE"         , 8);
define("AOOSMODEL_PROP_DATA_NOHTML"         , 16);
define("AOOSMODEL_PROP_DATA_HASH"           , 32);
define("AOOSMODEL_PROP_DATA_STRIP"          , 64);

define("AOOSMODEL_PROP_GUI_NOTEDITABLE"     , 1<<8);
define("AOOSMODEL_PROP_GUI_PRIVATE"         , 2<<8);
define("AOOSMODEL_PROP_FROM_DATABASE"       , 4<<8);
define("AOOSMODEL_PROP_UNIQUE"              , 8<<8);

/**
 * Second-generation AOOSModel
 * On the good side:
 * - The addition of properties allowing easy per-column settings
 * @author Sebastian Skejø
 */
class AOOSModel extends AOOSModule {
    const INTERN_DATA_UPDATED   = 1;
    const INTERN_DATA_REMOVED   = 2;
    const INTERN_DATA_INSERTED  = 3;

    private $_data      = array();
    private $_index     = array();
    private $_props     = array();
    private $_types     = array();
    private $_intern    = array();

    private $_source                = null;
    private $_table                 = null;
    private $_connection            = null;


    private $_rows      = 0;
    private $_curRow    = 0;
    private $_curCol    = 0;

    /**
     * Standard destructor
     */
    public function __destruct() {
    }

    /**
     * Transforms to a printable string
     */
    public function __toString() {
        return nl2br(str_replace(" ", "&nbsp;", print_r($this->data(), true)));
    }

    /**
     * Appends a row to the end of the model with 0 as values unless $values is 
     * provided. Appended rows will NOT be inserted into database when AOOSModel::save() is called.
     * @param $values If given null an empty row will be added. Otherwise an 
     * associative array is assumed.
     * @param $ignore Flags to ignores when inserting data.
     * @see insert
     * @return true
     */
    public function appendRow($values = null, $ignore = 0) {
        $this->_data[] = new AOOSModelRow($this, $this->columnIndex()); //array_fill_keys($this->_index, 0);
        $this->_rows++;
        if (is_array($values)) {
            $index = $this->columnIndex();
            $last = $this->rows()-1;
            foreach ($index as $i) {
                if (in_array($i, array_keys($values))) {
                    $this->setData($last, $i, $values[$i], $ignore);
                }
                else {
                    $this->setData($last, $i, null, $ignore);
                }
            }
        }
        return true;
    }

    /**
     * Sets the data of a single field. Fields updated this way will NOT be 
     * updated in the database when AOOSModel::save() is called. If the type of 
     * the inserted data doesn't match the column type, an AOOSTypeException is 
     * thrown. If $row is less than 0 or greater that the row count, an 
     * AOOSException is throw.
     * @param $row An integer representing the row
     * @param $column A column index
     * @param $value Value
     * @param $ignore Flags to ignore when inserting data
     * @return bool
     */
    public function setData($row, $column, $value, $ignore = 0) {
        if (!$this->inColumnIndex($column)) {
            // Exception?
            return false;
        }
        $props  = $this->_props[$column];
        $type   = $this->_types[$column];

        try {
             $this->_checkType($value, $type);
        }
        catch (AOOSTypeException $e) {
            throw $e;
            return false;
        }

        try {
            $value = $this->_fixDataProps($column, $value, $props, $ignore);
        }
        catch (AOOSException $e) {
            throw $e;
            return false;
        }

        // XXX
        if ($row < 0 || $row > $this->rows()) {
            throw new AOOSException($this->core(), $this->tr("row_out_of_bounds"));
            return false;
        }
        $this->_data[$row]->setData($column, $value);
        return true;
    }

    /**
     */
    public function setDataRowSingle($row, $column, $value, $ignore = 0) {
        if (!$this->inColumnIndex($column)) {
            // Exception?
            return false;
        }
        $props  = $this->_props[$column];
        $type   = $this->_types[$column];

        try {
             $this->_checkType($value, $type);
        }
        catch (AOOSTypeException $e) {
            throw $e;
            return false;
        }

        try {
            $value = $this->_fixDataProps($column, $value, $props, $ignore);
        }
        catch (AOOSException $e) {
            throw $e;
            return false;
        }

        $row->setData($column, $value);
        return true;
    }

    public function setDataRow($row, $values, $ignore = 0) {
        if (is_int($row)) {
            $row = $this->getRow($row);
        }

        foreach ($values as $key => $value) {
            $this->setDataRowSingle($row, $key, $value, $ignore);
        }
    }

    private function _checkType($value, $type) {
        // Only type-props
        $correct = false;
        $continue = true;
        if ($type & AOOSMODEL_TYPE_UNKNOWN) {
            $correct = true;
            $continue = false;
        }
        elseif($continue && $type & AOOSMODEL_TYPE_STRING) {
            $correct = is_string($value);
            $continue = false;
        }
        elseif($continue && $type & AOOSMODEL_TYPE_INTEGER) {
            $correct = is_integer((int)$value);
            $continue = false;
        }
        elseif($continue && $type & AOOSMODEL_TYPE_ARRAY) {
            $correct = is_array($value);
            $continue = false;
        }
        elseif($continue && $type & AOOSMODEL_TYPE_AOOSMODEL) {
            $correct = $value instanceof AOOSModel;
            $continue = false;
        }
        elseif($continue && $type & AOOSMODEL_TYPE_EMAIL) {
            $correct = preg_match("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$", $value);
            $continue = false;
        }

        if (!$correct) {
            throw new AOOSTypeException($this->core(), "", "When inserting ".$value);
            return false;
        }
        return true;
    }

    private function _fixDataProps($col, $value, $props, $ignore = 0) {
        // Only data props
        if ($props & AOOSMODEL_PROP_DATA_NOHTML && !(AOOSMODEL_PROP_DATA_NOHTML & $ignore)) {
            $value = htmlspecialchars($value);
        }

        if ($props & AOOSMODEL_PROP_DATA_ESCAPE && !(AOOSMODEL_PROP_DATA_ESCAPE & $ignore)) {
            $value = mysql_real_escape_string($value);
        }

        if ($props & AOOSMODEL_PROP_DATA_STRIP && !(AOOSMODEL_PROP_DATA_STRIP & $ignore)) {
            $value = rtrim(trim($value));
        }

        if ($props & AOOSMODEL_PROP_DATA_HASH && !(AOOSMODEL_PROP_DATA_HASH & $ignore)) {
            $value = hash("sha256", $value);
        }
        if ($props & AOOSMODEL_PROP_DATA_QUOTES && !(AOOSMODEL_PROP_DATA_QUOTES & $ignore)) {
            $first = substr($value, 0,1);
            if ($first != "'" && $first != '"' && $first != substr($value, -1)) {
                $value = "'".$value."'";
            }
        }
        if ($props & AOOSMODEL_PROP_UNIQUE && !(AOOSMODEL_PROP_UNIQUE & $ignore)) {
            $cols = $this->getColumn($col);
            if (in_array($value, $cols)) {
                throw new AOOSException($this->core(), $this->tr("not_unique"));
                return false;
            }
        }
        if ($props & AOOSMODEL_PROP_DATA_INCREASING && !(AOOSMODEL_PROP_DATA_INCREASING & $ignore)) {
            if ($this->rows() == 1) {
                $value = 0;
            }
            else {
                $r = $this->getRow(-2);
                $value = $r->$col + 1;
            }
        }

        return $value;
    }

    /**
     * Returns a to-dimensional array containing the data.
     * @return array
     */
    public function data() {
        return $this->_data;
    }

    /**
     * Returns the column with the name $column
     * @param $column The name of the column
     * @param $offset Column values starts at this row
     * @param $length The array of column values has this length
     * @return array
     */
    public function getColumn($column, $start = 0, $length = null) {
        if (!$this->inColumnIndex($column)) {
            return false;
        }
        if ($length === null) {
            $length = $this->rows();
        }
        if ($start < 0) {
            $start = $this->rows() + $start;
        }
        $a = array();
        for ($i= $start; $length > 0; $length--) {
            $r = $this->getRow($i);
            $a[] = $r[$column];
            $i++;
        }
        return $a;
    }

    /**
     * Returns an AOOSModelRow object
     * @param $row The row number.
     * @return AOOSModel
     */
    public function getRow($row) {
        if ($row < 0) {
            $row = $this->rows() + $row;
        }
        return $this->_data[$row];
    }

    /**
     * Returns the row number
     * @param $row The AOOSModelRow object
     * @return integer
     */
/*    public function getRowNumber($row) {
        foreach*/

    /**
     * Returns the number of rows
     * @return integer
     */
    public function rows() {
        return $this->_rows;
    }

    /**
     * Returns only columns which match the given properties
     * @param $props Properties
     */
    public function filter($props = 0, $offset = 0, $length = null) {
        if ($length === null) {
            $length = $this->rows();
        }
        $a = array();
        for ($i = $offset; $length > 0; $length--) {
            $r = $this->getRow($i);
            $ra = array();
            foreach ($this->_props as $col => $colprops) {
                if ($colprops & $props) {
                    $ra[$col] = $r[$col];
                }
            }
            $a[] = $ra;
            $i++;
        }
        return $a;
    }

    /**
     * Returns the first row from $start which matches $match
     * @param $match An associative array in which keys should match column 
     * indices and values should match values. Values of the match array can be 
     * regular expressions.
     * @param $start An integer representing the row from which search should. 
     * Defaults to 0.
     * start
     * @return Integer
     * @sa findAll
     */
    public function find($match, $start = 0) {
        if ($match && !($match = $this->_fixWhere($match))) {
            return false;
        }
        for ($i = $start; $i < $this->rows(); $i++) {
            $r = $this->getRow($i);
            if ($r->match($match)) {
                $this->_lastMatchRow = $i;
                return $r;
            }
        }
        return false;
    }

    /**
     * Returns all rows which match $match, starting from $start
     * @param $match The row to match against.
     * @param $start An integer representing the row from which to start from. 
     * Defaults to 0.
     * @return An array containing integers.
     * @sa find
     */
    public function findAll($match, $start = 0, $length = null) {
        if ($length === null) {
            $length = $this->rows();
        }
        $i = $start;
        $a = array();
        while (true) {
            if (false === ($r = $this->find($match, $i))) {
                break;
            }
            $a[] = $r;
            $i = $this->_lastMatchRow+1;
        }
        $a = array_slice($a, 0, $length);
        return count($a) ? $a : false;
    }

    /**
     * Sets a columns properties to be $property
     * @param $column Column index name
     * @param $type The type of the column
     * @param $property An integer representing the property
     * @return true
     */
    public function setProperty($column, $type, $property) {
        if (!$this->inColumnIndex($column)) {
            // Exception?
            return false;
        }
        if ($property & AOOSMODEL_PROP_FROM_DATABASE && !($type & AOOSMODEL_TYPE_INTEGER)) {
            $property |= AOOSMODEL_PROP_DATA_QUOTES;
        }
        $this->_types[$column] = $type;
        $this->_props[$column] = $property;
        return true;
    }

    /**
     * Returns the properties of the given $column
     * @param $column Name of the column
     * @return integer
     */
    public function getProperty($column) {
        if (!$this->inColumnIndex($column)) {
            return false;
        }
        return $this->_props[$column];
    }

    /**
     * Toggles a given property using the ... operation.
     * @param $column Column index name
     * @param $property An integer representing the property to toggle
     * @return true
     */
    public function toggleProperty($column, $property) {
        if (!$this->inColumnIndex($column)) {
            // Exception?
            return false;
        }
        if ($property & AOOSMODEL_PROP_FROM_DATABASE) {
            $property |= AOOSMODEL_PROP_DATA_QUOTES;
        }
        $this->_props[$column] ^= $property;
        return true;
    }

    /**
     * Returns the type of the given $column
     * @param $column Name of the column
     * @return string
     */
    public function getType($column) {
        if (!$this->inColumnIndex($column)) {
            // Exception?
            return false;
        }
        $type = $this->_types[$column];
        $typename = 0;
        $continue = true;
        if ($type & AOOSMODEL_TYPE_UNKNOWN) {
            $typename = "UNKNOWN";
            $continue = false;
        }
        elseif($continue && $type & AOOSMODEL_TYPE_STRING) {
            $typename = "STRING";
            $continue = false;
        }
        elseif($continue && $type & AOOSMODEL_TYPE_INTEGER) {
            $typename = "INTEGER";
            $continue = false;
        }
        elseif($continue && $type & AOOSMODEL_TYPE_ARRAY) {
            $typename = "ARRAY";
            $continue = false;
        }
        elseif($continue && $type & AOOSMODEL_TYPE_AOOSMODEL) {
            $typename = "AOOSModel";
            $continue = false;
        }

        return $typename;
    }
        
    /**
     * Returns true if the given $property is set, otherwise return false
     * @param $column Column index name
     * @param $property An integer representing the property
     * @return boolean
     */
    public function checkProperty($column, $property) {
        if (!$this->inColumnIndex($column)) {
            // Exception?
            return false;
        }
        if ($this->_props[$column] & $property) {
            return true;
        }
        return false;
    }

    /**
     * Sets the column index to be $index. Note: this resets the properties AND 
     * data
     * If $index isn't an array an AOOSException is thrown.
     * @param $index An array containing the column indices
     * @return true
     */
    public function setColumnIndex($index) {
        if (!is_array($index)) {
            throw new AOOSTypeException($this->core(), $this->tr("not_array"));
            return false;
        }
        $this->_index = $index;
        $this->_props = array_fill_keys($index, 0);
        return true;
    }

    /**
     * Returns the column index
     * @return array
     */
    public function columnIndex() { return $this->_index; }

    /**
     * Returns true if the given $index is in the column index. Otherwise returns
     * false.
     * @param $index Name of the index
     * @return bool
     */
    public function inColumnIndex($index) {
        return in_array($index, $this->_index);
    }


    /**
     * Sets the table from in which data is contained
     * @param $table Table name
     * @return true
     */
    public function setTable($table) {
        $this->_table = $this->core()->getSetting("DBPrefix").$table;
        return true;
    }

    /**
     * Returns the table name
     * @return string
     */
    public function table() {
        return $this->_table;
    }

    /**
     * Sets the type of source from which data is fetched, inserted and deleted.
     * @param $source The type of source, e.g. "mysql".
     * @return true
     */
    public function setSource($source) {
        $this->_source = strtolower($source);
        return true;
    }

    /**
     * Returns the type of source in a string
     * @return string
     */
    public function source() {
        return $this->_source;
    }

    /**
     * Populates the model. If the model is successfully populated $this is 
     * returned. Otherwise false is returned.
     * @param $where An associative array containing the where-keys and values. 
     * This means that array("FOO" => "BAR") will expand to WHERE FOO = 'BAR'
     * @param $order An array with two rows. First row defines the row to order 
     * by, the second row defines the order. This means that array("BAZ", 
     * "DESC") will expand to ORDER BY BAZ DESC.
     * @param $limit An array with two rows, where the first row is the start 
     * limit and the second row is the end limit. This means that array(0,2) 
     * will expand into LIMIT 0,2
     * @return 
     */
    public function populate($where = null, $order = null, $limit = null) {
        $this->_reset();
        if ($where && !($where = $this->_fixWhere($where))) {
            return false;
        }
        $fields = array();
        foreach ($this->_props as $col => $prop) {
            if ($prop & AOOSMODEL_PROP_FROM_DATABASE) {
                $fields[] = $col;
            }
        }
        if (false === ($values = $this->_connection()->select($fields, $where, $order, $limit))) {
            throw new AOOSException($this->core(), $this->tr("couldnt_select_values"));
            return false;
        }
        foreach ($values as $row) {
            $this->appendRow($row, AOOSMODEL_PROP_DATA_HASH);
        }
        return $this;
    }

    /**
     * Inserts the given array into the model. Note that data isn't saved to 
     * database before calling AOOSModel::save()
     * @param $values An associative array, in which the array keys corresponds 
     * to column indices and the array values are the value that should be 
     * inserted.
     */
    public function insert($values) {
        $this->appendRow($values);
        $values = $this->filter(AOOSMODEL_PROP_FROM_DATABASE, -1, 1);
        $this->_intern[] = array(AOOSModel::INTERN_DATA_INSERTED, $values);
        return true;
    }

    /**
     * Deletes the row which matches $where. As with AOOSModel::insert() and 
     * AOOSModel::update(), changes aren't saved to database before AOOSModel::save() is 
     * called. An AOOSException is thrown if no rows match $where.
     * @param $where Either an associative array containing the where-keys and values. 
     * This means that array("FOO" => "BAR") will expand to WHERE FOO = 'BAR' or 
     * an integer representing a row number.
     * @param $limit An array with two rows, where the first row is the start 
     * limit and the second row is the end limit. This means that array(0,2) 
     * will expand into LIMIT 0,2 or a single integer
     */
    public function remove($where, $limit = null) {
        $limit = $this->_fixLimit($limit);
        if (is_array($where)) {
            if (!($w = $this->findAll($where, $limit[0], $limit[1]))) {
                throw new AOOSException($this->core(), $this->tr("no_rows_found"), "", true, 2);
                return false;
            }
        }
        elseif (is_integer($where)) {
            $w = array($where);
            $where = $this->getRow($where);
        }
        else {
            return false;
        }
        foreach($w as $row) {
            unset($row);//$this->_data[$nr]);
            $this->_rows--;
        }
        $where = $this->_fixWhere($where);
        $this->_intern[] = array(AOOSModel::INTERN_DATA_REMOVED, $where, $limit);
        return true;
    }

    /**
     * Updates the row that matches $where with the values, $values. Changes 
     * aren't saved to database until AOOSModel::save() is called..
     * @param $values An associative array, in which the array keys matches 
     * column indices and the array values are the values to use to update the 
     * selected row
     * @param $where Either an associative array containing the where-keys and values. 
     * This means that array("FOO" => "BAR") will expand to WHERE FOO = 'BAR' or 
     * an integer representing a row number
     * @param $limit An array with two rows, where the first row is the start 
     * limit and the second row is the end limit. This means that array(0,2) 
     * will expand into LIMIT 0,2
     */
    public function update($values, $where, $limit = null) {
        $limit = $this->_fixLimit($limit);
        $w = $this->findAll($where, $limit[0], $limit[1]);
        foreach ($w as $row) {
            $this->setDataRow($row, $values);
        }
        $where = $this->_fixWhere($where);
        $values = $this->_fixWhere($values);
        $this->_intern[] = array(AOOSModel::INTERN_DATA_UPDATED, $values, $where, $limit);
        return 0;
    }

    /**
     * Creates the model as a new table in the database.
     * @return bool
     */
    public function create() {
        if (!$this->_connection()) {
            return false;
        }
        return $this->_connection()->create($this->_types, $this->_props);
    }

    /**
     * Creates the model as a new table in the database.
     * @return bool
     */
    public function drop() {
        if (!$this->_connection()) {
            return false;
        }
        return $this->_connection()->drop();
    }

    /**
     * Saves the changes caused by AOOSModel::insert(), AOOSModel::remove() or 
     * AOOSModel::update()
     */
    public function save() {
        if (!$this->_connection()) {
            return false;
        }
        foreach ($this->_intern as $key => $row) {
            switch($row[0]) {
            case(AOOSModel::INTERN_DATA_INSERTED):
                if (!$this->_connection()->insert($row[1])) {
                    return false;
                }
                break;
            case(AOOSModel::INTERN_DATA_REMOVED):
                if (!$this->_connection()->remove($row[1], $row[2])) {
                    return false;
                }
            case(AOOSModel::INTERN_DATA_UPDATED):
                if (!$this->_connection()->update($row[1], $row[2], $row[3])) {
                    return false;
                }
            }
            unset($this->_intern[$key]);
        }
        return true;
    }

    private function _connect() {
        if ($this->_connection) {
            return $this->_connection;
        }
        if (!$this->source() || !$this->table()) {
            throw new AOOSException($this->core(), $this->tr("no_source_or_table_set"));
            return false;
        }
        switch ($this->source()) {
        case("mysql"):
            require_once("lib/AOOSMysqlInterface.php");
            $this->_connection = new AOOSMysqlInterface($this->core());
            break;
        }
        $this->_connection->setTable($this->table());
    }

    private function _connection() {
        if (!$this->_connection) {
            try {
                $this->_connect();
            }
            catch (AOOSException $e) {
                throw $e;
                return false;
            }
        }
        return $this->_connection;
    }

    /**
     * \internal Fixes where clauses so that the given values are correctly 
     * formatted according to the properties for their column
     */
    private function _fixWhere($where) {
        $ci = $this->columnIndex();

        if (!is_array($where)) {
            return false;
        }

        foreach ($where as $key => $value) {
            if (!in_array($key, $ci)) {
                unset($where[$ci]);
                continue;
            }
            $where[$key] = $this->_fixDataProps($key, $value, $this->getProperty($key));
        }
        return $where;
    }

    /**
     * \internal Fixes a limit
     */
    private function _fixLimit($l) {
        $limit = array(0,$this->rows());
        if (is_integer($l)) {
            $limit[1] = $l;
        }
        elseif(is_array($l)) {
            $limit = $l;
        }
        return $limit;
    }

    private function _reset() {
        $this->_data = array();
        $this->_connect();
        $this->_rows = 0;
    }

    /**
     * Dummy function
     */
    public function dataModelDefinition() { return 0; }

    static public function stripQuotes($string) {
        if (substr($string,0,1) == "'") {
            $string = substr($string,1,strlen($string)-2);
        }
        return $string;
    }
}


class AOOSModelRow extends AOOSModule implements ArrayAccess {
    private $_data          = array();
    private $_columnIndex   = array();

    public function __construct($parent, $columnIndex) {
        parent::__construct($parent);
        $this->_columnIndex = $columnIndex;
        $this->_data = array_fill_keys($columnIndex, 0);
    }

    public function dataModelDefinition() {
        return 0;
    }

    public function __set($name, $value) {
        return $this->parent()->setDataRow($this, $name, $value);
    }

    public function __get($name) {
        return $this->_data[$name];
    }

    public function __toString() {
        $str = "Row:\n";
        foreach ($this->_data as $key => $value) {
            $str .= "\t[".$key."] => ".$value."\n";
        }
        return $str;
    }

    public function columnIndex() {
        return $this->_columnIndex;
    }

    // Array Access
    public function offsetExists($offset) {
        return in_array($offset, array_keys($_data));
    }

    public function offsetSet($offset, $value) {
        $this->$offset = $value;
    }

    public function offsetGet($offset) {
        return $this->$offset;
    }

    public function offsetUnset($offset) {
        unset($this->_data[$offset]);
    }

    /**
     * Simply inserts the data into the row. This should NOT be used since it 
     * ignores column flags completely
     */
    public function setData($name, $value) {
        $this->_data[$name] = $value;
        return true;
    }

    public function save() {
        return $this->parent()->save();
    }

    public function match($match) {
        foreach ($match as $key => $value) {
            if (!preg_match($this->_data[$key], "/".$value."/")) {
                return false;
            }
        }
        return true;
    }
}
// vim: textwidth=80


?>