class.ilADTFormBridge.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */

abstract class ilADTFormBridge
{
        protected $adt; // [ilADT]
        protected $form; // [ilPropertyFormGUI]
        protected $id; // [string]
        protected $title; // [string]
        protected $info; // [string]
        protected $parent_element; // [string|array]
        protected $required; // [bool]
        protected $disabled; // [bool]
        
        public function __construct(ilADT $a_adt)
        {
                $this->setADT($a_adt);          
        }               
        
        
        //
        // properties
        //
        
        abstract protected function isValidADT(ilADT $a_adt);
        
        protected function setADT(ilADT $a_adt)
        {
                if(!$this->isValidADT($a_adt))
                {
                        throw new Exception('ADTFormBridge Type mismatch.');
                }
                
                $this->adt = $a_adt;                            
        }
        
        public function getADT()
        {
                return $this->adt;
        }
        
        public function setForm(ilPropertyFormGUI $a_form)
        {
                $this->form = $a_form;
        }
        
        public function getForm()
        {
                return $this->form;
        }
        
        public function setElementId($a_value)
        {
                $this->id = (string)$a_value;
        }
        
        public function getElementId()
        {
                return $this->id;
        }
        
        public function setTitle($a_value)
        {
                $this->title = trim($a_value);
        }
        
        public function getTitle()
        {
                return $this->title;
        }
        
        public function setInfo($a_value)
        {
                $this->info = trim($a_value);
        }
        
        public function getInfo()
        {
                return $this->info;
        }
        
        public function setParentElement($a_value)
        {
                if(!is_array($a_value))
                {
                        $a_value = (string)$a_value;
                }
                $this->parent = $a_value;
        }
        
        public function getParentElement()
        {
                return $this->parent;
        }
        
        public function setDisabled($a_value)
        {
                $this->disabled = (bool)$a_value;
        }
        
        public function isDisabled()
        {
                return $this->disabled;
        }
        
        public function setRequired($a_value)
        {
                $this->required = (bool)$a_value;
        }
        
        public function isRequired()
        {
                return $this->required;
        }
        
        
        //
        // form
        //              
        
        protected function addBasicFieldProperties(ilFormPropertyGUI $a_field, ilADTDefinition $a_def)
        {
                if((bool)$this->isDisabled())
                {
                        $a_field->setDisabled(true);
                }
                else if($this->isRequired())
                {
                        $a_field->setRequired(true);
                }                               
                
                $info = $this->getInfo();
                if($info)
                {
                        $a_field->setInfo($info);
                }
        }
        
        protected function findParentElementInForm()
        {
                $parent_def = $this->getParentElement();
                if($parent_def)
                {
                        if(is_array($parent_def))
                        {
                                $parent_option = $parent_def[1];
                                $parent_def = $parent_def[0];                                                           
                        }                       

                        // :TODO: throw exception on invalid definition ?!

                        $parent_field = $this->getForm()->getItemByPostVar($parent_def);                                                
                        if($parent_field instanceof ilSubEnabledFormPropertyGUI)
                        {
                                // radio/checkbox group
                                if($parent_option && method_exists($parent_field, "getOptions"))
                                {                                       
                                        foreach($parent_field->getOptions() as $option)
                                        {
                                                if($option->getValue() == $parent_option)
                                                {
                                                        $parent_field = $option;
                                                        break;
                                                }
                                        }
                                }
                        }
                        
                        if($parent_field)
                        {
                                return $parent_field;
                        }                                       
                }
        }
                                
        protected function addToParentElement(ilFormPropertyGUI $a_field)
        {                               
                $field = $this->findParentElementInForm();
                if($field)
                {
                        $field->addSubItem($a_field);
                }
                else if($this->getForm() instanceof ilPropertyFormGUI)
                {
                        $this->getForm()->addItem($a_field);            
                }
        }
        
        abstract public function addToForm();
        
        public function addJS(ilTemplate $a_tpl)
        {
                
        }
        
        protected function isActiveForSubItems($a_parent_option = null)
        {
                return !$this->getADT()->isNull();
        }
                
        public function shouldBeImportedFromPost(ilADTFormBridge $a_parent_adt = null)
        {
                if($this->isDisabled())
                {
                        return false;
                }
                
                // inactive parent elements disable importing
                if($a_parent_adt)
                {
                        $parent_option = null;
                        $parent_element = $this->getParentElement();
                        if(is_array($parent_element))
                        {
                                $parent_option = $parent_element[1];
                        }
                        return $a_parent_adt->isActiveForSubItems($parent_option);
                }       
                
                return true;
        }
        
        abstract public function importFromPost();      
        
        public function validate()
        {               
                global $lng;
                
                // ilADTFormBridge->isRequired() != ilADT->allowNull()
                if($this->isRequired() && $this->getADT()->isNull())
                {
                        $field = $this->getForm()->getItemByPostvar($this->getElementId());                                     
                        $field->setAlert($lng->txt("msg_input_is_required"));
                        return false;
                }               
                // no need to further validate if no value given
                else if(!$this->getADT()->isValid())
                {
                        $tmp = array();
                        
                        $mess = $this->getADT()->getValidationErrors();
                        foreach($mess as $error_code)
                        {
                                $tmp[] = $this->getADT()->translateErrorCode($error_code);
                        }                       
                        
                        $field = $this->getForm()->getItemByPostvar($this->getElementId());                                     
                        $field->setAlert(implode("<br />", $tmp));
                        
                        return false;
                }
                
                return true;
        }
        
        public function setExternalErrors($a_errors)
        {
                $field = $this->getForm()->getItemByPostvar($this->getElementId());                                     
                $field->setAlert(implode("<br />", $a_errors));
        }
}

?>