form.class.php

Go to the documentation of this file.

<?php
class form extends object {

        protected $elements = array();

        protected $i18nElements = array();

        protected $section = array();

        protected $elementsSection = array();

        protected $curSection = 0;

        protected $hasFiles = 0;

        protected $isBound = false;

        protected $errors = array();

        protected $customErrors = array();

        protected $captchaAdded = false;

        protected function afterInit() {
                $this->addSection($this->cfg->sectionName);
        }

        public function setSubmitText($text) {
                $this->cfg->submitText = $text;
        }

        public function setSubmitPlus($text) {
                $this->cfg->submitPlus = $text;
        }

        public function __toString() {
                try {
                        return $this->to(request::get('out'));
                } catch (Exception $e) {
                        if (DEV) {
                                debug::trace($e, 2);
                        } else
                           throw $e;
                }
        }

        public function to($type) {
                $this->addCaptcha();
                $ret = null;

                $prm = $this->cfg->get($type);
                if ($this->cfg->check($tmp = $type.ucfirst($this->cfg->mode)))
                        $prm = array_merge($prm, $this->cfg->get($tmp));

                if (!$this->cfg->showSection) {
                        $prm = array_merge($prm, $this->cfg->get($type.'NoSection'));
                        if ($this->cfg->check($tmp = $type.'NoSection'.ucfirst($this->cfg->mode)))
                                $prm = array_merge($prm, $this->cfg->get($tmp));
                }

                $hiddenGlobal = is_array($prm) && (array_key_exists('noHidden', $prm) && $prm['noHidden']) || !(strpos($prm['global'], '[hidden]') === false);
                $hiddens = null;

                $errorPos = $prm['errorPos'];
                $errorsGlobal = array();

                foreach($this->section as $kSection=>$sectionName) {
                        $fields = null;
                        $errorsSection = array();
                        foreach($this->elements[$kSection] as $name=>$e) {
                                $des = $e->description? str_replace('[des]', $e->getDescription(), $prm['des']) : null;
                                $line = $e->isHidden()? 'lineHidden' : 'line';

                                $errors = null;
                                if ($this->isBound() && !$e->isValid() && !$e->isHidden()) {
                                        $tmp = array();
                                        foreach($e->getErrors() as $err) {
                                                $tmp[] = str_replace('[error]', $err, $prm['lineErrorLine']);
                                                $errorsSection[] = str_replace('[error]', $err, $prm['sectionErrorLine']);
                                                $errorsGlobal[] = str_replace('[error]', $err, $prm['globalErrorLine']);
                                        }
                                        $errors = $errorPos == 'field' ? str_replace('[errors]', implode('', $tmp), $prm['lineErrorWrap']) : null;
                                        $line = 'lineError';
                                }

                                $requiredMoreLabel = $e->getValidRule('required') ? $this->cfg->requiredMoreLabel : null;
                                $label = $e->label
                                                ? $e->label.$requiredMoreLabel.$this->cfg->sepLabel
                                                : $this->cfg->emptyLabel;
                                $tmp = str_replace(
                                        array('[des]', '[label]', '[field]', '[errors]', '[id]', '[classLine]'),
                                        array($des, $label, $e->to($type), $errors, $e->id, $e->classLine),
                                        $prm[$line]);
                                if ($e->isHidden() && $hiddenGlobal)
                                        $hiddens.= $tmp;
                                else
                                        $fields.= $tmp;
                        }
                        if ($fields) {
                                $errors = null;
                                $section = 'section';
                                if (!empty($errorsSection) && $errorPos == 'section') {
                                        $errors = implode('', $errorsSection);
                                        $section.= 'Error';
                                }
                                $ret.= str_replace(
                                        array('[errors]', '[fields]', '[label]'),
                                        array($errors, $fields, $this->cfg->outSection ? utils::htmlOut($sectionName) : $sectionName),
                                        $prm[$section]);
                        }
                }

                $plus = null;
                if ($type == 'html') {
                        if (array_key_exists('incFiles', $prm))
                                foreach($prm['incFiles'] as $f)
                                        response::getInstance()->add($f);

                        $plus = 'action="'.$this->cfg->action.'" method="'.$this->cfg->method.'"';
                        if ($this->hasFiles)
                                $plus.= ' enctype="multipart/form-data"';
                }
                $plus.= $this->cfg->formPlus;

                $errors = null;
                if (!empty($errorsGlobal) && $errorPos == 'global') {
                        $errors = str_replace('[errors]', implode('', $errorsGlobal), $prm['globalError']);
                }
                return str_replace(
                        array('[hidden]', '[errors]', '[content]', '[plus]', '[submit]', '[submitText]', '[submitPlus]'),
                        array($hiddens, $errors, $ret, $plus, $prm['submit'], $this->cfg->submitText, $this->cfg->submitPlus),
                        $prm['global']);
        }

