SWAT/questionnaire/SQuestionnaire.php5

<?php

class SQuestionnaire extends SObject
{
    # Data
    # --------------------------------------------------

    protected $surveyId;
    protected $questions;
    protected $responses;
    protected $refOrder;

    protected $options;
    protected $DBI;

    # temporary solution: figure out which items have been updated
    # by storing flags in array
    protected $responseUpdateFlags;

    # Functions
    # --------------------------------------------------

    public function __construct($id = "") {
        global $DBI;
        parent::__construct($id);

        if (isset($DBI)) { $this->setDBI($DBI); }

        $this->setOption('surveyClass', 'SSurvey');
        $this->setOption('questionClass', 'SQuestion');
        $this->setOption('responseClass', 'SResponse');

        if ($id != "") {
            $this->populate($id);
        }
    }

    public function setDBI($DBI) {
        $this->DBI = &$DBI;
    }

    public function getDBI() {
        return $this->DBI;
    }

    public function setOption($key, $value) {
        $this->options[$key] = $value;
    }

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

    # Populate the questionnaire with questions. If there is a review id set,
    # also populate it with the responses for that review.

    public function populate($surveyId = "") {
        $rClass = $this->getOption('responseClass');
        $qClass = $this->getOption('questionClass');
        $sClass = $this->getOption('surveyClass');

        # If a survey is specified, check to see if the requested survey
        # object exists by trying to populate it. If not, throw an error.
        if ($surveyId != ""){
            $s = new $sClass($surveyId);
            if ($s->hasError()) {
                $this->setPrettyError('populate', 'Specified survey object with id ' . $surveyId
                                        . ' could not be populated.');
                $this->getErrorFrom($s);
                return false;
            }
            $this->setSurveyId($surveyId);
        }

        # Populate a list of all available questions
        $qProvider = new $qClass();
        $qList = $qProvider->getList(array('active' => 1, 'order' => 'qOrder'));
        if ($qProvider->hasError()) {
            $this->setPrettyError('populate', 'Could not populate a list of questions.');
            $this->getErrorFrom($qProvider);
            return false;
        }

        # prepare to update our collection of questions and responses--
        # clear the arrays
        $this->questions = array();
        $this->responses = array();
        $this->refOrder = array();

        # loop through the results and add an object to the questionnaire for each
        foreach ($qList as $q) {
            $this->addQuestion($q);
        }

        # If there is a survey set, load in the responses as well
        if ($surveyId != "") {

            # assemble the components we'll need for the left join
            $q = new $qClass();
            $r = new $rClass();
            $qId = $q->getUniqueAttributes();
            $rId = $r->getUniqueAttributes();
            $rEntity = $r->getEntity();
            $qEntity = $q->getEntity();
            $sId = $s->getUniqueAttributes();

            # build the query - left join response onto question (get the question Id
            #   for each response), limit by responses only related to this survey.
            $query = "SELECT $rEntity.$rId[0] AS responseId, $qEntity.ref as qRef FROM"
                        . " $rEntity LEFT JOIN $qEntity ON $rEntity.questionId = $qEntity.$qId[0]"
                        . " WHERE $sId[0] = '$surveyId' AND $qEntity.active = '1'";
            print($query);
            # run the query
            $result = $this->queryOrSetError($query);
            if ($result === false) return false;

            # loop through the results and add them to the questionnaire object
            for ($i = 0; $i < count($result); $i++) {
                $ref = $result[$i]["qRef"];
                $rid = $result[$i]["responseId"];

                if ($ref == "") {
                    $this->setPrettyError('populate', 'Encountered a blank ref value while '
                        . ' reading responses. Ref value was for response id ' . $rid);
                    return false;
                }

                $r = new $rClass($rid);
                if(!$this->addResponseForRef($ref, $r)){
                    return false;
                }
            }
        }
        return true;
    }

    public function addQuestion($question) {
        # store it in the array, and create the corresponding
        # responses array. There should never be two questions with
        # the same ref, so we can hash them by ref.
        #
        # store the ordering of the refs in a separate array
        # since we've ordered the query by order, we can just push the
        # ref values on here.

        if (!$question->isValidQuestion())
        {
            $this->setError("Attempt to addQuestion() failed: question is not valid");
            return false;
        }
        $ref = $question->getRef();
        if (isset($this->questions[$ref]))
        {
            $this->setWarning("addQuestion() is replacing a question that already exists for ref $ref");
            return false;
        }
        $this->questions[$ref] = $question;
        $this->responses[$ref] = array();

        array_push($this->refOrder, $ref);
    }

