row.class.php

Go to the documentation of this file.

<?php
class db_row extends object implements ArrayAccess {

        protected $changes = array();

        protected $new = true;

        protected $table;

        protected $linked = array();

        protected $related = array();

        protected $i18nRows = array();

        protected function afterInit() {
                $defaultClass = 'db_row_'.$this->cfg->table->getName();
                if (get_class($this) != $defaultClass)
                        $this->cfg->overload($defaultClass);

                $this->table = $this->cfg->table;

                if (!empty($this->cfg->data)) {
                        $this->loadData($this->cfg->data);
                } else if (!empty($this->cfg->findId)) {
                        $tmp = $this->getTable()->find($this->cfg->findId);
                        if ($tmp) {
                                $this->cfg->data = $tmp->getValues('data');
                                $this->setNew(false);
                        }
                        unset($tmp);
                }
        }

        public function loadData(array $data) {
                $this->cfg->data = $data;
                if (array_key_exists($this->getTable()->getIdent(), $data) && $data[$this->getTable()->getIdent()])
                        $this->setNew(false);
                else {
                        $primary = $this->getTable()->getPrimary();
                        $p = 0;
                        foreach($primary as $pp) {
                                if (array_key_exists($pp, $data) && $data[$pp])
                                        $p++;
                        }
                        if ($p == count($primary))
                                $this->setNew(false);
                }

                $linkedKey = db::getCfg('linked');
                if (array_key_exists($linkedKey, $data)) {
                        $this->setLinked($data[$linkedKey]);
                }

                $relatedKey = db::getCfg('related');
                if (array_key_exists($relatedKey, $data)) {
                        $this->setRelated($data[$relatedKey]);
                }
        }

        public function reload($force = true) {
                if (!$this->isNew() && $this->getId() && ($force || $this->cfg->needReload)) {
                        $this->loadData($this->getTable()->find($this->getId())->getValues());
                        $this->cfg->needReload = false;
                }
        }

        public function getDb() {
                return $this->cfg->db;
        }

        public function getTable() {
                return $this->table;
        }

        public function getWhere(array $prm = array()) {
                return $this->getDb()->getWhere($prm);
        }

        public function getForm($showFields = null, array $formParam = array(), $passConfirm = true) {
                $form = factory::get('form_db', array_merge($formParam, array(
                        'table'=>$this->getTable()
                )));
                /* @var $form form_db */
                foreach($this->getTable()->getField() as $f) {
                        if ($f['name'] != $this->getTable()->getIdent() && !$f['auto'] &&
                                        (empty($showFields) || in_array($f['name'], $showFields))) {
                                $f['label'] = $this->getTable()->getLabel($f['name']);
                                $f['link'] = $this->getTable()->getLinked($f['name']);
                                $f['value'] = $this->get($f['name']);
                                $obj = $form->addFromField($f);
                                if ($passConfirm && $obj instanceof form_password) {
                                        $name = $f['name'];
                                        $f['name'].= 'Confirm';
                                        $f['label'] = $this->getTable()->getLabel($f['name']);
                                        $moreConf = $this->getTable()->getCfg()->getInArray('fields', $f['name']);
                                        if (is_array($moreConf) && array_key_exists('comment', $moreConf)) {
                                                factory::mergeCfg($f, $moreConf);
                                        }
                                        $form->addFromField($f)->addRule('equal', $obj);
                                        $form->addNotValue($f['name']);
                                        if (!$this->isNew()) {
                                                // remove the required validation for the 2 password fields but keep the equal
                                                $form->get($name)->getValid()->delRule('required');
                                                $form->get($f['name'])->getValid()->delRule('required');
                                        }
                                        if (!empty($showFields) && !in_array($f['name'], $showFields)) {
                                                $key = array_search($name, $showFields);
                                                array_splice($showFields, $key+1, 0, array($f['name']));
                                        }
                                }
                        }
                }

                $relatedUpdated = false;
                $related = $this->cfg->getInArray('data', 'related');
                foreach($this->getTable()->getRelated() as $t=>$r) {
                        if (empty($showFields) || in_array($r['tableLink'], $showFields)) {
                                $r['name'] = $r['tableLink'];
                                $r['label'] = $this->getTable()->getLabel($r['table']);
                                $r['valid'] = false;
                                $form->addFromRelated($r);
                                
                                if (!$this->getTable()->getCfg()->autoJoin) {
                                        $relatedUpdated = true;
                                        $tmp = $this->getRelated($t);
                                        $related[$r['table']] = $tmp;
                                }
                        }
                }
                
                if ($relatedUpdated)
                        $this->cfg->setInArray('data', 'related', $related);

                $form->setValues($this->getValues('flat'));

                $i18nFields = $this->getTable()->getI18nFields();
                $i18nFieldsT = array();
                
                foreach($i18nFields as $f) {
                        if ((empty($showFields) || in_array(db::getCfg('i18n').$f['name'], $showFields))) {
                                $i18nFieldsT[] = $f['name'];
                                $f['label'] = $this->getTable()->getI18nTable()->getLabel($f['name']);
                                $form->addFromField($f, true);
                        }
                }

                $form->finalize();

                if ($i18nRows = $this->getI18nRows()) {
                        $tmp = array();
                        $primary = $this->getTable()->getI18nTable()->getPrimary();
                        foreach($i18nRows as $r) {
                                $lang = $r->get($primary[1]);
                                foreach($r->getValues() as $k=>$v) {
                                        $tmp[db::getCfg('i18n').'['.$lang.']['.$k.']'] = $v;
                                }
                        }
                        $form->setValues($tmp);
                }
                $form->setBound(false);
                if (is_array($showFields) && !empty($showFields))
                        $form->reOrder($showFields);

                return $form;
        }