        public function finalize() {
                if ($this->isI18n()) {
                        $this->cfg->showSection = true;
                        $nb = 0;
                        if ($this->cfg->forceOnlyOneLang || $this->cfg->noForceLang)
                                $requiredFields = array();
                        foreach(request::avlLang(true) as $lg=>$lang) {
                                $this->addSection($lang);
                                $groupedFieldsAdded = false;
                                foreach($this->i18nElements as $e) {
                                        $e['prm']['isI18n'] = true;
                                        $initName = $e['prm']['name'];
                                        $e['prm']['name'] = db::getCfg('i18n').'['.$lg.']['.$initName.']';
                                        if ($this->cfg->forceOnlyOneLang || $this->cfg->noForceLang) {
                                                if ($nb == 0) {
                                                        if ($e['prm']['valid']['required'])
                                                                $requiredFields[] = $initName;
                                                } else {
                                                        if (!$groupedFieldsAdded && $e['prm']['valid']['required'] && count($requiredFields)) {
                                                                $fields = array();
                                                                foreach($requiredFields as $v)
                                                                        $fields[] = db::getCfg('i18n').'['.$lg.']['.$v.']';
                                                                $e['prm']['valid']['groupedFields'] = array(
                                                                        'form'=>$this,
                                                                        'fields'=>$fields
                                                                );
                                                                $groupedFieldsAdded = true;
                                                        }
                                                }
                                                if ($nb > 0 || $this->cfg->noForceLang)
                                                        $e['prm']['valid']['required'] = false;
                                        }
                                        $this->add($e['type'], $e['prm']);
                                }
                                $nb++;
                        }
                }
        }

        public function toHtml() {
                return $this->to('html');
        }

        public function toXul() {
                return $this->to('xul');
        }

        public function isValid() {
                $validRet = empty($this->customErrors);
                $this->errors = array();
                foreach($this->section as $kSection=>$sectionName) {
                        foreach($this->elements[$kSection] as $name=>$e) {
                                $valid = $e->isValid();
                                if (!$valid)
                                        $this->errors[$name] = $e->getErrors();
                                $validRet = $validRet && $valid;
                        }
                }
                return $validRet;
        }

        public function isI18n() {
                return !empty($this->i18nElements);
        }

        public function getErrors() {
                return array_merge_recursive($this->errors, $this->customErrors);
        }

        public function hasErrors() {
                return !empty($this->errors) || !empty($this->customErrors);
        }

        public function addCustomError($field, $error) {
                if ($elt = $this->get($field)) {
                        $elt->addCustomError($error);
                        return;
                }
                if (!array_key_exists($field, $this->customErrors))
                        $this->customErrors[$field] = array();
                $this->customErrors[$field][] = $error;
        }

        public function add($type, array $prm=array(), $isI18n=false) {
                if ($isI18n) {
                        $this->i18nElements[] = array('type'=>$type, 'prm'=>$prm);
                        return null;
                }
                $inst = null;
                $name = null;
                if ($type instanceof form_abstract && !$this->has($name = $type->getName())) {
                        $inst = $type;
                        $inst->renew();
                } else if (is_string($type) && array_key_exists('name', $prm) && !$this->has($name = $prm['name'])) {
                        $inst = $this->getNew($type, $prm);
                }
                if ($inst) {
                        $this->elements[$this->curSection][$name] = $inst;
                        $this->elementsSection[$name] = $this->curSection;

                        if ($inst instanceof form_file)
                                $this->hasFiles++;

                        return $inst;
                } else
                        return null;
        }