    public function getQuestionByRef($ref) {
        if (!isset($this->questions[$ref])) {
            $this->setError("Attempt to getQuestionByRef() failed: the ref '$ref' does not exist.");
            return false;
        }
        return $this->questions[$ref];
    }

    public function addResponseForRef($ref, $response) {
        if (!isset($this->responses[$ref])) {
            $this->setError("Attempt to setResponse() failed: the array of responses for ref '$ref' does not exist.");
            return false;
        }
        array_push($this->responses[$ref], $response);
        if(isset($this->responseUpdateFlags[$ref])){
            array_push($this->responseUpdateFlags[$ref], 1);
        }
        return true;
    }

    public function getResponsesForRef($ref) {
        if (!isset($this->responses[$ref])) {
            $this->setError("Attempt to getResponsesForRef() failed: the array of responses for ref '$ref' does not exist.");
            return false;
        }
        return $this->responses[$ref];
    }

    public function getResponseByRefAndId($ref, $responseId) {
        if (!isset($this->responses[$ref])) {
            $this->setError("Attempt to getResponseByRefAndId() failed: the array of responses for ref '$ref' does not exist.");
            return false;
        }
        foreach($this->responses[$ref] as $response) {
            if ($response->getResponseId() == $responseId) {
                return $response;
            }
        }
        $this->setError("Attempt to getResponseByRefAndId() failed: a response with that Id was not found in responses for ref '$ref'.");
        return false;
    }

    /* commit()
        write values from object back to database
        if reviewId is blank, commit all questions to database ( not attached to review)
        else commit only the responses (is attached to review).
     */
    public function commit() {
        if (count($this->getError()) != 0) {
            $this->setError("Attempt to call commit() Questionnaire failed: "
                            . "error count for object is not zero");
            return false;
        }

        if ($this->surveyId == "") {
            # commit only the questions back to the database
            $questions = $this->getQuestions();
            foreach($questions as $ref => $question) {
                $question->commit();
            }
        } else {
            # commit only the responses back to the database
            $responses = $this->getResponses();
            foreach($responses as $respRef) {
                foreach($respRef as $response) {
                    $response->commit();
                }
            }
        }
        return true;
    }

    /*---------------------------------------------*/
    /* XML Input/Output Methods
    /*---------------------------------------------*/

    /* getXFormsModel()
        return an XML string (in XForms model format) of all the values for the
        questions in this questionnaire. Every active question will appear in this
        string as a tag, whether or not it has a value.
     */
    public function getXFormsModel()
    {
        if (count($this->getError()) != 0)
        {
            $this->setError("Attempt to call getXFormsModel on Questionnaire failed: "
                        . "error count for object is not zero");
            return false;
        }

        $ret = " <model>\n <instance>\n ";
        $order = $this->getRefOrder();
        $questions = $this->getQuestions();

        /* loop through the ordering array to get each ref*/
        foreach($order as $ref)
        {
            /* look up the question based on the ref */
            $question = $questions[$ref];

            /* if there are any responses for this question in the object,
                create tags surrounding all the values. */

            /* get all responses for the ref */
            $responses = $this->getResponsesForRef($ref);

            /* if the result is false, we have data inconsistency-- an error */
            if ($responses === false) {
                $this->setError("Attempt to getXFormsModel() failed: "
                                . "call to getResponsesByRef() failed for ref $ref");
                return false;
            }

            /* count the number of responses returned. If there are any, loop through them */
            if (count($responses) > 0) {
                foreach($responses as $response) {
                /* foreach response, print a tag */
                    $ret .= $question->getXFormsOpenTag($response->getResponseId())
                            . $response->getResponse() . $question->getXFormsCloseTag() . "\n";
                }
            } else {
                /* if there are no responses for the question, simply return
                    the question as an all-in-one tag */
                $ret .= $question->getXFormsOpenCloseTag() . "\n";
            }
        }
        $ret .= " </instance>\n </model>\n";
        return $ret;
    }

