com.newsblob.phphtmllib/form/FormProcessor.inc

<?php
/**
 * This file contains the FormProcessor class.
 *
 * $Id: FormProcessor.inc,v 1.1 2003/02/22 21:07:42 jonen 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"];
        }

    }

    /**
     * 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) {
        //now process the form
        $this->_process_form();

        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	jonen	1.1	<?php
2			/**
3			* This file contains the FormProcessor class.
4			*
5	jonen	1.2	* $Id: FormProcessor.inc,v 1.1 2003/02/22 21:07:42 jonen Exp $
6	jonen	1.1	*
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			}
101
102			/**
103			* This method does the logic of
104			* doing the form processing
105			*/
106			function _process_form() {
107			//let the form build the FormElement objects
108			//that will be used by the form
109			$this->_form_content->form_init_elements();
110
111			//first we need to
112			if (!$_POST[FORM_VISITED]) {
113			$this->_form_content->form_init_data();
114			}
115
116
117			//we only need to process the form
118			//if it has been visited. Otherwise
119			//it just gets rendered.
120			if ($_POST[FORM_VISITED] == 1) {
121			$this->_form_content->set_action($_POST[FORM_ACTION]);
122
123			//let see if this was a confirmation page.
124			if ( $_POST[FORM_CONFIRM] == 1 ) {
125			//looks like this was a submit on a
126			//confirmation page. we don't need
127			//to do form field validation.
128			$this->_confirmed = TRUE;
129			}
130
131			//now do the validation
132			if (!$this->_confirmed) {
133			//we haven't been confirmed, so we
134			//need to validate the form.
135			if ($this->can_validate()) {
136			//looks like we should do validation
137			$this->do_validation();
138			}
139			if (!$this->_has_errors) {
140			//no errors were found
141			if ($this->_form_content->has_confirm()) {
142			//the form content has a confirmation
143			//we need to process
144			$this->_has_errors = !$this->_pre_confirm();
145			} else {
146			//make sure we don't have any backend errors
147			$this->_has_errors = !$this->_form_content->form_backend_validation();
148			if (!$this->_has_errors) {
149			$this->_has_errors = !$this->_process_action();
150			}
151			}
152			}
153			} else {
154			//make sure we don't have any backend errors
155			$this->_has_errors = !$this->_form_content->form_backend_validation();
156			if (!$this->_has_errors) {
157			$this->_has_errors = !$this->_process_action();
158			}
159			}
160			}
161			}
162
163
164			/**
165			* This function is responsible for
166			* processing the form action
167			* after validation, and form confirmation
168			* happens.
169			*
170			*/
171			function _process_action() {
172			//There were no validation errors.
173			return $this->_form_content->form_action();
174			}
175
176			/**
177			* This method calls the FormContent
178			* to let it do any data munging before the
179			* confirmation page is rendered
180			*/
181			function _pre_confirm() {
182			return $this->_form_content->pre_confirm();
183			}
184
185
186			/**
187			* This method walks the FormContent's visible elements
188			* and calls the validation function for the element
189			*
190			*/
191			function do_validation() {
192			$keys = array_keys( $this->_form_content->_elements );
193			foreach( $keys as $key ) {
194			$valid = $this->_form_content->_elements[$key]->_do_validation();
195			if (!$valid) {
196			$this->_has_errors = TRUE;
197			}
198			}
199			}
200
201
202			/**
203			* This method is called to render the form's html
204			*
205			*/
206			function render($indent_level=0, $output_debug=0) {
207	jonen	1.2	//now process the form
208			$this->_process_form();
209
210	jonen	1.1	if ($this->_has_errors) {
211			//we need to render the form errors
212			//and then the form
213			return $this->render_error($indent_level, $output_debug);
214			} else {
215			//there are no errors!
216			if ($_POST[FORM_VISITED] == 1) {
217			//looks like the form has been processed?
218			if ($this->_form_content->has_confirm() && !$this->_confirmed) {
219			return $this->render_confirm($indent_level, $output_debug);
220			} else {
221			//Looks like the action worked
222			$success = $this->_form_content->form_success($this->_message);
223
224			if ($this->_form_success_render) {
225			return $this->render_form($indent_level, $output_debug,
226			$success);
227			} else {
228			if (method_exists($success,"render")) {
229			//looks like this is an object.
230			//we'll assume it has a render function.
231			return $success->render($indent_level, $output_debug);
232			} else {
233			//since its not an object,
234			//lets just display it.
235			return $success;
236			}
237			}
238			}
239			} else {
240			return $this->render_form($indent_level, $output_debug);
241			}
242			}
243			}
244
245
246			/**
247			* This renders the form
248			*
249			* @param the FormContent->form() object
250			* @param int - $indent_level
251			* @param int - $output_debug
252			* @param object - the form errors object.
253			* @return raw html
254			*/
255			function render_form( $indent_level, $output_debug, $obj=NULL ) {
256
257			//build the $this->_form object.
258			$this->_build_form_tag();
259
260			if ($obj) {
261			$this->_form->add_reference( $obj );
262			}
263
264			$this->_form->add_reference( $this->_form_content->form() );
265
266			//add the FormContent's hidden declared
267			//hidden form fields.
268			$this->_add_hidden_fields();
269
270			//Ok lets add our hidden vars
271			$this->__hidden_fields();
272
273			return $this->_form->render($indent_level, $output_debug);
274			}
275
276			/**
277			* This function renders the confirmation
278			* page. This page sits in between the
279			* front end form, and the action handler.
280			* This only gets called after a form
281			* and its data has been successfully
282			* validated.
283			*
284			* @param int - $indent_level
285			* @param int - $output_debug
286			*
287			* @return string - the raw html
288			*/
289			function render_confirm( $indent_level, $output_debug ) {
290			//build the $this->_form object.
291			$this->_build_form_tag();
292
293			//add the confirm object/html
294			$confirm = &$this->_form_content->form_confirm( $this->data );
295			$this->_form->add_reference( $confirm );
296
297			//ok add all of the submitted data as hidden form fields
298			$this->_add_confirm_data();
299
300			//Ok lets add our hidden vars
301			$this->__hidden_fields();
302
303			return $this->_form->render($indent_level, $output_debug);
304			}
305
306
307			/**
308			* This renders the error table
309			* and then the form with the fields
310			*
311			* @param array - the form field vlues.
312			* @param array - array of errors.
313			* @param int - $indent_level
314			* @param int - $output_debug
315			*
316			* @return raw html
317			*/
318			function render_error( $indent_level, $output_debug) {
319			$wrapper_div = new DIVtag;
320
321			//Ok first lets build the error table
322			$errors = &$this->_form_content->form_errors();
323			if ($errors != NULL) $wrapper_div->add( $errors, html_br() );
324
325			return $this->render_form( $indent_level, $output_debug, $wrapper_div);
326			}
327
328
329
330
331			//***********************************************//
332			//* utility functions for this class *//
333			//***********************************************//
334
335
336			/**
337			* This method lets us turn on/off the
338			* ability to do validation for the form
339			*
340			* @return BOOLEAN
341			*/
342			function can_validate() {
343			return TRUE;
344			}
345
346
347			/**
348			* This function turns on the ability to
349			* render the form after the success
350			* of the action. Normally this feature
351			* is off
352			*
353			*/
354			function set_render_form_after_success() {
355			$this->_form_success_render = TRUE;
356			}
357
358
359			/**
360			* this function builds the FORMtag object
361			* and its attributes.
362			*
363			* @return FORMtag object.
364			*/
365			function _build_form_tag() {
366			$form_attrs = array("method" => "POST",
367			"action" => $this->_form_action,
368			"name" => $this->_form_name,
369			"style" => "margin: 0px 0px 0px 0px;");
370			if ($this->_enctype != NULL)
371			$form_attrs["enctype"] = $this->_enctype;
372			if ($this->_target != NULL)
373			$form_attrs["target"] = $this->_target;
374			if ($this->_onsubmit != NULL)
375			$form_attrs["onSubmit"] = $this->_onsubmit;
376
377			$this->_form = new FORMtag( $form_attrs );
378			}
379
380			/**
381			* This adds all of the submitted data as
382			* hidden form fields
383			*
384			*/
385			function _add_confirm_data() {
386			$keys = array_keys( $this->_form_content->_elements );
387			foreach( $keys as $key ) {
388			$element_name = $this->_form_content->_elements[$key]->get_element_name();
389			$values = $this->_form_content->_elements[$key]->get_value();
390			if (is_array($values)) {
391			foreach($values as $value) {
392			$this->_form->add( form_hidden($element_name, $value) );
393			}
394			} else {
395			$this->_form->add( form_hidden($element_name, $values) );
396
397			}
398			}
399
400			$keys = array_keys( $this->_form_content->_hidden_elements );
401			foreach( $keys as $key ) {
402			$this->_form->add( $this->_form_content->_hidden_elements[$key]->get_element() );
403			}
404			}
405
406
407			/**
408			* This function adds the form content's
409			* hidden form fields to the
410			* form automatically
411			*
412			*/
413			function _add_hidden_fields() {
414			//Lets add the form's hidden vars it wants
415			foreach ($this->_form_content->_hidden_elements as $element) {
416			$this->_form->add( $element->get_element() );
417			}
418			}
419
420
421			/**
422			* This method adds the processor specific
423			* hidden fields.
424			*
425			*/
426			function __hidden_fields() {
427			$this->_form->add( form_hidden(FORM_ACTION),
428			form_hidden(FORM_VISITED,1) );
429
430			if ($this->_form_content->has_confirm() && !$this->_confirmed) {
431			if (!$_POST[FORM_VISITED] \|\| $this->_has_errors) {
432			$this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
433			} else {
434			$this->_form->add( form_hidden(FORM_CONFIRM, 1 ) );
435			}
436			} else if ($this->_form_content->has_confirm() && !$this->_confirmed) {
437			//reset this so they can submit again
438			$this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
439			}
440			}
441			}
442			?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26