4405648418

Build Type

push

github

Committed by ozanuykun

Commit Message

Released 8.2.0

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

9 existing lines in 1 file now uncovered.

10429 of 10472 relevant lines covered (99.59%)

17.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.59

/Internal/package-hypertext/Form.php

<?php namespace ZN\Hypertext;
/**
 * ZN PHP Web Framework
 * 
 * "Simplicity is the ultimate sophistication." ~ Da Vinci
 * 
 * @package ZN
 * @license MIT [http://opensource.org/licenses/MIT]
 * @author  Ozan UYKUN [ozan@znframework.com]
 */

use ZN\Hypertext\Exception\InvalidArgumentException;
use ZN\DataTypes\Arrays;
use ZN\Protection\Json;
use ZN\Request\Method;
use ZN\Buffering;
use ZN\Singleton;
use ZN\Inclusion;
use ZN\Base;
use ZN\IS;

class Form
{
    use ViewCommonTrait;

    /**
     * Keeps validation usage this form info.
     * 
     * @var bool
     */
    protected $validateUsageThisForm = false;

    /**
     * Keeps validation form name.
     * 
     * @var string
     */
    protected $getValidationFormName = NULL;

    /**
     * Keeps real form name.
     */
    protected $getFormName = NULL;

    /**
     * Keeps form input objects.
     * 
     * @var array
     */
    protected $elements =
    [
        'input' =>
        [
            'button', 'reset' , 'submit'  , 'radio', 'checkbox',
            'date'  , 'time'  , 'datetime', 'week' , 'month'   ,
            'text'  , 'search', 'password', 'email', 'tel'     ,
            'number', 'url'   , 'range'   , 'image', 'color'
        ]
    ];

    /**
     * Keeps validation rules.
     * 
     * @var array
     */
    protected $validate = [];

    /**
     * Keeps method type.
     * 
     * @var string
     */
    protected $method;

    /**
     * Keeps update process row
     * 
     * @var object
     */
    protected $getUpdateRow;

    /**
     * Gets update process row
     */
    public function getUpdateRow()
    {
        return $this->getUpdateRow;
    }

    /**
     * Open form tag.
     * 
     * @param string $name        = NULL
     * @param array  $_attributes = []
     * 
     * Available Enctype Options
     * 
     * 1. multipart   => multipart/form-data
     * 2. application => application/x-www-form-urlencoded
     * 3. text        => text/plain
     * 
     * @return string|object
     */
    public function open(string $name = NULL, array $_attributes = [])
    {
        $this->setFormName($name, $_attributes);

        $this->isEnctypeAttribute($_attributes);
       
        $this->isWhereAttribute($name);
        
        $this->isQueryAttribute();

        $this->isPreventAttribute();
        
        $this->setMethodType($_attributes);
        
        $this->createFormElementByAttributes($_attributes, $return);

        $this->isDatabaseProcessWithName($name, $return);

        $this->isCSRFAttribute($return);

        $this->_unsetopen();

        $this->outputElement .= $return;

        return $this;
    }

    /**
     * Get form name
     * 
     * @return string
     */
    public function getName()
    {
        return $this->getFormName;
    }

    /**
     * Validate error message.
     * 
     * @param void
     * 
     * @return string
     */
    public function validateErrorMessage()
    {
        return Singleton::class('ZN\Validation\Data')->error('string');
    }

    /**
     * Validate error array.
     * 
     * @param void
     * 
     * @return array
     */
    public function validateErrorArray()
    {
        return Singleton::class('ZN\Validation\Data')->error('array');
    }

    /**
     * Reset validation rules
     * 
     * @param string $formName
     */
    public function resetValidationRules(string $formName)
    {
        $session = Singleton::class('ZN\Storage\Session');

        $session->delete('FormValidationRules' . $formName);
        $session->delete('FormValidationMethod' . $formName);

        return $this;
    }

    /**
     * Closes form object.
     * 
     * @param void
     * 
     * @return string|object
     */
    public function close()
    {
        unset($this->settings['getrow']);

        $this->getFormName = NULL;

        if( isset($this->getJavascriptValidationFunction) )
        {
            $this->outputElement .= Inclusion\View::use('JavascriptValidationFunctions', $this->getJavascriptValidationFunction, true, __DIR__ . '/');

            $this->getJavascriptValidationFunction = NULL;
        }

        if( $this->validateUsageThisForm === true )
        {
            $this->outputElement .= '<input type="hidden" name="ValidationFormName" value="' . $this->getValidationFormName . '">';

            $this->getValidationFormName = NULL;

            $this->validateUsageThisForm = false;
        }
        
        $this->outputElement .= '</form>' . EOL;
        
        return $this;
    }

    /**
     * datetime-local form object.
     * 
     * @param string $name        = NULL
     * @param string $value       = NULL
     * @param array  $_attributes = []
     * 
     * @return string|object
     */
    public function datetimeLocal(string $name = NULL, string $value = NULL, array $_attributes = [])
    {
        return $this->_input($name, $value, $_attributes, 'datetime-local');
    }