    /* setXFormsModel(xml)
        use "xml" (in XForms model format, coming out of a posted XForm)
        to load all the values for the questions in the questionnaire.
        This should only contain the "positive" changes that are posted back
        by the form (i.e., the refs that are in the presentation XML). Only
        these changes will be made to the populated object, which can then be
        committed back to the database.

        This method can only be run on a questionnaire that has a reviewId, since
        we need to check whether the responses match the reviewId.
     */
    public function setXFormsModel($xml) {

        //print("the model XML:" . $xml);

        /* make sure that the reviewId is valid */
        if ($this->getSurveyId() == "" || !ctype_digit((string) $this->getSurveyId())) {
            $this->setError("Attempt to call setXFormsModel() failed: "
                        . "questionnaire object must have a reviewId");
            return false;
        }

        /* make sure we can parse the XML object */
        $x = $this->parseXML($xml);
        if ($x === false) {
            $this->setError("Attempt to setXFormsModel() failed: could not parse input XML.");
            print_r($this->getError());
            return false;
        }

        /* make sure there's an instance node set on the XML tree */
        if (!isset($x->instance)){
            $this->setError("Attempt to setXFormsModel() failed: input XML lacks instance node.");
            return false;
        }
        $instance = $x->instance;

        /* clear out the update flags -- we are getting ready to update */
        $this->responseUpdateFlags = array();

        /* ------------------------------- */
        /* Starting to update */

        foreach($instance->children() as $ref => $value) {

            /* get the current set of response objects for the current ref */
            $responsesForRef = $this->getResponsesForRef($ref);
            if ($responsesForRef === false) {
                $this->setError("Attempt to setXFormsModel() failed: unable to"
                    . " get responses array for ref $ref in Questionnaire.");
                return false;
            }

            /* if we've not been to this ref before, but now we're starting,
                make a new responseUpdateFlag set for this ref. Also, clear
                out all the VALUES from the response objects for this ref.
                (just the values, not the objects). */
            if (!isset($this->responseUpdateFlags[$ref])) {
                $this->responseUpdateFlags[$ref] = array();
                foreach($responsesForRef as $aResponse){
                    $aResponse->setResponse("");
                }
            }

            /* count the number of responses already updated for this ref */
            $numFilledForRef = count($this->responseUpdateFlags[$ref]);

            /* count the number of existing response OBJECTS for this ref */
            $numRespObjsForRef = count($responsesForRef);

            /* if the number filled is less than the number of objects,
                update the next object */
            if ($numFilledForRef < $numRespObjsForRef) {
                $aResponse = $responsesForRef[$numFilledForRef];
                $aResponse->setResponse($value);
                array_push($this->responseUpdateFlags[$ref], true);

            } else {
            /* otherwise, add a new object */
                $q = $this->getQuestionByRef($ref);
                if ($q === false) {
                    $this->setError("Attempt to setXFormsModel() failed: unable"
                        . " to getQuestionByRef $ref in Questionnaire.");
                    return false;
                }
                # creating a new response that's not already in database/memory
                # store in array of responses at [ref][dbid]
                $rClass = $this->getOption('responseClass');
                $r = new $rClass();
                $r->setSurveyId($this->getSurveyId());
                $r->setQuestionId($q->getQuestionId());
                $r->setResponse($value);

                # this is not gonna work because it does not yet have an ID.
                $this->addResponseForRef($ref, $r);
            }
        }
        return true;
    }

    /*---------------------------------------------*/
    /* Accessor Get/Set Methods */
    /*---------------------------------------------*/

    protected function getQuestions() {
        return $this->questions;
    }

    protected function getRefOrder() {
        return $this->refOrder;
    }

    protected function getResponses() {
        return $this->responses;
    }

    public function getSurveyId() {
        return $this->surveyId;
    }

    protected function setSurveyId($surveyId) {
        $this->surveyId = $surveyId;
    }

    protected function queryOrSetError($query) {
        if (!isset($this->DBI)) {
            $this->setPrettyError('queryOrSetError',
                    'No DBI found on questionnaire object.');
            return false;
        }
        $result = $this->DBI->query($query);
        if  (count($this->DBI->getError()) != 0){
            $this->setError($this->DBI->getError());
            return false;
        }
        return $result;
    }
}

?>

---