XForms/XFormsRenderModule.php5

<?php
/* ------------------------------------------------------------------ */
/* XFormsRenderModule 1.1 */
/* jwsm@shodor.org | 9-23-06
/* updated by jwsm@shodor.org | 5-17-07
/*
/* The XForms Render Module is the main (pseudo-controller) object of
/* Shodorx Forms system. It is this module that provides the main API
/* for the program. Although this class can be further wrapped into
/* an XFormsPageRenderModule, where the form will appear on a Shodor
/* page, all the functionality of the system comes directly from this
/* class.
/*
/* ------------------------------------------------------------------ */

class XFormsRenderModule extends SObject{

    // source XML
    protected $xml;

    // form presets (set by script, not XML)
    protected $presets;

    // booleans
    protected $booleans;
    protected $options;

    // modules to help build/process the form
    protected $ib;
    protected $ip;

    // output buffers from the form processor
    protected $model;
    protected $xformsError;
    protected $itemCount;

    // finite state machine states
    protected $state;
    protected $READY_TO_LOAD_XML = 0;
    protected $XML_LOADED_SUCCESSFULLY = 5;

    public function __construct () {}

    public function loadXML($xml)
    {
        $xml = utf8_encode($xml);
        $this->xml = @simplexml_load_string($xml);
        if ($this->xml === false){
            $this->setPrettyError('loadXML', 'Your XForms XML does not parse');
            return false;
        }
        $this->init();
        $this->countItems();

    }

    public function init() {
        # create new manager classes
        $this->ib = new XFormsInterfaceBuilder($this);
        $this->ip = new XFormsInputProcessor($this);

        # check the created classes' validity
        if (!is_object($this->ib)){
            $this->setPrettyError('init', 'Instantiation of XFormsInterfaceBuilder failed');
            return false;
        }
        if (!is_object($this->ip)){
            $this->setPrettyError('init', 'Instantiation of XFormsInputProcessor failed');
            return false;
        }

        # clear all the class variables
        $this->booleans = array();

        $this->booleans['validated'] = false;
        $this->booleans['submitted'] = false;

        $this->options = array();
        $this->options['pictcha'] = true;
        $this->options['token'] = true;

        $this->model = "";
        $this->modelObj = null;
        $this->xformsError = array();
        $this->itemCount = array();

        $this->presets = array();
    }

    /*------------------------------------------------------------------- */
    /* Get and set options as to how the form should work */
    /*------------------------------------------------------------------- */

    public function getOption ($key) {
        if (!isset($this->options[$key])) return "";
        return $this->options[$key];}

    public function setOption ($key, $value) {
        $this->options[$key] = $value;
        if ($key == 'pictcha') {
            SConfig::setOption('xforms.pictcha', $value);
        }
    }

    /*------------------------------------------------------------------- */
    /* Preset values for the form (that are not included in the XML file) */
    /*------------------------------------------------------------------- */
    public function setPreset($tag, $value) {
        if (!isset($this->presets["$tag"])){ $this->presets["$tag"] = array();}
        if (is_array($value)){
            $this->presets["$tag"] = array_merge($this->presets["$tag"], $value);
        } else {
            array_push($this->presets["$tag"], $value);
        }
    }

    public function getPreset($tag) {
        if (!isset($this->presets["$tag"])){ return false; }
        return $this->presets["$tag"];
    }

    /*------------------------------------------------------------------- */
    /* Process the user input to the form                               */
    /*------------------------------------------------------------------- */
    public function processInput () {
        # if there is no form, return false immediately
        if ($this->xml == null){
            $this->booleans['submitted'] = false;
            return false;
        }

        //TODO: make the different submit buttons ID'd by the XForm's (so that there can be multiple per page)
        # if the form has been submitted
        if ( isset($_POST['submit']) ) {
            // remember that we've "submitted" in a boolean
            $this->booleans['submitted'] = true;
            // process the input and store the results of validation
            $this->ip->processInput($this->xml);
            // remember whether there were any errors in a boolean
            $this->validate();
        } else{
            $this->booleans['submitted'] = false;
        }
    }

    public function validate() {
        $this->booleans['validated'] = !($this->getErrorCount());
    }

    /*------------------------------------------------------------------- */
    /* Access the model / Submitted Values                                */
    /*------------------------------------------------------------------- */

    /* set the buffered model XML (i.e., an XML version of what's been submitted) */
    public function setModel ( $model ) {
        $this->model = $model;
        $this->modelObj = @simplexml_load_string($model);
        if (!$this->modelObj) {
            $this->setPrettyWarning('setModel', 'unable to parse model into a simplexml object.');
        }
    }