    /**
     * textarea form object.
     * 
     * @param string $name        = NULL
     * @param string $value       = NULL
     * @param array  $_attributes = []
     * 
     * @return string|object
     */
    public function textarea(string $name = NULL, string $value = NULL, array $_attributes = [])
    {
        $this->setNameAttribute($name);

        $this->setValueAttribute($value);

        if( ! empty($this->settings['attr']['name']) )
        {
            $this->_postback($this->settings['attr']['name'], $value);

            # 5.8.2.8[added]
            $this->getVMethodMessages();

            # 5.4.2[added]
            $this->_validate($this->settings['attr']['name'], $this->settings['attr']['name']);
            
            # 5.4.2[added]|5.4.5|5.4.6[edited]
            $value = $this->_getrow('textarea', $value, $this->settings['attr']);
        }

        $this->commonMethodsForInputElements('textarea');

        $this->getPermAttribute($perm);

        $this->createTextareaElementByValueAndAttributes($value, $_attributes, $return);

        $this->createBootstrapFormInputElementByType('textarea', $return, $_attributes, $return);

        $this->outputElement .= $this->_perm($perm, $return);

        return $this;
    }

    /**
     * select form object.
     * 
     * @param string $name        = NULL
     * @param string $optios      = []
     * @param mixed  $selected    = NULL
     * @param array  $_attributes = []
     * @param bool   $multiple    = false
     * 
     * @return string|object
     */
    public function select(string $name = NULL, array $options = [], $selected = NULL, array $_attributes = [], bool $multiple = false)
    {
        $this->isRepeatData($options);

        $this->isTableOrQueryData($options);

        $this->setOptionAttribute($options);

        $this->isExcludeAttribute($options);

        $this->isIncludeAttribute($options);

        $this->isOrderAttribute($options);

        $this->setSelectedAttribute($selected, $options);

        $this->setMultipleAttribute($multiple, $_attributes);

        $this->setNameAttributeWithReference($name, $_attributes);

        if( ! empty($_attributes['name']) )
        {
            $this->_postback($_attributes['name'], $selected);

            # 5.8.2.8[added]
            $this->getVMethodMessages();

            # 5.4.2[added]
            $this->_validate($_attributes['name'], $_attributes['name']);
            
            # 5.4.2[added]|5.4.5|5.4.6[edited]
            $selected = $this->_getrow('select', $selected, $_attributes);
        }

        $this->commonMethodsForInputElements('select');

        $this->getPermAttribute($perm);

        $this->createSelectElement($options, $selected, $_attributes, $return);

        $this->createBootstrapFormInputElementByType('select', $return, $_attributes, $return);

        $this->_unsetselect();

        $this->outputElement .= $this->_perm($perm, $return);

        return $this;
    }

    /**
     * select type multiselect form object.
     * 
     * @param string $name        = NULL
     * @param string $optios      = []
     * @param mixed  $selected    = NULL
     * @param array  $_attributes = []
     * 
     * @return string|object
     */
    public function multiselect(string $name = NULL, array $options = [], $selected = NULL, array $_attributes = [])
    {
        return $this->select($name, $options, $selected, $_attributes, true);
    }

    /**
     * hidden form object.
     * 
     * @param string $name        = NULL
     * @param string $value       = NULL
     * 
     * @return string
     */
    public function hidden($name = NULL, string $value = NULL)
    {
        $name  = $this->settings['attr']['name' ] ?? $name ;
        $value = $this->settings['attr']['value'] ?? $value;

        $this->settings['attr'] = [];

        $hiddens = '';
        
        if( is_array($name) ) foreach( $name as $key => $val )
        {
            $hiddens .= $this->createHiddenElement($key, $val);
        }
        else
        {
            $hiddens = $this->createHiddenElement($name, $value);
        }

        $this->outputElement .= $hiddens;

        return $this;
    }

    /**
     * file form object.
     * 
     * @param string $name        = NULL
     * @param string $value       = NULL
     * @param array  $_attributes = []
     * 
     * @return string|object
     */
    public function file(string $name = NULL, bool $multiple = false, array $_attributes = [])
    {
        if( ! empty($this->settings['attr']['multiple']) )
        {
            $multiple = true;
        }

        $name = $this->settings['attr']['name'] ?? $name;

        if( $multiple === true )
        {
            $this->settings['attr']['multiple'] = 'multiple';
            $name = Base::suffix($name, '[]');
        }

        $this->commonMethodsForInputElements('file');

        return $this->_input($name, '', $_attributes, 'file');
    }

    /**
     * Protected create hidden element
     */
    protected function createHiddenElement($key, $value)
    {
        return '<input type="hidden" name="' . $key . '" id="' . $key . '" value="' . $value . '">' . EOL;
    }

    /**
    * Protected create select element
    */
    protected function createSelectElement($options, $selected, $_attributes, &$return)
    {        
        $option = '';

        if( is_string($selected) && Json::check($selected) )
        {
            $selected = Json::decodeArray($selected);
        }

        if( is_array($options) ) foreach( $options as $key => $value )
        {
            if( is_array($selected) )
            {
                if( in_array($key, $selected) )
                {
                    $select = ' selected="selected"';
                }
                else
                {
                    $select = "";
                }
            }
            else
            {
                if( $selected === $key || ( is_numeric($selected) && $selected == $key ) )
                {
                    $select = ' selected="selected"';
                }
                else
                {
                    $select = "";
                }
            }

            if( is_numeric($value) || ! empty($value) )
            {
                $option .= '<option value="'.$key.'"'.$select.'>'.$value.'</option>'.EOL;
            }
        }

        if( isset($this->settings['attr']['only-options']) )
        {
            unset($this->settings['attr']['only-options']);
            
            $return = $option;
        }
        else
        {
            $return = '<select'.$this->attributes($_attributes).'>' . $option . '</select>'.EOL;
        }
    }

