XForms/XFormsInputProcessor.php5

<?php
class XFormsInputProcessor extends SObject {

    protected $parent;
    protected $namePrefix = "shodor_xforms_";
    protected $validator;
    protected $selectCount;

    public function __construct ($parent) {
        $this->parent = $parent;
        $this->validator = new StandardValidator();
    }

/* ------------------------------------------------------------------ */
/* INPUT PROCESSING METHODS */
/* ------------------------------------------------------------------ */
/*  Traverse the XML tree of the XForms document and align it
/*  with the POST variables */

    public function processInput ( $xform ) {
        $this->selectCount = array();
        if (SConfig::getOption('xforms.pictcha') === true) {
            // check to see if the pictcha was completed properly. If not, throw an error
            $p = new Pictcha();
            if (!($p->getValidPictcha($_POST['series_a'], $_POST['pictcha_a'],
                        $_POST['series_b'], $_POST['pictcha_b']))) {
                $this->parent->setErrorCode("pictcha", 114);
            }
        }

        if ($this->parent->getOption('token')) {
            // check to see if the token was sent. If not, throw an error
            if (!isset($_POST['xformtoken'])
                    || $_POST['xformtoken'] != sha1(session_id() . 'hasdfhv894h3gpvub')) {
                $this->parent->setErrorCode("token", 135);
            }
        }

        // check to see if the fields were filled in properly -- and update the model
        $traversedXML = $this->traverseXml($xform->model->instance);
        $this->parent->setModel("<xforms> <model><instance>" . $traversedXML
                                . "</instance></model> </xforms>");

        // return whether or not there were errors in the process
        return (count($this->parent->getErrorCount()) == 0);
    }

    protected function traverseXml ($model) {
        $returnString = "";
        $tagsDone = array();

        foreach($model->children() as $tag=>$child) {
            if (!in_array($tag, $tagsDone)) {
                array_push($tagsDone, $tag);

                // validate any input at this level
                $index = $this->namePrefix . $tag;
                $tagItemCount = $this->parent->getItemCount($tag);

                // is the element required by the model?
                $required = $this->isRequired($child);

                // if it's a standard tag, with a count of 1
                if ($tagItemCount == 1) {
                    if (isset($_POST[$index]) && !isset($_FILES[$index])) {
                        $returnString .= $this->createDefaultXML($child, $index, $tag);
                    } elseif(isset($_FILES[$index])) {
                        $returnString .= $this->createFileXML($child, $index, $tag);
                    } 
                    // In case this is a one-item checkbox group
                    elseif(isset($_POST[$index . "_0"])) {
                        $returnString .= "<$tag>";
                        $returnString .= $this->checkSetInput($child, $index . "_0", $tag);
                        $returnString .= "</$tag>";
                    }
                    else {
                        // if this is a required field, throw an error (90)
                        if ($required)
                        {   $this->parent->setErrorCode($tag, 90);  }
                    }

                // if it's a multiple select, with an item count > 1
                } else {
                    if ($tagItemCount > 1) {
                        $anyItemSet = false;
                        for ( $i = 0; $i < $tagItemCount; $i++ ) {
                            $numberedIndex = $index . "_" . $i;
                            if (isset($_POST[$numberedIndex])) {
                                $returnString .= "<$tag>";
                                $returnString .= $this->checkSetInput($child, $numberedIndex, $tag);
                                $returnString .= "</$tag>";
                                $anyItemSet = true;
                            }
                        }
                        // if this is a required field, throw an error (90)
                        if ($required && !$anyItemSet){
                            $this->parent->setErrorCode($tag, 90);
                        }
                        // if no item is set, send back an empty stub element
                        if (!$anyItemSet){
                            $returnString .= "<$tag />";
                        }
                    }
                }

                // continute if it has children
                if (count($child->children()) > 0) {
                    $temp = $this->traverseXml($child);
                    if ($temp != "") { $returnString .= "<$tag>" . $temp . "</$tag>"; }
                }
            }
        }
        return $returnString;
    }