    /* get the buffered model XML (i.e., an XML version of what's been submitted) */
    public function getInstanceXML ()
    {   return $this->model; }

    /* get an individual submitted post value (for use in validating before
        the entire model has been successfully generated) */
    public function getSubmittedValue ($tag)
    {
        $index = $this->ib->getNamePrefix() . $tag;
        if(isset($_POST[$index])) return $_POST[$index];
        return "";
    }

    public function getInstanceValue($path) {
        if (!$this->modelObj) {
            $this->setPrettyWarning('getInstanceValue', 'Could not search for value at path ' . $path
                                        . '; XML does not parse.');
            return null;
        }
        $search = $this->modelObj->xpath($path);
        if (count($search) == 0){
            $this->setPrettyWarning('getInstanceValue', 'No node found for path ' . $path);
            return null;
        }
        if (count($search) == 1){
            return XFormsFunctions::contentFromParsedXML($search[0]);
        }
        else {
            $output = array();
            foreach ($search as $searchVal) {
                $output[] = XFormsFunctions::contentFromParsedXML((string)$searchVal);
            }
            return $output;
        }
    }

    /*------------------------------------------------------------------- */
    /* Error Handling                                                     */
    /* This class collects all the error codes thrown by the Form Interface
    /* Processor and other classes (possibly including the controller)
    /* during form processing. Then, in order to decide whether to move
    /* on to a successful submission, or whether to generate error messages
    /* on the page, we ask, "error count == 0?".
    /*------------------------------------------------------------------- */

    /* set an error code, i.e., "throw an error" -- for use during processing */
    public function setErrorCode($index, $code)
    {
        if (!isset($this->xformsError["$index"]))
        {   $this->xformsError["$index"] = array(); }
        array_push($this->xformsError["$index"], $code);
    }


    public function getErrorCode ($index) {
        if (isset($this->xformsError["$index"]))
        {   return $this->xformsError["$index"][0]; }
    }


    public function getErrorCount() {
        return count($this->xformsError);
    }


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

    /*------------------------------------------------------------------- */
    /* Checking Completion                                                */
    /*------------------------------------------------------------------- */

    public function isComplete () {
        if (!isset($this->booleans['submitted']) || ($this->booleans['submitted'] == false)) {
            # if it's not set at all, don't have a warning, just get the heck out.
            if (!isset($this->booleans['submitted'])) {
                $this->setPrettyWarning('isComplete', 'Attempted to call isComplete() before calling processInput()');
            }
            return false;
        }

        $this->validate();

        return (
            $this->booleans['submitted'] &&
            $this->booleans['validated']
        );
    }

    public function isSubmitted () {
        return $this->booleans['submitted'];
    }

    public function toHtml () {
        $this->validate();
        if ($this->isComplete()) {
            return "Form Was Submitted";
        } else {
            return $this->formatXFormsRoot($this->xml);
        }
    }

    protected function formatXFormsRoot ( $xforms )
    {
        $htmlOutput = "";
        if ($xforms === false) {
            return false;
        }

        if (!is_object($this->ib)){
            $this->setPrettyError('formatXFormsRoot', 'XFormsInterfaceBuilder is not an object.');
            return false;
        }

        $htmlOutput .= $this->ib->formatXFormsInterface($xforms);
        if ($this->ib->hasError()) {
            $this->setError('formatXFormsRoot', 'Interface Builder had an error');
            $this->getErrorFrom($this->ib);
            return false;
        }
        return $htmlOutput;
    }


    // Helper methods

    /*------------------------------------------------------------------- */
    /* Item Count Methods                                                 */
    /*------------------------------------------------------------------- */
    public function getItemCount ($tag)
    {
        return (isset($this->itemCount["$tag"])) ? $this->itemCount["$tag"] : 0;
    }

    protected function updateItemCount ($tag, $child) {
        $nodeCounter = 0;
        foreach($child->item as $node){
            $nodeCounter++;
        }
        $this->itemCount["$tag"] = $nodeCounter;
    }

    protected function countItems () {
        foreach($this->xml->children() as $tag => $child) {
            if ( isset($child['ref']) ) {
                $ref = $child['ref'];

                //print("counting $ref <br />");
                switch($tag) {
                    // if the item is a select displaying not as minimal -- i.e., if it is
                    // checkboxes, compute a count
                    case 'select':
                        if (isset($child['appearance']) && 'minimal' == $child['appearance'])
                            $this->itemCount["$ref"] = 1;
                        else
                            $this->updateItemCount($ref, $child);
                        break;
                    // otherwise, set the count to 1 (all other items have just one form control)
                    default:
                        $this->itemCount["$ref"] = 1;
                        break;
                }
            }
        }
    }
}
?>

---