    /**
     * Protected set multiple attribute
     */
    protected function setMultipleAttribute($multiple, &$_attributes)
    {
        if( $multiple === true )
        {
            $_attributes['multiple'] = 'multiple';
        }
    }

    /**
     * Protected set selected attribute
     */
    protected function setSelectedAttribute(&$selected, $options)
    {
        $selected = $this->settings['selectedKey'] ?? $selected;

        if( isset($this->settings['selectedValue']) )
        {
            $flip     = array_flip($options);
            $selected = $flip[$this->settings['selectedValue']];
        }
    }

    /**
     * Protected is order attribute
     */
    protected function isOrderAttribute(&$options)
    {
        if( isset($this->settings['order']['type']) )
        {
            $options = Arrays\Sort::order($options, $this->settings['order']['type'], $this->settings['order']['flags']);
        }
    }

    /**
     * Protected is exclude attribute
     */
    protected function isExcludeAttribute(&$options)
    {
        if( isset($this->settings['exclude']) )
        {
            $options = Arrays\Excluding::use($options, $this->settings['exclude']);
        }
    }

    /**
     * Protected is include attribute
     */
    protected function isIncludeAttribute(&$options)
    {
        if( isset($this->settings['include']) )
        {
            $options = Arrays\Including::use($options, $this->settings['include']);
        }
    }

    /**
     * Protected set option attribute
     */
    protected function setOptionAttribute(&$options)
    {
        $options = $this->settings['option'] ?? $options;
    }

    /**
     * Protected is repeat data
     */
    protected function isRepeatData(&$options)
    {
        if( ! empty($this->settings['attr']['repeat']) )
        {
            $key = key($options); $current = current($options);

            if( $key > $current )
            {
                $ocurrent = $current;
                $current  = $key;
                $key      = $ocurrent;
            }

            for( $i = $key; $i <= $current; $i++ )
            {
                $options[$i] = $i;
            }

            unset($this->settings['attr']['repeat']);
        }
    }

    /**
     * Protected is table or query data
     */
    protected function isTableOrQueryData(&$options)
    {
        if( ! empty($this->settings['table']) || ! empty($this->settings['query']) )
        {
            $key     = key($options);
            $current = current($options);

            if( IS::closure($current) )
            {
                $selectedColumns = ['*'];
            }
            else
            {
                $selectedColumns = [$key, $current];
            }
            
            array_shift($options);

            $dbClass = Singleton::class('ZN\Database\DB');

            if( ! empty($this->settings['table']) )
            {
                $table = $this->settings['table'];

                if( strstr($table, ':') )
                {
                    $tableEx = explode(':', $table);
                    $table   = $tableEx[1];
                    $db      = $tableEx[0];

                    $db     = $dbClass->differentConnection($db);
                    $result = $db->select(...$selectedColumns)->get($table)->result();
                }
                else
                {
                    $result = $dbClass->select(...$selectedColumns)->get($table)->result();
                }
            }
            else
            {
                $result = $dbClass->query($this->settings['query'])->result();
            }

            foreach( $result as $row )
            {
                if( IS::closure($current) )
                {
                    $options[$row->$key] = $current($row);
                }
                else
                {
                    $options[$row->$key] = $row->$current;
                }
            }
        }
    }

    /**
     * Protected create textarea element by value and attributes
     */
    protected function createTextareaElementByValueAndAttributes($value, $_attributes, &$return)
    {
        $return = '<textarea'.$this->attributes($_attributes).'>'.$value.'</textarea>' . EOL;
    }

    /**
     * Protected set textarea name attribute
     */
    protected function setNameAttribute($name)
    {
        if( ! isset($this->settings['attr']['name']) && ! empty($name) )
        {
            $this->settings['attr']['name'] = $name;
        }
    }

    /**
     * Protected set value attribute
     */
    protected function setValueAttribute(&$value)
    {
        $value = $this->settings['attr']['value'] ?? $value;
    }

    /**
     * Protected set form name
     */
    protected function setFormName(&$name, &$_attributes)
    {
        $this->getFormName = $this->getValidationFormName = $name = $this->settings['attr']['name'] ?? $name;
  
        $_attributes['name'] = $name;
    }

    /**
     * Protected create form element by attributes
     */
    protected function createFormElementByAttributes($_attributes, &$return)
    {
        $this->changeFormAttributes
        ([
            'inline'     => 'class:form-inline',
            'horizontal' => 'class:form-horizontal'
        ]);

        $return = '<form'.$this->attributes($_attributes).'>' . EOL;
    }

    /**
     * Protected is database process with name
     */
    protected function isDatabaseProcessWithName($name, &$return)
    {
        $return .= $this->_process($name, $this->method);
    }

    /**
     * Protected is csrf attribute
     */
    protected function isCSRFAttribute(&$return)
    {
        if( isset($this->settings['token']) )
        {
            $return .= CSRFInput();
        }
    }

    /**
     * Protected set method type
     */
    protected function setMethodType(&$_attributes)
    {
        $this->method = ($_attributes['method'] = $_attributes['method'] ?? $this->settings['attr']['method'] ?? 'post');
    }