        public function has($name) {
                return array_key_exists($name, $this->elementsSection);
        }

        public function get($name) {
                if ($this->has($name))
                        return $this->elements[$this->elementsSection[$name]][$name];
                return null;
        }

        public function del($name) {
                if ($this->has($name)) {
                        unset($this->elements[$this->elementsSection[$name]][$name]);
                        unset($this->elementsSection[$name]);
                }
        }

        public function reOrder(array $order) {
                $tmp = array();
                foreach($order as $v) {
                        if (isset($this->elementsSection[$v]) && $this->elementsSection[$v] == $this->curSection) {
                                $e = $this->get($v);
                                if ($e)
                                        $tmp[$v] = $e;
                        }
                }
                foreach($this->elements[$this->curSection] as $name=>$elt) {
                        if (!isset($tmp[$name]))
                                $tmp[$name] = $elt;
                }
                $this->elements[$this->curSection] = $tmp;
        }

        public function reOrderSection(array $order) {
                $section = $elements = $elementsSection = $trans = array();
                $cur = 0;
                foreach($order as $v) {
                        $old = is_int($v) ? $v : array_search($v, $this->section);
                        if (!is_null($old) && $old !== false && isset($this->section[$old])) {
                                $new = $cur;
                                $trans[$old] = $new;
                                $section[$new] = $this->section[$old];
                                $elements[$new] = $this->elements[$old];
                                foreach(array_keys($elements[$new]) as $k)
                                        $elementsSection[$k] = $new;
                                $cur++;
                        }
                }
                if (count($section) < count($this->section)) {
                        foreach($this->section as $old=>$v) {
                                if (!isset($trans[$old])) {
                                        $new = $cur;
                                        $trans[$old] = $new;
                                        $section[$new] = $this->section[$old];
                                        $elements[$new] = $this->elements[$old];
                                        foreach(array_keys($elements[$new]) as $k)
                                                $elementsSection[$k] = $new;
                                        $cur++;
                                }
                        }
                }

                $this->section = $section;
                $this->elements = $elements;
                $this->elementsSection = $elementsSection;
        }


        public function getValue($name) {
                if ($elm = $this->get($name)) {
                        return $elm->getValue();
                }
                return null;
        }

        public function getValues($onlyFilled=false, $ignoreWhitePassword=true) {
                $ret = array();

                foreach($this->elementsSection as $name=>$section) {
                        if (!($ignoreWhitePassword && $this->get($name) instanceof form_password && !$this->getValue($name)))
                                $ret[$name] = $this->getValue($name);
                }

                $ret = array_diff_key($ret, $this->cfg->notValue);

                if ($onlyFilled)
                        $ret = array_filter($ret, create_function('$v', 'return $v ? true : false;'));

                $tmp = array();
                foreach($ret as $k=>$v) {
                        $matches = explode('|', str_replace(
                                array('][', '[', ']'),
                                array('|', '|', ''),
                                $k
                        ));
                        if (count($matches) > 1) {
                                $t = &$tmp;
                                for($i = 0; $i < count($matches); $i++) {
                                        if (!isset($matches[$i+1]))
                                                $t[$matches[$i]] = $v;
                                        else {
                                                if (!array_key_exists($matches[$i], $t) || !is_array($t[$matches[$i]]))
                                                        $t[$matches[$i]] = array();
                                                $t = &$t[$matches[$i]];
                                        }
                                }
                        } else
                                $tmp[$matches[0]] = $v;
                }
                return $tmp;
        }

        public function addNotValue($name) {
                $this->cfg->setInArray('notValue', $name, true);
        }

        public function getNames() {
                return array_keys($this->elementsSection);
        }