        public function isNew() {
                return $this->new;
        }

        public function setNew($new) {
                $this->new = (bool) $new;
        }

        public function insert() {
                $values = array_intersect_key(array_merge($this->getValues('flat'), $this->getChangesTable()), $this->getTable()->getField());
                unset($values[$this->getTable()->getIdent()]);
                $id = $this->getTable()->insert($values);
                $this->set($this->getTable()->getIdent(), $id);
                $this->setNew(false);
                $this->saveRelated();
                $this->saveI18n();
                $this->getTable()->clearCache();
                return $id;
        }

        public function save() {
                if ($this->isNew())
                        return $this->insert();

                if (!$this->hasChange())
                        return true;

                if ($changesTable = $this->getChangesTable())
                        $this->getTable()->update($changesTable, $this->whereClause());

                $this->saveRelated();
                $this->saveI18n();
                $this->getTable()->clearCache();

                return true;
        }

        public function saveRelated() {
                if ($this->isNew())
                        throw new nException('db_row::saveRelated: try to save related for a new row');

                $changes = $this->getChangesOther();
                foreach($this->getTable()->getRelated() as $r) {
                        if (array_key_exists($r['tableLink'], $changes)) {
                                $values = array(
                                        $r['fk1']['name'] => $this->getId()
                                );
                                $r['tableObj']->delete($values);
                                $hasFields = isset($r['fields']) && count($r['fields']);
                                if (($tmp = $changes[$r['tableLink']]) && is_array($tmp)) {
                                        foreach($tmp as $t) {
                                                $curValues = $values;
                                                if ($hasFields) {
                                                        foreach($t as $k=>$v) {
                                                                if ($k == db::getCfg('relatedValue'))
                                                                        $curValues[$r['fk2']['name']] = $v;
                                                                else
                                                                        $curValues[$k] = $v;
                                                        }
                                                } else
                                                        $curValues = array_merge($values, array($r['fk2']['name'] => $t));
                                                $r['tableObj']->insert($curValues);
                                        }
                                }
                        }
                }
        }

        public function saveI18n() {
                if ($this->isNew())
                        throw new nException('db_row::saveI18n: try to save i18n for a new row');

                if (!empty($this->i18nRows)) {
                        list($fkId, $lang) = ($this->getTable()->getI18nTable()->getPrimary());
                        foreach($this->i18nRows as $r) {
                                if ($r->isNew())
                                        $r->set($fkId, $this->getId());
                                $r->save();
                        }
                }
        }