    /**
     * Protected is enctype attribute
     */
    protected function isEnctypeAttribute(&$_attributes)
    {
        if( isset($_attributes['enctype']) )
        {
            $enctype = $_attributes['enctype'];

            if( isset($this->enctypes[$enctype]) )
            {
                $_attributes['enctype'] = $this->enctypes[$enctype];
            }
        }
    }

    /**
     * Protected is where attribute
     */
    protected function isWhereAttribute($name)
    {
        if( isset($this->settings['where']) )
        {
            $this->settings['getrow'] = Singleton::class('ZN\Database\DB')->get($name)->row();
        }
    }

    /**
     * Protected is query attribute
     */
    protected function isQueryAttribute()
    {
        if( $query = ($this->settings['query'] ?? NULL) )
        {
            $this->settings['getrow'] = Singleton::class('ZN\Database\DB')->query($query)->row();
        }
    }

    /**
     * Protected is prevent attribute
     */
    protected function isPreventAttribute()
    {
        if( isset($this->settings['attr']['prevent']) )
        {
            unset($this->settings['attr']['prevent']);

            $this->settings['attr']['onsubmit'] = 'event.preventDefault()';
        }
    }

    /**
     * protected process
     * 
     * @param string $name
     * @param string $method
     * 
     * @return mixed
     */
    protected function _process($name, $method)
    {
        if( $process = ($this->settings['process'] ?? NULL) )
        {
            if( Method::$method('FormProcessValue') )
            {
                if( Singleton::class('ZN\Validation\Data')->check() )
                {
                    $dbClass = Singleton::class('ZN\Database\DB');

                    if( $process === 'update' )
                    {
                        $dbClass->where
                        (
                            $whereColumn = $this->settings['whereColumn'], 
                            $whereValue  = $this->settings['whereValue']
                        )
                        ->update(strtolower($method).':'.$name);       

                        $this->getUpdateRow = $this->settings['getrow'] = $dbClass->where($whereColumn, $whereValue)->get($name)->row();
                    }
                    elseif( $process === 'insert' )
                    {
                        if( isset($this->settings['duplicateCheck']) )
                        {
                            $dbClass->duplicateCheck();
                        }

                        $dbClass->insert(strtolower($method).':'.$name); 
                    }
                    else
                    {
                        throw new InvalidArgumentException('[Form::process()] method can take one of the values [update or insert].');
                    }
                }
            }

            return (string) $this->hidden('FormProcessValue', 'FormProcessValue');
        }
    }

    /**
     * protected unset select variables
     * 
     * @param void
     * 
     * @return void
     */
    protected function _unsetselect()
    {
        unset($this->settings['table']);
        unset($this->settings['query']);
        unset($this->settings['option']);
        unset($this->settings['exclude']);
        unset($this->settings['include']);
        unset($this->settings['order']);
        unset($this->settings['selectedKey']);
        unset($this->settings['selectedValue']);
    }

    /**
     * protected unset open variables
     * 
     * @param void
     * 
     * @return void
     */
    protected function _unsetopen()
    {
        unset($this->settings['where']);
        unset($this->settings['whereValue']);
        unset($this->settings['whereColumn']);
        unset($this->settings['query']);
        unset($this->settings['token']);
        unset($this->settings['process']);
        unset($this->settings['duplicateCheck']);
    }
}