        public function setValue($name, $value, $refill=false) {
                if ($elm = $this->get($name)) {
                        $elm->setValue($value, $refill);
                        $this->isBound = true;
                        return true;
                }
                return false;
        }

        public function setValues(array $data, $refill=false) {
                $i = 0;
                foreach($data as $name=>$value) {
                        if ($this->setValue($name, $value, $refill))
                                $i++;
                }
                return $i;
        }

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

        public function setBound($bound) {
                $this->isBound = $bound;
        }

        public function refill() {
                $this->addCaptcha();
                $htVars = http_vars::getInstance();
                foreach($this->elementsSection as $name=>$section) {
                        $val = $htVars->getVar(array(
                                'name'=>str_replace('.', '_', $name),
                                'method'=>$this->cfg->method
                        ));
                        $this->setValue($name, $val, true);
                }
        }

        public function getNew($type, array $prm) {
                if (!array_key_exists('mode', $prm))
                        $prm['mode'] = $this->cfg->mode;
                return factory::get('form_'.$type, $prm);
        }

        public function addSection($name) {
                $this->curSection = count($this->section);
                $this->section[$this->curSection] = $name;
                $this->elements[$this->curSection] = array();
                return $this->curSection;
        }

        public function setSection($search) {
                $find = false;
                if (!is_int($search)) {
                        foreach($this->section as $k=>&$s) {
                                if ($s == $search)
                                        $find = $k;
                        }
                } else
                        $find = $search;

                if (is_int($find) && $find < count($this->section))
                        $this->curSection = $find;

                return $find;
        }
        
        public function setSectionName($name, $search = null) {
                $find = false;
                if (is_null($search)) {
                        $find = $this->curSection;
                } else if (is_int($search)) {
                        $find = $search;
                } else {
                        foreach($this->section as $k=>&$s) {
                                if ($s == $search)
                                        $find = $k;
                        }
                }
                
                if (is_int($find) && $find < count($this->section)) {
                        $this->section[$find] = $name;
                        return true;
                }
                return false;
        }

        public function moveToSection($name, $section=null) {
                $f = $this->get($name);
                if ($f) {
                        $curSection = $this->elementsSection[$name];
                        $section = $section ? $section : $this->curSection;
                        $this->elements[$section][$name] = $f;
                        $this->elementsSection[$name] = $section;
                        unset($this->elements[$curSection][$name]);
                        return true;
                }
                return false;
        }

        public function setMode($mode, $force=true) {
                $this->cfg->mode = $mode;
                if ($force) {
                        foreach($this->section as $kSection=>$sectionName)
                                foreach($this->elements[$kSection] as $name=>$e)
                                        $e->mode = $mode;
                }
        }

        public function firstSection() {
                $this->curSection = 0;
        }

        public function lastSection() {
                $this->curSection = count($this->elements)-1;
        }

        public function getSection() {
                return $this->curSection;
        }

        public function addCaptcha() {
                if (!$this->captchaAdded) {
                        if (($typeCpt = $this->cfg->getInarray('captcha', 'type')) && ($nameCpt = $this->cfg->getInarray('captcha', 'name'))) {
                                $this->add($typeCpt, $this->cfg->captcha);
                                $this->captchaAdded = true;
                                $this->cfg->setInArray('notValue', $nameCpt, $nameCpt);
                        }
                }
        }

        public function set($key1, $key2, $val) {
                $this->cfg->setInArray($key1, $key2, $val);
        }

        public function __set($key, $val) {
                $this->cfg->set($key, $val);
        }

        public function __clone() {
                $this->cfg = new config($this->cfg->getAll());
                $bound = $this->isBound;
                foreach($this->section as $kSection=>$sectionName) {
                        foreach($this->elements[$kSection] as $name=>$e) {
                                $this->elements[$kSection][$name] = factory::get(get_class($e), unserialize(serialize($e->getCfg()->getAll())));
                                if (!is_object($e->getValue()))
                                        $this->setValue($name, $e->getValue());
                        }
                }
                $this->isBound = $bound;
        }

}