        public function delete() {
                foreach($this->getTable()->getRelated() as $related) {
                        $related['tableObj']->delete(array(
                                $related['fk1']['name']=>$this->getId()
                        ));
                }
                $nb = $this->getTable()->delete($this->whereClause());
                return ($nb > 0);
        }

        public function getId() {
                return $this->get($this->getTable()->getIdent());
        }

        public function clear() {
                $this->changes = array();
        }

        public function keyExists($key) {
                return in_array($key, $this->getTable()->getCols());
        }

        public function get($key, $mode = 'flat') {
                if (db::isI18nName($key))
                        return $this->getI18n(db::unI18nName($key), $mode);

                if ($this->keyExists($key)) {
                        if ($mode == 'flat' && $this->hasChange($key))
                                $val = $this->changes[$key];
                        else
                                $val = $this->cfg->getInArray('data', $key);
                        return $this->getTable()->getField($key, 'htmlOut') ? utils::htmlOut($val) : $val;
                } else if ($val = $this->cfg->getInArray('data', $key)) {
                        return $val;
                } else if ($this->getTable()->isRelated($key)) {
                        $key = $this->getTable()->getRelatedTableName($key);
                        $values = $this->getValues($mode);
                        if (isset($values[$key]))
                                return $values[$key];
                        
                        if (!$this->getTable()->getCfg()->autoJoin && ($mode == 'flat' || $mode == 'flatReal')) {
                                $tmp = $this->getRelated($key);
                                if (count($tmp)) {
                                        $v = $this->getTable()->getRelated($key);
                                        $ret = array();
                                        $fields = explode(',', $v['fk2']['link']['fields']);
                                        $i18nFields = explode(',', $v['fk2']['link']['i18nFields']);
                                        array_walk($i18nFields, create_function('&$v', '$v = "'.db::getCfg('i18n').'".$v;'));
                                        $fields = array_filter(array_merge($fields, $i18nFields));
                                        
                                        $hasFields = isset($v['fields']) && count($v['fields']);
                                        
                                        foreach($tmp as $vv) {
                                                if ($mode == 'flat') {
                                                        if ($hasFields) {
                                                                $curVal = array(
                                                                        db::getCfg('relatedValue')=>$vv->get($v['fk2']['link']['ident'])
                                                                );
                                                                foreach($v['fields'] as $kF=>$vF) {
                                                                        $curVal[$kF] = $vv->get($kF);
                                                                }
                                                                $ret[] = $curVal;
                                                        } else {
                                                                $ret[] = $vv->get($v['fk2']['link']['ident']);
                                                        }
                                                } else {
                                                        $tmp2 = array();
                                                        foreach($fields as $f) {
                                                                if ($vv->get($f))
                                                                        $tmp2[] = $vv->get($f);
                                                        }
                                                        $ret[] = utils::htmlOut(implode($v['fk2']['link']['sep'], $tmp2));
                                                }
                                        }
                                        if (count($ret))
                                                return $ret;
                                }
                        }
                }
                return null;
        }

        public function getI18n($key, $mode='flat', $lang=null) {
                return $this->getI18nRow($lang)->get($key, $mode);
        }

        public function getI18nRow($lang = null) {
                if (is_null($lang) || !$lang)
                        $lang = request::get('lang');
                if (!array_key_exists($lang, $this->i18nRows)) {
                        if ($this->getTable()->getCfg()->i18nGetDefaultLangIfNotExist && $lang != request::getDefaultLang())
                                return $this->getI18nRow(request::getDefaultLang());
                        $primary = $this->getTable()->getI18nTable()->getPrimary();
                        $this->i18nRows[$lang] = $this->getTable()->getI18nTable()->getRow();
                        $this->i18nRows[$lang]->setValues(array(
                                $primary[0]=>$this->getId(),
                                $primary[1]=>$lang
                        ));
                }
                return $this->i18nRows[$lang];
        }

        public function getI18nRows() {
                return $this->i18nRows;
        }