1	<?php namespace ZN\Hypertext;
2	/**
3	* ZN PHP Web Framework
4	*
5	* "Simplicity is the ultimate sophistication." ~ Da Vinci
6	*
7	* @package ZN
8	* @license MIT [http://opensource.org/licenses/MIT]
9	* @author Ozan UYKUN [ozan@znframework.com]
10	*/
11
12	use ZN\Hypertext\Exception\InvalidArgumentException;
13	use ZN\DataTypes\Arrays;
14	use ZN\Protection\Json;
15	use ZN\Request\Method;
16	use ZN\Buffering;
17	use ZN\Singleton;
18	use ZN\Inclusion;
19	use ZN\Base;
20	use ZN\IS;
21
22	class Form
23	{
24	use ViewCommonTrait;
25
26	/**
27	* Keeps validation usage this form info.
28	*
29	* @var bool
30	*/
31	protected $validateUsageThisForm = false;
32
33	/**
34	* Keeps validation form name.
35	*
36	* @var string
37	*/
38	protected $getValidationFormName = NULL;
39
40	/**
41	* Keeps real form name.
42	*/
43	protected $getFormName = NULL;
44
45	/**
46	* Keeps form input objects.
47	*
48	* @var array
49	*/
50	protected $elements =
51	[
52	'input' =>
53	[
54	'button', 'reset' , 'submit' , 'radio', 'checkbox',
55	'date' , 'time' , 'datetime', 'week' , 'month' ,
56	'text' , 'search', 'password', 'email', 'tel' ,
57	'number', 'url' , 'range' , 'image', 'color'
58	]
59	];
60
61	/**
62	* Keeps validation rules.
63	*
64	* @var array
65	*/
66	protected $validate = [];
67
68	/**
69	* Keeps method type.
70	*
71	* @var string
72	*/
73	protected $method;
74
75	/**
76	* Keeps update process row
77	*
78	* @var object
79	*/
80	protected $getUpdateRow;
81
82	/**
83	* Gets update process row
84	*/
85	public function getUpdateRow()
86	{
87	return $this->getUpdateRow;	1✔
88	}
89
90	/**
91	* Open form tag.
92	*
93	* @param string $name = NULL
94	* @param array $_attributes = []
95	*
96	* Available Enctype Options
97	*
98	* 1. multipart => multipart/form-data
99	* 2. application => application/x-www-form-urlencoded
100	* 3. text => text/plain
101	*
102	* @return string\|object
103	*/
104	public function open(string $name = NULL, array $_attributes = [])
105	{
106	$this->setFormName($name, $_attributes);	14✔
107
108	$this->isEnctypeAttribute($_attributes);	14✔
109
110	$this->isWhereAttribute($name);	14✔
111
112	$this->isQueryAttribute();	14✔
113
114	$this->isPreventAttribute();	14✔
115
116	$this->setMethodType($_attributes);	14✔
117
118	$this->createFormElementByAttributes($_attributes, $return);	14✔
119
120	$this->isDatabaseProcessWithName($name, $return);	14✔
121
122	$this->isCSRFAttribute($return);	13✔
123
124	$this->_unsetopen();	13✔
125
126	$this->outputElement .= $return;	13✔
127
128	return $this;	13✔
129	}
130
131	/**
132	* Get form name
133	*
134	* @return string
135	*/
136	public function getName()
137	{
138	return $this->getFormName;	1✔
139	}
140
141	/**
142	* Validate error message.
143	*
144	* @param void
145	*
146	* @return string
147	*/
148	public function validateErrorMessage()
149	{
150	return Singleton::class('ZN\Validation\Data')->error('string');	1✔
151	}
152
153	/**
154	* Validate error array.
155	*
156	* @param void
157	*
158	* @return array
159	*/
160	public function validateErrorArray()
161	{
162	return Singleton::class('ZN\Validation\Data')->error('array');	1✔
163	}
164
165	/**
166	* Reset validation rules
167	*
168	* @param string $formName
169	*/
170	public function resetValidationRules(string $formName)
171	{
172	$session = Singleton::class('ZN\Storage\Session');	1✔
173
174	$session->delete('FormValidationRules' . $formName);	1✔
175	$session->delete('FormValidationMethod' . $formName);	1✔
176
177	return $this;	1✔
178	}
179
180	/**
181	* Closes form object.
182	*
183	* @param void
184	*
185	* @return string\|object
186	*/
187	public function close()
188	{
189	unset($this->settings['getrow']);	7✔
190
191	$this->getFormName = NULL;	7✔
192
193	if( isset($this->getJavascriptValidationFunction) )	7✔
194	{
195	$this->outputElement .= Inclusion\View::use('JavascriptValidationFunctions', $this->getJavascriptValidationFunction, true, __DIR__ . '/');
196
197	$this->getJavascriptValidationFunction = NULL;	1✔
198	}
199
200	if( $this->validateUsageThisForm === true )	7✔
201	{
202	$this->outputElement .= '<input type="hidden" name="ValidationFormName" value="' . $this->getValidationFormName . '">';	4✔
203
204	$this->getValidationFormName = NULL;	4✔
205
206	$this->validateUsageThisForm = false;	4✔
207	}
208
209	$this->outputElement .= '</form>' . EOL;	7✔
210
211	return $this;	7✔
212	}
213
214	/**
215	* datetime-local form object.
216	*
217	* @param string $name = NULL
218	* @param string $value = NULL
219	* @param array $_attributes = []
220	*
221	* @return string\|object
222	*/
223	public function datetimeLocal(string $name = NULL, string $value = NULL, array $_attributes = [])
224	{
225	return $this->_input($name, $value, $_attributes, 'datetime-local');	1✔
226	}
227
228	/**
229	* textarea form object.
230	*
231	* @param string $name = NULL
232	* @param string $value = NULL
233	* @param array $_attributes = []
234	*
235	* @return string\|object
236	*/
237	public function textarea(string $name = NULL, string $value = NULL, array $_attributes = [])
238	{
239	$this->setNameAttribute($name);	2✔
240
241	$this->setValueAttribute($value);	2✔
242
243	if( ! empty($this->settings['attr']['name']) )	2✔
244	{
245	$this->_postback($this->settings['attr']['name'], $value);	2✔
246
247	# 5.8.2.8[added]
248	$this->getVMethodMessages();	2✔
249
250	# 5.4.2[added]
251	$this->_validate($this->settings['attr']['name'], $this->settings['attr']['name']);	2✔
252
253	# 5.4.2[added]\|5.4.5\|5.4.6[edited]
254	$value = $this->_getrow('textarea', $value, $this->settings['attr']);	2✔
255	}
256
257	$this->commonMethodsForInputElements('textarea');	2✔
258
259	$this->getPermAttribute($perm);	2✔
260
261	$this->createTextareaElementByValueAndAttributes($value, $_attributes, $return);	2✔
262
263	$this->createBootstrapFormInputElementByType('textarea', $return, $_attributes, $return);	2✔
264
265	$this->outputElement .= $this->_perm($perm, $return);	2✔
266
267	return $this;	2✔
268	}
269
270	/**
271	* select form object.
272	*
273	* @param string $name = NULL
274	* @param string $optios = []
275	* @param mixed $selected = NULL
276	* @param array $_attributes = []
277	* @param bool $multiple = false
278	*
279	* @return string\|object
280	*/
281	public function select(string $name = NULL, array $options = [], $selected = NULL, array $_attributes = [], bool $multiple = false)
282	{
283	$this->isRepeatData($options);	10✔
284
285	$this->isTableOrQueryData($options);	10✔
286
287	$this->setOptionAttribute($options);	10✔
288
289	$this->isExcludeAttribute($options);	10✔
290
291	$this->isIncludeAttribute($options);	10✔
292
293	$this->isOrderAttribute($options);	10✔
294
295	$this->setSelectedAttribute($selected, $options);	10✔
296
297	$this->setMultipleAttribute($multiple, $_attributes);	10✔
298
299	$this->setNameAttributeWithReference($name, $_attributes);	10✔
300
301	if( ! empty($_attributes['name']) )	10✔
302	{
303	$this->_postback($_attributes['name'], $selected);	10✔
304
305	# 5.8.2.8[added]
306	$this->getVMethodMessages();	10✔
307
308	# 5.4.2[added]
309	$this->_validate($_attributes['name'], $_attributes['name']);	10✔
310
311	# 5.4.2[added]\|5.4.5\|5.4.6[edited]
312	$selected = $this->_getrow('select', $selected, $_attributes);	10✔
313	}
314
315	$this->commonMethodsForInputElements('select');	10✔
316
317	$this->getPermAttribute($perm);	10✔
318
319	$this->createSelectElement($options, $selected, $_attributes, $return);	10✔
320
321	$this->createBootstrapFormInputElementByType('select', $return, $_attributes, $return);	10✔
322
323	$this->_unsetselect();	10✔
324
325	$this->outputElement .= $this->_perm($perm, $return);	10✔
326
327	return $this;	10✔
328	}
329
330	/**
331	* select type multiselect form object.
332	*
333	* @param string $name = NULL
334	* @param string $optios = []
335	* @param mixed $selected = NULL
336	* @param array $_attributes = []
337	*
338	* @return string\|object
339	*/
340	public function multiselect(string $name = NULL, array $options = [], $selected = NULL, array $_attributes = [])
341	{
UNCOV 342	return $this->select($name, $options, $selected, $_attributes, true);	×
343	}
344
345	/**
346	* hidden form object.
347	*
348	* @param string $name = NULL
349	* @param string $value = NULL
350	*
351	* @return string
352	*/
353	public function hidden($name = NULL, string $value = NULL)
354	{
355	$name = $this->settings['attr']['name' ] ?? $name ;	15✔
356	$value = $this->settings['attr']['value'] ?? $value;	15✔
357
358	$this->settings['attr'] = [];	15✔
359
360	$hiddens = '';	15✔
361
362	if( is_array($name) ) foreach( $name as $key => $val )	15✔
363	{
364	$hiddens .= $this->createHiddenElement($key, $val);	1✔
365	}
366	else
367	{
368	$hiddens = $this->createHiddenElement($name, $value);	14✔
369	}
370
371	$this->outputElement .= $hiddens;	15✔
372
373	return $this;	15✔
374	}
375
376	/**
377	* file form object.
378	*
379	* @param string $name = NULL
380	* @param string $value = NULL
381	* @param array $_attributes = []
382	*
383	* @return string\|object
384	*/
385	public function file(string $name = NULL, bool $multiple = false, array $_attributes = [])
386	{
387	if( ! empty($this->settings['attr']['multiple']) )	2✔
388	{
389	$multiple = true;	1✔
390	}
391
392	$name = $this->settings['attr']['name'] ?? $name;	2✔
393
394	if( $multiple === true )	2✔
395	{
396	$this->settings['attr']['multiple'] = 'multiple';	2✔
397	$name = Base::suffix($name, '[]');	2✔
398	}
399
400	$this->commonMethodsForInputElements('file');	2✔
401
402	return $this->_input($name, '', $_attributes, 'file');	2✔
403	}
404
405	/**
406	* Protected create hidden element
407	*/
408	protected function createHiddenElement($key, $value)
409	{
410	return '<input type="hidden" name="' . $key . '" id="' . $key . '" value="' . $value . '">' . EOL;	15✔
411	}
412
413	/**
414	* Protected create select element
415	*/
416	protected function createSelectElement($options, $selected, $_attributes, &$return)
417	{
418	$option = '';	10✔
419
420	if( is_string($selected) && Json::check($selected) )	10✔
421	{
UNCOV 422	$selected = Json::decodeArray($selected);	×
423	}
424
425	if( is_array($options) ) foreach( $options as $key => $value )	10✔
426	{
427	if( is_array($selected) )	10✔
428	{
UNCOV 429	if( in_array($key, $selected) )	×
430	{
UNCOV 431	$select = ' selected="selected"';	×
432	}
433	else
434	{
UNCOV 435	$select = "";	×
436	}
437	}
438	else
439	{
440	if( $selected === $key \|\| ( is_numeric($selected) && $selected == $key ) )	10✔
441	{
442	$select = ' selected="selected"';	1✔
443	}
444	else
445	{
446	$select = "";	10✔
447	}
448	}
449
450	if( is_numeric($value) \|\| ! empty($value) )	10✔
451	{
452	$option .= '<option value="'.$key.'"'.$select.'>'.$value.'</option>'.EOL;	10✔
453	}
454	}
455
456	if( isset($this->settings['attr']['only-options']) )	10✔
457	{
458	unset($this->settings['attr']['only-options']);	1✔
459
460	$return = $option;	1✔
461	}
462	else
463	{
464	$return = '<select'.$this->attributes($_attributes).'>' . $option . '</select>'.EOL;	9✔
465	}
466	}	10✔
467
468	/**
469	* Protected set multiple attribute
470	*/
471	protected function setMultipleAttribute($multiple, &$_attributes)
472	{
473	if( $multiple === true )	10✔
474	{
UNCOV 475	$_attributes['multiple'] = 'multiple';	×
476	}
477	}	10✔
478
479	/**
480	* Protected set selected attribute
481	*/
482	protected function setSelectedAttribute(&$selected, $options)
483	{
484	$selected = $this->settings['selectedKey'] ?? $selected;	11✔
485
486	if( isset($this->settings['selectedValue']) )	11✔
487	{
488	$flip = array_flip($options);	1✔
489	$selected = $flip[$this->settings['selectedValue']];	1✔
490	}
491	}	11✔
492
493	/**
494	* Protected is order attribute
495	*/
496	protected function isOrderAttribute(&$options)
497	{
498	if( isset($this->settings['order']['type']) )	10✔
499	{
500	$options = Arrays\Sort::order($options, $this->settings['order']['type'], $this->settings['order']['flags']);	1✔
501	}
502	}	10✔
503
504	/**
505	* Protected is exclude attribute
506	*/
507	protected function isExcludeAttribute(&$options)
508	{
509	if( isset($this->settings['exclude']) )	10✔
510	{
511	$options = Arrays\Excluding::use($options, $this->settings['exclude']);
512	}
513	}	10✔
514
515	/**
516	* Protected is include attribute
517	*/
518	protected function isIncludeAttribute(&$options)
519	{
520	if( isset($this->settings['include']) )	10✔
521	{
522	$options = Arrays\Including::use($options, $this->settings['include']);
523	}
524	}	10✔
525
526	/**
527	* Protected set option attribute
528	*/
529	protected function setOptionAttribute(&$options)
530	{
531	$options = $this->settings['option'] ?? $options;	10✔
532	}	10✔
533
534	/**
535	* Protected is repeat data
536	*/
537	protected function isRepeatData(&$options)
538	{
539	if( ! empty($this->settings['attr']['repeat']) )	10✔
540	{
541	$key = key($options); $current = current($options);	1✔
542
543	if( $key > $current )	1✔
544	{
545	$ocurrent = $current;	1✔
546	$current = $key;	1✔
547	$key = $ocurrent;	1✔
548	}
549
550	for( $i = $key; $i <= $current; $i++ )	1✔
551	{
552	$options[$i] = $i;	1✔
553	}
554
555	unset($this->settings['attr']['repeat']);	1✔
556	}
557	}	10✔
558
559	/**
560	* Protected is table or query data
561	*/
562	protected function isTableOrQueryData(&$options)
563	{
564	if( ! empty($this->settings['table']) \|\| ! empty($this->settings['query']) )	10✔
565	{
566	$key = key($options);	2✔
567	$current = current($options);	2✔
568
569	if( IS::closure($current) )	2✔
570	{
571	$selectedColumns = ['*'];	1✔
572	}
573	else
574	{
575	$selectedColumns = [$key, $current];	1✔
576	}
577
578	array_shift($options);	2✔
579
580	$dbClass = Singleton::class('ZN\Database\DB');	2✔
581
582	if( ! empty($this->settings['table']) )	2✔
583	{
584	$table = $this->settings['table'];	2✔
585
586	if( strstr($table, ':') )	2✔
587	{
588	$tableEx = explode(':', $table);	×
589	$table = $tableEx[1];	×
UNCOV 590	$db = $tableEx[0];	×
591
592	$db = $dbClass->differentConnection($db);	×
UNCOV 593	$result = $db->select(...$selectedColumns)->get($table)->result();	×
594	}
595	else
596	{
597	$result = $dbClass->select(...$selectedColumns)->get($table)->result();	2✔
598	}
599	}
600	else
601	{
UNCOV 602	$result = $dbClass->query($this->settings['query'])->result();	×
603	}
604
605	foreach( $result as $row )	2✔
606	{
607	if( IS::closure($current) )	2✔
608	{
609	$options[$row->$key] = $current($row);	1✔
610	}
611	else
612	{
613	$options[$row->$key] = $row->$current;	1✔
614	}
615	}
616	}
617	}	10✔
618
619	/**
620	* Protected create textarea element by value and attributes
621	*/
622	protected function createTextareaElementByValueAndAttributes($value, $_attributes, &$return)
623	{
624	$return = '<textarea'.$this->attributes($_attributes).'>'.$value.'</textarea>' . EOL;	2✔
625	}	2✔
626
627	/**
628	* Protected set textarea name attribute
629	*/
630	protected function setNameAttribute($name)
631	{
632	if( ! isset($this->settings['attr']['name']) && ! empty($name) )	2✔
633	{
634	$this->settings['attr']['name'] = $name;	2✔
635	}
636	}	2✔
637
638	/**
639	* Protected set value attribute
640	*/
641	protected function setValueAttribute(&$value)
642	{
643	$value = $this->settings['attr']['value'] ?? $value;	2✔
644	}	2✔
645
646	/**
647	* Protected set form name
648	*/
649	protected function setFormName(&$name, &$_attributes)
650	{
651	$this->getFormName = $this->getValidationFormName = $name = $this->settings['attr']['name'] ?? $name;	14✔
652
653	$_attributes['name'] = $name;	14✔
654	}	14✔
655
656	/**
657	* Protected create form element by attributes
658	*/
659	protected function createFormElementByAttributes($_attributes, &$return)
660	{
661	$this->changeFormAttributes	14✔
662	([
663	'inline' => 'class:form-inline',	14✔
664	'horizontal' => 'class:form-horizontal'
665	]);
666
667	$return = '<form'.$this->attributes($_attributes).'>' . EOL;	14✔
668	}	14✔
669
670	/**
671	* Protected is database process with name
672	*/
673	protected function isDatabaseProcessWithName($name, &$return)
674	{
675	$return .= $this->_process($name, $this->method);	14✔
676	}	13✔
677
678	/**
679	* Protected is csrf attribute
680	*/
681	protected function isCSRFAttribute(&$return)
682	{
683	if( isset($this->settings['token']) )	13✔
684	{
685	$return .= CSRFInput();	1✔
686	}
687	}	13✔
688
689	/**
690	* Protected set method type
691	*/
692	protected function setMethodType(&$_attributes)
693	{
694	$this->method = ($_attributes['method'] = $_attributes['method'] ?? $this->settings['attr']['method'] ?? 'post');	14✔
695	}	14✔
696
697	/**
698	* Protected is enctype attribute
699	*/
700	protected function isEnctypeAttribute(&$_attributes)
701	{
702	if( isset($_attributes['enctype']) )	14✔
703	{
704	$enctype = $_attributes['enctype'];	1✔
705
706	if( isset($this->enctypes[$enctype]) )	1✔
707	{
708	$_attributes['enctype'] = $this->enctypes[$enctype];	1✔
709	}
710	}
711	}	14✔
712
713	/**
714	* Protected is where attribute
715	*/
716	protected function isWhereAttribute($name)
717	{
718	if( isset($this->settings['where']) )	14✔
719	{
720	$this->settings['getrow'] = Singleton::class('ZN\Database\DB')->get($name)->row();	2✔
721	}
722	}	14✔
723
724	/**
725	* Protected is query attribute
726	*/
727	protected function isQueryAttribute()
728	{
729	if( $query = ($this->settings['query'] ?? NULL) )	14✔
730	{
731	$this->settings['getrow'] = Singleton::class('ZN\Database\DB')->query($query)->row();	1✔
732	}
733	}	14✔
734
735	/**
736	* Protected is prevent attribute
737	*/
738	protected function isPreventAttribute()
739	{
740	if( isset($this->settings['attr']['prevent']) )	14✔
741	{
742	unset($this->settings['attr']['prevent']);	1✔
743
744	$this->settings['attr']['onsubmit'] = 'event.preventDefault()';	1✔
745	}
746	}	14✔
747
748	/**
749	* protected process
750	*
751	* @param string $name
752	* @param string $method
753	*
754	* @return mixed
755	*/
756	protected function _process($name, $method)
757	{
758	if( $process = ($this->settings['process'] ?? NULL) )	14✔
759	{
760	if( Method::$method('FormProcessValue') )	4✔
761	{
762	if( Singleton::class('ZN\Validation\Data')->check() )	3✔
763	{
764	$dbClass = Singleton::class('ZN\Database\DB');	3✔
765
766	if( $process === 'update' )	3✔
767	{
768	$dbClass->where	1✔
769	(
770	$whereColumn = $this->settings['whereColumn'],	1✔
771	$whereValue = $this->settings['whereValue']	1✔
772	)
773	->update(strtolower($method).':'.$name);	1✔
774
775	$this->getUpdateRow = $this->settings['getrow'] = $dbClass->where($whereColumn, $whereValue)->get($name)->row();	1✔
776	}
777	elseif( $process === 'insert' )	2✔
778	{
779	if( isset($this->settings['duplicateCheck']) )	1✔
780	{
781	$dbClass->duplicateCheck();	1✔
782	}
783
784	$dbClass->insert(strtolower($method).':'.$name);	1✔
785	}
786	else
787	{
788	throw new InvalidArgumentException('[Form::process()] method can take one of the values [update or insert].');	1✔
789	}
790	}
791	}
792
793	return (string) $this->hidden('FormProcessValue', 'FormProcessValue');	3✔
794	}
795	}	10✔
796
797	/**
798	* protected unset select variables
799	*
800	* @param void
801	*
802	* @return void
803	*/
804	protected function _unsetselect()
805	{
806	unset($this->settings['table']);	10✔
807	unset($this->settings['query']);	10✔
808	unset($this->settings['option']);	10✔
809	unset($this->settings['exclude']);	10✔
810	unset($this->settings['include']);	10✔
811	unset($this->settings['order']);	10✔
812	unset($this->settings['selectedKey']);	10✔
813	unset($this->settings['selectedValue']);	10✔
814	}	10✔
815
816	/**
817	* protected unset open variables
818	*
819	* @param void
820	*
821	* @return void
822	*/
823	protected function _unsetopen()
824	{
825	unset($this->settings['where']);	13✔
826	unset($this->settings['whereValue']);	13✔
827	unset($this->settings['whereColumn']);	13✔
828	unset($this->settings['query']);	13✔
829	unset($this->settings['token']);	13✔
830	unset($this->settings['process']);	13✔
831	unset($this->settings['duplicateCheck']);	13✔
832	}	13✔
833	}

znframework / fullpack-edition / 4405648418

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous