models/CSERDmodel/CSERDquestionnaire.php5

<?php
class CSERDquestionnaire
{
    private $reviewId;
    private $questions;
    private $responses;
    private $refOrder;
    
    // temporary solution: figure out which items have been updated
    // by storing flags in array
    private $responseUpdateFlags;
    
    function __construct($reviewId = "") {
        //parent::__construct();
        $this->populate($reviewId);
    }
    
    /* Populate the questionnaire with questions. If there is a review id set, also populate it
        with the responses for that review */
    public function populate($reviewId = "") {
        $CSERD_DBI = CSERDModelBase::getDBI();

        /* if the reviewId is not blank, do the following checks */
        if ($reviewId != ""){
            
            /* check to see if the reviewId is numeric */
            if (!is_numeric($reviewId)){
                print("Attempt to call populate() with reviewId '$reviewId' failed: "
                                . "reviewId is non-numeric");
                return false;
            }

            /* check to see if the review exists (if there is a reviewId)
                if not, throw an error */
            
            /* select the review with the given reviewId */             
            $query = "SELECT review.reviewId FROM review "
                    . "WHERE reviewId = '" . $reviewId . "' LIMIT 1;";
            
            /* if there is an error, report and stop */
            //$result = $this->query($query);
            $result = $CSERD_DBI->query($query);
            if ($result === false) return false;
            
            /* check to make sure there is one result */
            if (count($result) != 1) {
                print("Attempt to populate Questionnaire for reviewId '$reviewId' failed:"
                                . " no such review in the database.");
                return false;
            }
        }
        
        /* ----------------------------------------- */     
        /* WHETHER OR NOT A REVIEW ID IS SET */
        /* clear the arrays */
        $this->questions = array();
        $this->responses = array();
        $this->refOrder = array();
        
        /* select all active questions */               
        $query = "SELECT question.questionId, question.ref FROM question "
                    . "WHERE active = '1' ORDER BY question.qOrder;";
        //$result = $this->queryOrSetError($query);
        $result = $CSERD_DBI->query($query);
        if ($result === false) return false;
                
        /* loop through the results and add an object for each one */
        foreach ($result as $row)
        {
            $ref = $row["ref"];
            $qid = $row["questionId"];
            
            // create the new question
            $question = new CSERDquestion(array('questionId' => (int)$qid));
            // throw an error if it could not be populated
            if ($question === false)
            {
                print("Created new question for questionId $qid");
                print("Error Creating Question Object for questionId $qid");
                return false;
            }
            $this->addQuestion($question);
        }
        
        /* ----------------------------------------- */
        /* IF A REVIEW ID IS SET
            we need to query for and load in the responses for the review */
        if ($reviewId != "" && is_numeric($reviewId)) {
            // should it check here to see if the review ID exists at all in the DB?
            $this->setReviewId($reviewId);
            
            /* select all responses for this review */
            $query = "SELECT response.responseId, question.ref FROM response "
                    . "LEFT JOIN question ON response.questionId = question.questionId "
                    . "WHERE reviewId='" . $reviewId . "' AND question.active='1';";
            //print($query);
            //$result = $this->query($query);
            $result = $CSERD_DBI->query($query);
            if ($result === false) return false;

            /* loop through responses and put them into the responses array by ref
                (based on question) */
                //print("there were " . count($result) . " results");
            foreach ($result as $row) {
                $ref = $row["ref"];
                $rid = $row["responseId"];
                //print("creating response object with responseId $rid");
                $r = new CSERDresponse(array('responseId' => $rid));
                if(!$this->addResponseForRef($ref, $r)){
                    //print("bombing out on review $ref, $rid");
                    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->ref;
        
        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])) {
            print("Attempt to addResponseForRef() 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])) {
            print("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])) {
            print("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;
            }
        }
        print("Attempt to getResponseByRefAndId() failed: a response with that Id was not found in responses for ref '$ref'.");
        return false;
    }
    
    public function getRating() {
        $responses = $this->getResponsesForRef('usability');
        if ((!$responses) || (!isset($responses[0]))) return '0';
        return $responses[0]->response;
    }
    

    /* 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) {
//          print("Attempt to call commit() Questionnaire failed: "
//                          . "error count for object is not zero");
//          return false;
//      }
        
        if ($this->reviewId == "") {
            // 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)
//      {
//          print("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) {
                print("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->responseId)
                            . SXMLHelper::contentToXML($response->response)
                            . $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->getReviewId() == "" || !is_numeric($this->getReviewId())) {
            $this->setError("Attempt to call setXFormsModel() failed: "
                        . "questionnaire object must have a reviewId");
            return false;
        }
        
        /* make sure we can parse the XML object */
        $x = SXMLHelper::parse($xml);
        if ($x === false) {
            $this->setError("Attempt to setXFormsModel() failed: could not parse input XML.");
            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);
            //print('found ref: ' . $ref . '<br />');
            if ($responsesForRef === false) {
                print("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])) {
                //print("resetting response update flags for $ref<br />");
                $this->responseUpdateFlags[$ref] = array();
                foreach($responsesForRef as $aResponse){
                    //print("resetting response number " . $aResponse->getResponseId() . " to be blank.<br />");
                    $aResponse->response = "";
                }
            }
            
            /* count the number of responses already updated for this ref */
            $numFilledForRef = count($this->responseUpdateFlags[$ref]);
            
            //print("the number filled for $ref is $numFilledForRef<br />");
            
            /* count the number of existing response OBJECTS for this ref */
            $numRespObjsForRef = count($responsesForRef);
            
            //print("number of responses for $ref is $numRespObjsForRef<br />");
                        
            /* if the number filled is less than the number of objects,
                update the next object */
            if ($numFilledForRef < $numRespObjsForRef) {
    
                $aResponse = $responsesForRef[$numFilledForRef];

                //print("updating response index $numFilledForRef number " . $aResponse->getResponseId() . " for $ref to be " . $value . "<br />");
                
                $aResponse->response = $value;
                array_push($this->responseUpdateFlags[$ref], true);
            
            } else {
            /* otherwise, add a new object */
                
                //print("creating a new response object for $ref, set to $value<br />");
            
                $q = $this->getQuestionByRef($ref);
                if ($q === false) {
                    print("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]
                $r = new CSERDresponse();
                $r->reviewId = $this->reviewId;
                $r->questionId = $q->questionId;
                $r->response = $value;
                //var_dump($r);
                // this is not gonna work because it does not yet have an ID.
                $this->addResponseForRef($ref, $r);
            }
            //print("<hr />");
        }
        //print("here are the new question objects");
        //print_r($this->questions);
        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 getReviewId() {
        return $this->reviewId;
    }

    protected function setReviewId($reviewId) {
        $this->reviewId = $reviewId;
    }


}
/*
//header("Content-type: text/xml");
$a = new Questionnaire(3);

$q = new Question();
$q->setRef('heyHey');
$q->setType('string');
$q->setActive(true);
$q->setRequired(false);
$a->addQuestion($q);

//$a->commit();
//$a->setReviewId(3);

$inputXML =<<<END_IN
    <model>
    <instance>
        <bing  type="thingie"></bing>
        <heyHey  type="wing">arr there</heyHey>
        <heyHey  type="wing"></heyHey>
    </instance>
    </model>
END_IN;

$a->setXFormsModel($inputXML);
$a->commit();

//$a->commit();

print($a->getXFormsModel());

print("<hr />");
print("Errors:");
print_r($a->getError());
print("<hr />");
print("Warnings:");
print_r($a->getWarning());
*/
/*$USER->setUserName("jwsm");
$USER->populate();
//print_r($USER);
print("your name is " . $USER->getName());
print("you are a " . $USER->getRole());

print_r($USER->getError());
$USER->resetUser();
print("-----------I just reset the user------------");

$USER->setUserName("mevans");
$USER->populate();
//print_r($USER);
print("your name is " . $USER->getName());
print("you are a " . $USER->getRole());

print_r($USER->getError());
*/

?>

---