    protected function checkSetInput ($child, $index, $tag) {
        /* ------------------------------------------------------ */
        /* prepare the necessary vars
        /* ------------------------------------------------------ */

        # get the expected type of the node
        $type = $this->resolveType($child);

        # is the element required by the model?
        $required = $this->isRequired($child);

        $errorCode = 0;
        $input = "";

        /* ------------------------------------------------------ */
        /* Check for expected input, validate, set errors
        /* ------------------------------------------------------ */

        # set error codes based on whether the field is filled in /
        # filled in wrong / required, etc.

        /* ------------------------------------------------------ */
        /* check FILES array for input (for given ref)
        /* ------------------------------------------------------ */

        # We first check to see if there is a file upload
        # if a file is expected and the files array for that ref is set
        if(isset($_FILES[$index])) {
            # get the temp name of the file and the mime type
            $input = $_FILES[$index]['tmp_name'];
            $mime = $_FILES[$index]['type'];
            if ($mime == '') {
                $mime = 'text/plain';
            }
            # validate the file input
            $errorCode = $this->validateFile($input, $type, $mime);
        }

        /* ------------------------------------------------------ */
        /* check POST array for input (for given ref)
        /* ------------------------------------------------------ */

        # Next we check to see if the POST array has an index for our ref
        # if it does have the index set, we process the input
        else if (isset($_POST[$index]) && $_POST[$index] != "") {

            # relay the post index into the var $input
            $input = $_POST[$index];

            # if the type is not XMl, clean the entites out
            if ($type != "xml" && $type != "mixedxml"){
                $input = XFormsFunctions::contentToXML($input);
            }

            # the textlist type treats values on newlines as separate value instances (like a
            # multiple select). We want to create an XML tag to wrap each individual value from each
            # line.
            if ($type == 'textlist') {
                $input = trim($input);
                $input = str_replace('
', '\n', $input);
                # Split the lines into an array
                $lines = explode('\n', $input);
                $linesOut = array();
                # Trim each line, and if it's not blank, add it to the output lines
                foreach($lines as $l) {
                    $l = trim($l);
                    if ($l != '')
                        $linesOut []= $l;
                }
                # Implode the output lines to make new tags for each line
                # (fit inside the enclosing outside lines)
                $input = implode("</$tag><$tag>", $linesOut);
            }

            # set an error code if the validateInput function
            # returns an error for our input given its type
            $errorCode = $this->validateInput($input, $type);

        # if the POST array does not have our index set, and if that
        # index (ref) is required in the XForm, then throw the
        # "required input" error code 90
        } else {
            $errorCode = ($required) ? 90 : 0;
        }

        /* ------------------------------------------------------ */
        /* Return content or set error code
        /* ------------------------------------------------------ */

        # evaluate the error codes - if there is no error,
        # return the input content to be placed in the XML model
        if ($errorCode == 0) {
            # no error - return the input
            return $input;

        # if there IS and error, don't return the content,
        # and set an error code on the node.
        } else {
            # error - set error code
            $this->parent->setErrorCode($tag, $errorCode);
        }
    }

    protected function getGlobArray($index) {
        if(isset($_POST[$index])) {
            $globArray = 'post';
        } elseif(isset($_FILES[$index])) {
                $globArray = 'files';
            } else {
                return false;
            }
        return $globArray;
        }

    protected function createDefaultXML($child, $index, $tag) {
        $returnString = "<$tag>";
        $returnString .= $this->checkSetInput($child, $index, $tag);
        $returnString .= "</$tag>";
        return $returnString;
    }

    protected function createFileXML($child, $index, $tag) {
        $mediaType = $_FILES[$index]['type'];
        $name = $this->fixExtension($_FILES[$index]['name'], $mediaType);
        $size = $_FILES[$index]['size'];
        $returnString = <<<END_OUTPUT
<$tag filename="$name" mediatype="$mediaType" size="$size">
END_OUTPUT;
        $returnString .= $this->checkSetInput($child, $index, $tag);
        $returnString .= "</$tag>";
        return $returnString;
    }

    protected function resolveType ( $child ) {
        return (isset($child['type'])) ? $child['type'] : "";
    }

    protected function validateInput ( $input, $type ) {
        return $this->validator->validateInput($input, $type);
    }

    protected function validateFile ($input, $type, $mime) {
        return $this->validator->validateFile($input, $type, $mime);
    }

    protected function fixExtension($input, $mime) {
        return $this->validator->fixExtension($input, $mime);
    }

    public function isRequired ($child) {
        return (isset($child['required']) && ($child['required'] == "true()"));
    }
}
?>

---