        public function getValues($mode = 'data') {
                switch ($mode) {
                        case 'flat':
                        case 'flatNoRelated':
                                $data = array_merge($this->cfg->data, $this->getChanges());
                                $tmp = $this->getTable()->getCols();

                                if ($mode == 'flat') {
                                        $linked = $this->getTable()->getLinked();
                                        if (is_array($linked)) {
                                                foreach($linked as $k=>$v) {
                                                        $tmp[] = $k;
                                                        if (array_key_exists($key = $k.'_'.$v['ident'], $data))
                                                                $data[$k] = $data[$k.'_'.$v['ident']];
                                                }
                                        }
                                        if (array_key_exists('related', $data)) {
                                                foreach($this->getTable()->getRelated() as $k=>$v) {
                                                        $tmp[] = $k;
                                                        $data[$k] = array();
                                                        $hasFields = isset($v['fields']) && count($v['fields']);
                                                        foreach($data['related'][$v['fk2']['link']['table']] as $vv) {
                                                                if ($hasFields) {
                                                                        $curVal = array(
                                                                                db::getCfg('relatedValue')=>$vv[$v['fk2']['link']['ident']]
                                                                        );
                                                                        foreach($v['fields'] as $kF=>$vF) {
                                                                                $curVal[$kF] = $vv[$kF];
                                                                        }
                                                                        $data[$k][] = $curVal;
                                                                } else {
                                                                        $data[$k][] = $vv[$v['fk2']['link']['ident']];
                                                                }
                                                        }
                                                }
                                        }
                                }
                                return array_intersect_key($data, array_flip($tmp));
                                break;
                        case 'flatReal':
                        case 'flatRealNoRelated':
                                $data = array_merge($this->cfg->data, $this->getChanges());
                                $tmp = $this->getTable()->getCols();

                                if ($mode == 'flatReal' && array_key_exists('related', $data)) {
                                        foreach($this->getTable()->getRelated() as $k=>$v) {
                                                $tmp[] = $k;
                                                $data[$k] = array();
                                                $fields = explode(',', $v['fk2']['link']['fields']);
                                                $i18nFields = explode(',', $v['fk2']['link']['i18nFields']);
                                                array_walk($fields, create_function('&$v', '$v = "'.$v['fk2']['link']['table'].'_".$v;'));
                                                array_walk($i18nFields, create_function('&$v', '$v = "'.$v['fk2']['link']['table'].'_'.db::getCfg('i18n').'".$v;'));
                                                $fields = array_merge($fields, $i18nFields);
                                                foreach($data['related'][$v['fk2']['link']['table']] as $vv) {
                                                        $tmp2 = array();
                                                        foreach($fields as $f)
                                                                if (array_key_exists($f, $vv))
                                                                        $tmp2[] = $vv[$f];
                                                        $data[$k][] = implode($v['fk2']['link']['sep'], $tmp2);
                                                }
                                                $data[$k] = utils::htmlOut($data[$k]);
                                        }
                                }

                                return array_intersect_key($data, array_flip($tmp));
                                break;
                        case 'data':
                        default:
                                return $this->cfg->data;
                                break;
                }
        }

        public function getInValues($name = null, $mode = 'flatReal') {
                $tmp = $this->getValues($mode);
                if(array_key_exists($name, $tmp))
                        return $tmp[$name];
                return null;
        }

        public function set($key, $value, $force = false) {
                if ($key == db::getCfg('i18n'))
                        return $this->setI18n($value, $force);

                $field = $this->getTable()->getField($key);
                $fct = null;

                if (isset($field['comment']) && is_array($field['comment'])) {
                        foreach($field['comment'] as $k=>$v) {
                                if (!is_array($v) && strpos($v, 'fct:') === 0) {
                                        $fct = substr($v, 4);
                                        break;
                                }
                        }
                }
                if (!is_null($fct) && function_exists($fct))
                        $value = $fct($value);
                if ($force || $this->get($key) != $value)
                        $this->changes[$key] = $value;
        }

        public function setI18n(array $values, $force = false, $lg = null) {
                if (!is_null($lg) && $lg) {
                        if (count($values))
                                $this->getI18nRow($lg)->setValues($values, $force);
                } else {
                        foreach($values as $lg=>$val)
                                $this->setI18n($val, $force, $lg);
                }
        }

        public function setValues(array $values, $force = false) {
                foreach($values as $k=>$v)
                        $this->set($k, $v, $force);
        }

        public function getChanges($name = null) {
                if (is_null($name))
                        return $this->changes;

                if ($this->hasChange($name))
                        return $this->changes[$name];
                return null;
        }

