com.newsblob.phphtmllib/form/FormProcessor.inc

<?php
/**
 * This file contains the FormProcessor class.
 *
 * $Id: FormProcessor.inc,v 1.20 2003/02/19 00:37:45 hemna Exp $
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @author Suren Markossian <suren@cbestwhat?>
 * @package phpHtmlLib
 * @subpackage FormProcessing
 *
 * @copyright LGPL - See LICENCE
 *
 */

define(FORM_ACTION, "_form_action");
define(FORM_VISITED, "_form_visited");
define(FORM_CONFIRM, "_form_confirm");

/**
 * This is the main engine for the processing
 * of Forms.  It builds the form tag, and calls
 * the appropriate FormContent methods to build
 * the FormElement's and validation, as well as 
 * backend processing to do the action after the
 * data has been validated.
 *
 * @package phpHtmlLib
 * @subpackage FormProcessing
 */
class FormProcessor extends Container {

    /**
     * This holds the name of the form
     * for js that needs it
     */
    var $_form_name="forms[0]";


    /**
     * The action for the form tag
     */
    var $_form_action = "";

    /**
     * The form's enctype attribute.
     * ie <form enctype="multipart/form_data">
     *
     */
    var $_form_enctype = NULL;

    /**
     * This holds the FormContent Object
     * that knows how to render the
     * form.
     */
    var $_form_content = NULL;


    /**
     * This flag lets us know there
     * were errors during processing or
     * validating the form.
     */
    var $_has_errors = FALSE;

    /**
     * Flag to let us know the form
     * has been confirmed.
     */
    var $_confirmed = FALSE;

    /**
     * Flag to let us know if we should
     * render the form after it was
     * successfully processed
     */
    var $_form_success_render = TRUE;


    /**
     * The constructor for the FormProcessor
     *
     * @param FormContent object
     * @param string the form name
     */
    function FormProcessor(&$form_content, $form_name="forms[0]",
                           $form_action=NULL) {

        $this->_form_name = $form_name;
        $this->_form_content = &$form_content;
        $this->_form_content->set_form_name($form_name);

        if ($form_action != NULL) {
            $this->_form_action = $form_action;
        } else {
            $this->_form_action = $_SERVER["PHP_SELF"];
        }

        //now process the form
        $this->_process_form();
    }

    /**
     * This method does the logic of
     * doing the form processing
     */
    function _process_form() {
        //let the form build the FormElement objects
        //that will be used by the form
        $this->_form_content->form_init_elements();

        //first we need to
        if (!$_POST[FORM_VISITED]) {
            $this->_form_content->form_init_data();
        }


        //we only need to process the form
        //if it has been visited. Otherwise
        //it just gets rendered.
        if ($_POST[FORM_VISITED] == 1) {
            $this->_form_content->set_action($_POST[FORM_ACTION]);

            //let see if this was a confirmation page.
            if ( $_POST[FORM_CONFIRM] == 1 ) {
                //looks like this was a submit on a
                //confirmation page.  we don't need
                //to do form field validation.
                $this->_confirmed = TRUE;
            }

            //now do the validation
            if (!$this->_confirmed) {
                //we haven't been confirmed, so we
                //need to validate the form.
                if ($this->can_validate()) {
                    //looks like we should do validation
                    $this->do_validation();
                }
                if (!$this->_has_errors) {
                    //no errors were found
                    if ($this->_form_content->has_confirm()) {
                        //the form content has a confirmation
                        //we need to process
                        $this->_has_errors = !$this->_pre_confirm();
                    } else {
                        //make sure we don't have any backend errors
                        $this->_has_errors = !$this->_form_content->form_backend_validation();
                        if (!$this->_has_errors) {
                            $this->_has_errors = !$this->_process_action();
                        }
                    }
                }
            } else {
                //make sure we don't have any backend errors
                $this->_has_errors = !$this->_form_content->form_backend_validation();
                if (!$this->_has_errors) {
                    $this->_has_errors = !$this->_process_action();
                }                
            }
        }
    }


    /**
     * This function is responsible for
     * processing the form action
     * after validation, and form confirmation
     * happens.
     *
     */
    function _process_action() {
        //There were no validation errors.
        return $this->_form_content->form_action();
    }

    /**
     * This method calls the FormContent 
     * to let it do any data munging before the
     * confirmation page is rendered
     */
    function _pre_confirm() {
        return $this->_form_content->pre_confirm();
    }