        public function getChangesTable() {
                return array_intersect_key($this->getChanges(), $this->getTable()->getField());
        }

        public function getChangesOther() {
                return array_diff_key($this->getChanges(), array_merge($this->getTable()->getField(), array(db::getCfg('i18n')=>true)));
        }

        public function getChangesI18n() {
                $tmp = $this->getChanges();
                if (array_key_exists(db::getCfg('i18n'), $tmp))
                        return $tmp[db::getCfg('i18n')];
                return array();
        }

        public function hasChange($name = null) {
                if (is_null($name))
                        return !empty($this->changes) || $this->hasChange(db::getCfg('i18n'));
                else if ($name == db::getCfg('i18n')) {
                        $hasChange = false;
                        foreach($this->i18nRows as $r)
                                $hasChange = $hasChange || $r->hasChange();
                        return $hasChange;
                }
                return array_key_exists($name, $this->changes);
        }

        public function getLinked($field = null, $reload = false) {
                if ($this->getTable()->isLinked($field)) {
                        if (!array_key_exists($field, $this->linked)) {
                                $data = array();
                                if ($val = $this->get($field, 'flatReal')) {
                                        $tmp = $this->getTable()->getLinked($field);
                                        $data[$tmp['ident']] = $val;
                                } else if ($val = $this->get($field, 'flat')) {
                                        $tmp = $this->getTable()->getLinked($field);
                                        $data[$tmp['ident']] = $val;
                                }
                                $this->linked[$field] = $this->getTable()->getLinkedTableRow($field, $data);
                        }
                        if ($reload && array_key_exists($field, $this->linked) && !is_null($this->linked[$field]))
                                $this->linked[$field]->reload(false);
                        return $this->linked[$field];
                }
                return null;
        }

        public function setLinked($linked, $field = null) {
                if (!is_null($field)) {
                        if ($this->getTable()->isLinked($field)) {
                                if ($linked instanceof db_row)
                                        $this->linked[$field] = $linked;
                                else
                                        $this->linked[$field] = $this->getTable()->getLinkedTableRow($field, $linked);
                        }
                } else {
                        foreach($linked as $f=>$v)
                                $this->setLinked($v, $f);
                }
        }

        public function getRelated($name) {
                $related = $this->getTable()->getRelated($this->getTable()->getRelatedTableName($name));
                $id = $this->getId();
                if (!$id)
                        return array();
                return $related['tableObj']->getLinkedTable($related['fk2']['name'])->select(array(
                        'where'=>$this->getWhere(array(
                                'clauses'=>factory::get('db_whereClause', array(
                                        'name'=>$related['fk2']['link']['table'].'.'.$related['fk2']['link']['ident'],
                                        'in'=>$this->getDb()->selectQuery(array(
                                                'fields'=>$related['fk2']['name'],
                                                'table'=>$related['tableLink'],
                                                'where'=>$related['fk1']['name'].'='.$id
                                        ))
                                ))
                        ))
                ));
        }

        public function setRelated($related, $name = null) {
                if (!is_null($name)) {
                        if ($this->getTable()->getI18nTable() && $name == $this->getTable()->getI18nTable()->getName()) {
                                $primary = $this->getTable()->getI18nTable()->getPrimary();
                                foreach($related as $r) {
                                        $this->i18nRows[$r[$primary[1]]] = $this->getTable()->getI18nTable()->getRow(
                                                array_merge($r, array($primary[0]=>$this->getId())));
                                }
                        } else {
                                $name = $this->getTable()->getRelatedTableName($name);
                                if ($this->getTable()->isRelated($name)) {
                                        if (!array_key_exists($name, $this->related))
                                                $this->related[$name] = array();

                                        if ($related instanceof db_row)
                                                $this->related[$name][] = $related;
                                        else {
                                                foreach($related as $v) {
                                                        if ($v instanceof db_row)
                                                                $this->related[$name][] = $v;
                                                        else
                                                                $this->related[$name][] = $this->getTable()->getRelatedTableRow($name, $v);
                                                }
                                        }
                                }
                        }
                } else {
                        foreach($related as $t=>$v)
                                $this->setRelated($v, $t);
                }
        }

        public function whereClause() {
                $primary = $this->getTable()->getPrimary();
                $values = $this->getValues('flat');
                $where = array();
                foreach($primary as $p) {
                        $where[] = $this->getTable()->getRawName().'.'.$p.='="'.$values[$p].'"';
                }
                return implode(' AND ', $where);
        }

        public function getAround(array $prm = array()) {
                config::initTab($prm, array(
                        'field'=>null,
                        'returnId'=>false,
                        'where'=>null,
                        'asRow'=>false
                ));
                
                if ($prm['asRow'])
                        $prm['returnId'] = true;

                $field = $prm['field'];
                $where = $this->getDb()->makeWhere($prm['where']);
                if (empty($where))
                        $where = 'WHERE 1';

                if (!is_null($where))
                        $where.= ' AND ';
                if (is_null($field))
                        $field = $this->getTable()->getIdent();
                $val = $this->get($field);
                
                $query = '(SELECT '.$field.','.$this->getTable()->getIdent().' FROM '.$this->getTable()->getRawName().' '.$where.$field.' < ? ORDER BY '.$field.' DESC LIMIT 1)
                                        UNION
                                  (SELECT '.$field.','.$this->getTable()->getIdent().' FROM '.$this->getTable()->getRawName().' '.$where.$field.' > ? ORDER BY '.$field.' ASC LIMIT 1)';
                $vals = $this->getDb()->query($query, utils::htmlDeOut(array($val, $val)))->fetchAll(PDO::FETCH_NUM);
                $ret = array(null, null);
                $useIndex = $prm['returnId'] ? 1 : 0;
                if (array_key_exists(1, $vals)) {
                        $ret[0] = $vals[0][$useIndex];
                        $ret[1] = $vals[1][$useIndex];
                } else if (array_key_exists(0, $vals)) {
                        $tmp = $vals[0][0];
                        if ($tmp > $val)
                                $ret[1] = $vals[0][$useIndex];
                        else
                                $ret[0] = $vals[0][$useIndex];
                }
                if ($prm['asRow']) {
                        if ($ret[0])
                                $ret[0] = $this->getTable()->find($ret[0]);
                        if ($ret[1])
                                $ret[1] = $this->getTable()->find($ret[1]);
                }
                return $ret;
        }

        public function __call($name, $prm) {
                if (strpos($name, 'get') === 0 || strpos($name, 'set') === 0) {
                        $tblName = strtolower(substr($name, 3, 1)).substr($name, 4);
                        $found = false;
                        $linked = $this->getTable()->getLinked();
                        if (is_array($linked)) {
                                foreach(array_keys($linked) as $v) {
                                        if (strpos($v, $tblName.'_') === 0) {
                                                $name = $v;
                                                $found = true;
                                                break;
                                        }
                                }
                        }
                        if (!$found) {
                                $tblName = $this->getTable()->getName().'_'.substr($tblName, 0, -1);
                                $related = $this->getTable()->getRelated();
                                if (is_array($related)) {
                                        foreach(array_keys($related) as $v) {
                                                if ($v == $tblName) {
                                                        $name = $v;
                                                        $found = true;
                                                        break;
                                                }
                                        }
                                }
                        }
                }
                if ($this->getTable()->isLinked($name)) {
                        if (empty($prm) || is_bool($prm[0])) {
                                return $this->getLinked($name, isset($prm[0]) ? $prm[0] : false);
                        } else {
                                return $this->setLinked($prm[0], $name);
                        }
                } else if ($this->getTable()->isRelated($name)) {
                        if (empty($prm)) {
                                return $this->getRelated($name);
                        } else {
                                return $this->setRelated($prm[0], $name);
                        }
                }
        }

        public function offsetExists($offset) {
                return !is_null($this->getTable()->getField($offset));
        }

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

        public function offsetSet($offset, $value) {
                $this->set($offset, $value);
        }
        
        public function offsetUnset($offset) {
                $this->set($offset, null);
        }

        public function __get($name) {
                return $this->get($name);
        }

        public function __set($name, $val) {
                return $this->set($name, $val);
        }

        public function __toString() {
                return $this->getTable()->getName().'-'.$this->getId();
        }

}