    /**
     * This method walks the FormContent's visible elements
     * and calls the validation function for the element
     *
     */
    function do_validation() {
        $keys = array_keys( $this->_form_content->_elements );
        foreach( $keys as $key ) {
            $valid = $this->_form_content->_elements[$key]->_do_validation();
            if (!$valid) {
                $this->_has_errors = TRUE;
            }
        }
    }


    /**
     * This method is called to render the form's html
     *
     */
    function render($indent_level=0, $output_debug=0) {
        if ($this->_has_errors) {
            //we need to render the form errors
            //and then the form
            return $this->render_error($indent_level, $output_debug);
        } else {
            //there are no errors!
            if ($_POST[FORM_VISITED] == 1) {
                //looks like the form has been processed?
                if ($this->_form_content->has_confirm() && !$this->_confirmed) {
                    return $this->render_confirm($indent_level, $output_debug);
                } else {
                    //Looks like the action worked
                    $success = $this->_form_content->form_success($this->_message);
                    
                    if ($this->_form_success_render) {
                        return $this->render_form($indent_level, $output_debug,
                                                  $success);
                    } else {
                        if (method_exists($success,"render")) {
                            //looks like this is an object.
                            //we'll assume it has a render function.
                            return $success->render($indent_level, $output_debug);
                        } else {
                            //since its not an object,
                            //lets just display it.
                            return $success;
                        }
                    }
                }
            } else {
                return $this->render_form($indent_level, $output_debug);
            }
        }
    }


    /**
     * This renders the form
     *
     * @param the FormContent->form() object
     * @param int - $indent_level
     * @param int - $output_debug
     * @param object - the form errors object.
     * @return raw html
     */
    function render_form( $indent_level, $output_debug, $obj=NULL ) {

        //build the $this->_form object.
        $this->_build_form_tag();

        if ($obj) {
            $this->_form->add_reference( $obj );
        }

        $this->_form->add_reference( $this->_form_content->form() );

        //add the FormContent's hidden declared
        //hidden form fields.
        $this->_add_hidden_fields();

        //Ok lets add our hidden vars
        $this->__hidden_fields();

        return $this->_form->render($indent_level, $output_debug);
    }

    /**
     * This function renders the confirmation
     * page.  This page sits in between the
     * front end form, and the action handler.
     * This only gets called after a form
     * and its data has been successfully
     * validated.
     *
     * @param int - $indent_level
     * @param int - $output_debug
     *
     * @return string - the raw html
     */
    function render_confirm( $indent_level, $output_debug ) {
        //build the $this->_form object.
        $this->_build_form_tag();

        //add the confirm object/html
        $confirm = &$this->_form_content->form_confirm( $this->data );
        $this->_form->add_reference( $confirm );

        //ok add all of the submitted data as hidden form fields
        $this->_add_confirm_data();

        //Ok lets add our hidden vars
        $this->__hidden_fields();

        return $this->_form->render($indent_level, $output_debug);
    }


    /**
     * This renders the error table
     * and then the form with the fields
     *
     * @param array - the form field vlues.
     * @param array - array of errors.
     * @param int - $indent_level
     * @param int - $output_debug
     *
     * @return raw html
     */
    function render_error( $indent_level, $output_debug) {
        $wrapper_div = new DIVtag;

        //Ok first lets build the error table
        $errors = &$this->_form_content->form_errors();
        if ($errors != NULL) $wrapper_div->add( $errors, html_br() );

        return $this->render_form( $indent_level, $output_debug, $wrapper_div);
    }


    //***********************************************//
    //*       utility functions for this class      *//
    //***********************************************//


    /**
     * This method lets us turn on/off the
     * ability to do validation for the form
     *
     * @return BOOLEAN
     */
    function can_validate() {
        return TRUE;
    }


    /**
     * This function turns on the ability to
     * render the form after the success
     * of the action.  Normally this feature
     * is off
     *
     */
    function set_render_form_after_success() {
        $this->_form_success_render = TRUE;
    }


    /**
     * this function builds the FORMtag object
     * and its attributes.
     *
     * @return FORMtag object.
     */
    function _build_form_tag() {
        $form_attrs = array("method" => "POST",
                            "action" => $this->_form_action,
                            "name" => $this->_form_name,
                                                        "style" => "margin: 0px 0px 0px 0px;");
        if ($this->_enctype != NULL)
            $form_attrs["enctype"] = $this->_enctype;
        if ($this->_target != NULL)
            $form_attrs["target"] = $this->_target;
        if ($this->_onsubmit != NULL)
            $form_attrs["onSubmit"] = $this->_onsubmit;

        $this->_form = new FORMtag( $form_attrs );
    }

    /**
     * This adds all of the submitted data as
     * hidden form fields
     *
     */
    function _add_confirm_data() {
        $keys = array_keys( $this->_form_content->_elements );
        foreach( $keys as $key ) {
            $element_name = $this->_form_content->_elements[$key]->get_element_name();
            $values = $this->_form_content->_elements[$key]->get_value();
            if (is_array($values)) {
                foreach($values as $value) {
                    $this->_form->add( form_hidden($element_name, $value) );
                }                
            } else {
                $this->_form->add( form_hidden($element_name, $values) );

            }
        }

        $keys = array_keys( $this->_form_content->_hidden_elements );
        foreach( $keys as $key ) {
            $this->_form->add( $this->_form_content->_hidden_elements[$key]->get_element() );
        }
    }


    /**
     * This function adds the form content's
     * hidden form fields to the
     * form automatically
     *
     */
    function _add_hidden_fields() {
        //Lets add the form's hidden vars it wants
        foreach ($this->_form_content->_hidden_elements as $element) {
            $this->_form->add( $element->get_element() );
        }
    }


    /**
     * This method adds the processor specific
     * hidden fields.
     *
     */
    function __hidden_fields() {
        $this->_form->add( form_hidden(FORM_ACTION),
                           form_hidden(FORM_VISITED,1) );

        if ($this->_form_content->has_confirm() && !$this->_confirmed) {
            if (!$_POST[FORM_VISITED] || $this->_has_errors) {
                $this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
            } else {
                $this->_form->add( form_hidden(FORM_CONFIRM, 1 ) );
            }
        } else if ($this->_form_content->has_confirm() && !$this->_confirmed) {
            //reset this so they can submit again
            $this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
        }
    }
}
?>
1	<?php
2	/**
3	* This file contains the FormProcessor class.
4	*
5	* $Id: FormProcessor.inc,v 1.20 2003/02/19 00:37:45 hemna Exp $
6	*
7	* @author Walter A. Boring IV <waboring@buildabetterweb.com>
8	* @author Suren Markossian <suren@cbestwhat?>
9	* @package phpHtmlLib
10	* @subpackage FormProcessing
11	*
12	* @copyright LGPL - See LICENCE
13	*
14	*/
15
16	define(FORM_ACTION, "_form_action");
17	define(FORM_VISITED, "_form_visited");
18	define(FORM_CONFIRM, "_form_confirm");
19
20	/**
21	* This is the main engine for the processing
22	* of Forms. It builds the form tag, and calls
23	* the appropriate FormContent methods to build
24	* the FormElement's and validation, as well as
25	* backend processing to do the action after the
26	* data has been validated.
27	*
28	* @package phpHtmlLib
29	* @subpackage FormProcessing
30	*/
31	class FormProcessor extends Container {
32
33	/**
34	* This holds the name of the form
35	* for js that needs it
36	*/
37	var $_form_name="forms[0]";
38
39
40	/**
41	* The action for the form tag
42	*/
43	var $_form_action = "";
44
45	/**
46	* The form's enctype attribute.
47	* ie <form enctype="multipart/form_data">
48	*
49	*/
50	var $_form_enctype = NULL;
51
52	/**
53	* This holds the FormContent Object
54	* that knows how to render the
55	* form.
56	*/
57	var $_form_content = NULL;
58
59
60	/**
61	* This flag lets us know there
62	* were errors during processing or
63	* validating the form.
64	*/
65	var $_has_errors = FALSE;
66
67	/**
68	* Flag to let us know the form
69	* has been confirmed.
70	*/
71	var $_confirmed = FALSE;
72
73	/**
74	* Flag to let us know if we should
75	* render the form after it was
76	* successfully processed
77	*/
78	var $_form_success_render = TRUE;
79
80
81	/**
82	* The constructor for the FormProcessor
83	*
84	* @param FormContent object
85	* @param string the form name
86	*/
87	function FormProcessor(&$form_content, $form_name="forms[0]",
88	$form_action=NULL) {
89
90	$this->_form_name = $form_name;
91	$this->_form_content = &$form_content;
92	$this->_form_content->set_form_name($form_name);
93
94	if ($form_action != NULL) {
95	$this->_form_action = $form_action;
96	} else {
97	$this->_form_action = $_SERVER["PHP_SELF"];
98	}
99
100	//now process the form
101	$this->_process_form();
102	}
103
104	/**
105	* This method does the logic of
106	* doing the form processing
107	*/
108	function _process_form() {
109	//let the form build the FormElement objects
110	//that will be used by the form
111	$this->_form_content->form_init_elements();
112
113	//first we need to
114	if (!$_POST[FORM_VISITED]) {
115	$this->_form_content->form_init_data();
116	}
117
118
119	//we only need to process the form
120	//if it has been visited. Otherwise
121	//it just gets rendered.
122	if ($_POST[FORM_VISITED] == 1) {
123	$this->_form_content->set_action($_POST[FORM_ACTION]);
124
125	//let see if this was a confirmation page.
126	if ( $_POST[FORM_CONFIRM] == 1 ) {
127	//looks like this was a submit on a
128	//confirmation page. we don't need
129	//to do form field validation.
130	$this->_confirmed = TRUE;
131	}
132
133	//now do the validation
134	if (!$this->_confirmed) {
135	//we haven't been confirmed, so we
136	//need to validate the form.
137	if ($this->can_validate()) {
138	//looks like we should do validation
139	$this->do_validation();
140	}
141	if (!$this->_has_errors) {
142	//no errors were found
143	if ($this->_form_content->has_confirm()) {
144	//the form content has a confirmation
145	//we need to process
146	$this->_has_errors = !$this->_pre_confirm();
147	} else {
148	//make sure we don't have any backend errors
149	$this->_has_errors = !$this->_form_content->form_backend_validation();
150	if (!$this->_has_errors) {
151	$this->_has_errors = !$this->_process_action();
152	}
153	}
154	}
155	} else {
156	//make sure we don't have any backend errors
157	$this->_has_errors = !$this->_form_content->form_backend_validation();
158	if (!$this->_has_errors) {
159	$this->_has_errors = !$this->_process_action();
160	}
161	}
162	}
163	}
164
165
166	/**
167	* This function is responsible for
168	* processing the form action
169	* after validation, and form confirmation
170	* happens.
171	*
172	*/
173	function _process_action() {
174	//There were no validation errors.
175	return $this->_form_content->form_action();
176	}
177
178	/**
179	* This method calls the FormContent
180	* to let it do any data munging before the
181	* confirmation page is rendered
182	*/
183	function _pre_confirm() {
184	return $this->_form_content->pre_confirm();
185	}
186
187
188	/**
189	* This method walks the FormContent's visible elements
190	* and calls the validation function for the element
191	*
192	*/
193	function do_validation() {
194	$keys = array_keys( $this->_form_content->_elements );
195	foreach( $keys as $key ) {
196	$valid = $this->_form_content->_elements[$key]->_do_validation();
197	if (!$valid) {
198	$this->_has_errors = TRUE;
199	}
200	}
201	}
202
203
204	/**
205	* This method is called to render the form's html
206	*
207	*/
208	function render($indent_level=0, $output_debug=0) {
209	if ($this->_has_errors) {
210	//we need to render the form errors
211	//and then the form
212	return $this->render_error($indent_level, $output_debug);
213	} else {
214	//there are no errors!
215	if ($_POST[FORM_VISITED] == 1) {
216	//looks like the form has been processed?
217	if ($this->_form_content->has_confirm() && !$this->_confirmed) {
218	return $this->render_confirm($indent_level, $output_debug);
219	} else {
220	//Looks like the action worked
221	$success = $this->_form_content->form_success($this->_message);
222
223	if ($this->_form_success_render) {
224	return $this->render_form($indent_level, $output_debug,
225	$success);
226	} else {
227	if (method_exists($success,"render")) {
228	//looks like this is an object.
229	//we'll assume it has a render function.
230	return $success->render($indent_level, $output_debug);
231	} else {
232	//since its not an object,
233	//lets just display it.
234	return $success;
235	}
236	}
237	}
238	} else {
239	return $this->render_form($indent_level, $output_debug);
240	}
241	}
242	}
243
244
245	/**
246	* This renders the form
247	*
248	* @param the FormContent->form() object
249	* @param int - $indent_level
250	* @param int - $output_debug
251	* @param object - the form errors object.
252	* @return raw html
253	*/
254	function render_form( $indent_level, $output_debug, $obj=NULL ) {
255
256	//build the $this->_form object.
257	$this->_build_form_tag();
258
259	if ($obj) {
260	$this->_form->add_reference( $obj );
261	}
262
263	$this->_form->add_reference( $this->_form_content->form() );
264
265	//add the FormContent's hidden declared
266	//hidden form fields.
267	$this->_add_hidden_fields();
268
269	//Ok lets add our hidden vars
270	$this->__hidden_fields();
271
272	return $this->_form->render($indent_level, $output_debug);
273	}
274
275	/**
276	* This function renders the confirmation
277	* page. This page sits in between the
278	* front end form, and the action handler.
279	* This only gets called after a form
280	* and its data has been successfully
281	* validated.
282	*
283	* @param int - $indent_level
284	* @param int - $output_debug
285	*
286	* @return string - the raw html
287	*/
288	function render_confirm( $indent_level, $output_debug ) {
289	//build the $this->_form object.
290	$this->_build_form_tag();
291
292	//add the confirm object/html
293	$confirm = &$this->_form_content->form_confirm( $this->data );
294	$this->_form->add_reference( $confirm );
295
296	//ok add all of the submitted data as hidden form fields
297	$this->_add_confirm_data();
298
299	//Ok lets add our hidden vars
300	$this->__hidden_fields();
301
302	return $this->_form->render($indent_level, $output_debug);
303	}
304
305
306	/**
307	* This renders the error table
308	* and then the form with the fields
309	*
310	* @param array - the form field vlues.
311	* @param array - array of errors.
312	* @param int - $indent_level
313	* @param int - $output_debug
314	*
315	* @return raw html
316	*/
317	function render_error( $indent_level, $output_debug) {
318	$wrapper_div = new DIVtag;
319
320	//Ok first lets build the error table
321	$errors = &$this->_form_content->form_errors();
322	if ($errors != NULL) $wrapper_div->add( $errors, html_br() );
323
324	return $this->render_form( $indent_level, $output_debug, $wrapper_div);
325	}
326
327
328
329
330	//***********************************************//
331	//* utility functions for this class *//
332	//***********************************************//
333
334
335	/**
336	* This method lets us turn on/off the
337	* ability to do validation for the form
338	*
339	* @return BOOLEAN
340	*/
341	function can_validate() {
342	return TRUE;
343	}
344
345
346	/**
347	* This function turns on the ability to
348	* render the form after the success
349	* of the action. Normally this feature
350	* is off
351	*
352	*/
353	function set_render_form_after_success() {
354	$this->_form_success_render = TRUE;
355	}
356
357
358	/**
359	* this function builds the FORMtag object
360	* and its attributes.
361	*
362	* @return FORMtag object.
363	*/
364	function _build_form_tag() {
365	$form_attrs = array("method" => "POST",
366	"action" => $this->_form_action,
367	"name" => $this->_form_name,
368	"style" => "margin: 0px 0px 0px 0px;");
369	if ($this->_enctype != NULL)
370	$form_attrs["enctype"] = $this->_enctype;
371	if ($this->_target != NULL)
372	$form_attrs["target"] = $this->_target;
373	if ($this->_onsubmit != NULL)
374	$form_attrs["onSubmit"] = $this->_onsubmit;
375
376	$this->_form = new FORMtag( $form_attrs );
377	}
378
379	/**
380	* This adds all of the submitted data as
381	* hidden form fields
382	*
383	*/
384	function _add_confirm_data() {
385	$keys = array_keys( $this->_form_content->_elements );
386	foreach( $keys as $key ) {
387	$element_name = $this->_form_content->_elements[$key]->get_element_name();
388	$values = $this->_form_content->_elements[$key]->get_value();
389	if (is_array($values)) {
390	foreach($values as $value) {
391	$this->_form->add( form_hidden($element_name, $value) );
392	}
393	} else {
394	$this->_form->add( form_hidden($element_name, $values) );
395
396	}
397	}
398
399	$keys = array_keys( $this->_form_content->_hidden_elements );
400	foreach( $keys as $key ) {
401	$this->_form->add( $this->_form_content->_hidden_elements[$key]->get_element() );
402	}
403	}
404
405
406	/**
407	* This function adds the form content's
408	* hidden form fields to the
409	* form automatically
410	*
411	*/
412	function _add_hidden_fields() {
413	//Lets add the form's hidden vars it wants
414	foreach ($this->_form_content->_hidden_elements as $element) {
415	$this->_form->add( $element->get_element() );
416	}
417	}
418
419
420	/**
421	* This method adds the processor specific
422	* hidden fields.
423	*
424	*/
425	function __hidden_fields() {
426	$this->_form->add( form_hidden(FORM_ACTION),
427	form_hidden(FORM_VISITED,1) );
428
429	if ($this->_form_content->has_confirm() && !$this->_confirmed) {
430	if (!$_POST[FORM_VISITED] \|\| $this->_has_errors) {
431	$this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
432	} else {
433	$this->_form->add( form_hidden(FORM_CONFIRM, 1 ) );
434	}
435	} else if ($this->_form_content->has_confirm() && !$this->_confirmed) {
436	//reset this so they can submit again
437	$this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
438	}
439	}
440	}
441	?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26