form_question.inc

<?php
require_once SQ_INCLUDE_PATH.'/asset.inc';
require_once SQ_LIB_PATH.'/html_form/html_form.inc';


class Form_Question extends Asset
{

    var $_formid = 0;

    var $_questionid = 0;

    var $section_name = '';

    var $section_id  = 0;


    var $value = NULL;


    var $extra_data = Array();


    var $submission_errors = NULL;


    var $active_form = NULL;


    var $failed_rules = Array();


    function Form_Question($formid=0, $data=Array())
    {
        if (!$formid || empty($data)) {
            return;
        }
        $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($formid);

        if (is_null($form)) return;
        $this->_formid = $formid;
        $this->_questionid = $data['questionid'];

        // set the data paths
        $this->_loadDataPaths();

        $asset_attributes = $GLOBALS['SQ_SYSTEM']->am->getAssetTypeAttributes(get_class_lower($this), Array('name', 'type','default_val','attrid'));

        foreach ($asset_attributes as $attribute_name => $asset_attribute) {
            $this->vars[$attribute_name]['type'] = $asset_attribute['type'];
            $this->vars[$attribute_name]['attrid'] = $asset_attribute['attrid'];
            if (isset($data['attributes'][$attribute_name])) {
                $this->vars[$attribute_name]['value'] = (($asset_attribute['type'] == 'serialise') ? unserialize($data['attributes'][$attribute_name]) : $data['attributes'][$attribute_name]);
            } else {
                $this->vars[$attribute_name]['value'] = (($asset_attribute['type'] == 'serialise') ? unserialize($asset_attribute['default_val']) : $asset_attribute['default_val']);
            }
        }

        // set general object properties, now we have the name of the thing
        $this->id = $formid.':q'.$this->_questionid;
        $this->name = $this->vars['name']['value'];
        $this->short_name = $this->name;
        $this->status = $form->status;
        $this->version = '0.1';

        // set variable values
        $this->vars['question_type_code']['value'] = get_class_lower($this);
        $this->vars['question_type_code']['type'] = 'text';

    }//end constructor


    function setAttrValue($name, $value)
    {
        // do not allow empty question titles
        if ($name == 'name' && empty($value)) {
            return FALSE;
        }

        return parent::setAttrValue($name, $value);

    }//end setAttrValue()


    function saveAttributes($dont_run_updated=FALSE)
    {
        if (!$this->id) return TRUE;
//      if (empty($this->_tmp['vars_set'])) return TRUE;

        $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->_formid);

        if (!$GLOBALS['SQ_REVERT_TO_SYSTEM_VERSION'] && !$form->writeAccess('attributes')) {
            trigger_localised_error('CORE0121', E_USER_WARNING, $this->name, $this->id);
            return FALSE;
        }

        $save_vars = Array();
        $attr_ids  = Array();

        // prepare for the save
        $saved_vars = $this->vars;

        unset($saved_vars['question_type_code']);

        // open the transaction
        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        // find any previous entries
        $sql   = 'SELECT name, default_val FROM '.SQ_TABLE_RUNNING_PREFIX.'ast_attr ';
        $where = 'type_code = :type_code';
        $where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($where);

        try {
            $query = MatrixDAL::preparePdoQuery($sql.$where);
            MatrixDAL::bindValueToPdo($query, 'type_code', $this->vars['question_type_code']['value']);
            $existing = MatrixDAL::executePdoGroupedAssoc($query);
        } catch (Exception $e) {
            throw new Exception('Can not get default val and name base on type code due to the following database error '.$e->getMessage());
        }//end try catch

        // check against default values; we don't need to save that attribute if it is
        foreach ($existing as $name => $default_val) {
            if ($saved_vars[$name]['value'] == $default_val['0']['default_val']) {
                unset($saved_vars[$name]);
            }
        }//end foreach

        // only save the values
        foreach ($saved_vars as $attr_id => $saved_var) {
            $saved_vars_ser[$attr_id] = (($saved_vars[$attr_id]['type'] == 'serialise') ? serialize($saved_vars[$attr_id]['value']) : $saved_vars[$attr_id]['value']);
        }


        $questions = $form->attr('questions');
        $questions[$this->_questionid]['attributes'] = $saved_vars_ser;

        $form->setAttrValue('questions', $questions);

        if (!$form->saveAttributes()) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
            $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
            return FALSE;
        }

        // tell, the asset it has updated
        if (!$dont_run_updated && !$this->_updated()) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
            $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
            return FALSE;
        }

        unset($this->_tmp['vars_set']);

        // If we get this far, then it's all OK
        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        $GLOBALS['SQ_SYSTEM']->am->updateLock($this->_formid, 'attributes');

        return TRUE;

    }//end saveAttributes()


    function _updated($update_parents=TRUE)
    {
        // We should not be running our _updated() because we don't have anything in the asset table
        // to update... but we should run our form/section's update, if only to increment the version
        if (SQ_IN_BACKEND) {
            $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->_formid);
            return $form->_updated($update_parents);
        }

        return TRUE;

    }//end _updated()


    function canClone()
    {
        return FALSE;

    }//end canClone()


    function _getName($short_name=FALSE)
    {
        return $this->attr('name');

    }//end _getName()


    function getVal($field='')
    {
        switch (strtolower($field)) {
            case 'title' :
                return $this->attr('name');
            case 'answer' :
                return $this->getHtmlField();
            break;
            case 'note' :
                return $this->attr('note');
            case 'value' :
                return $this->getValue();
            default:
                return '';
        }

    }//end getVal()


    function getAnswerByOffset($offset=0)
    {
        $options = $this->getOptions();
        if (is_array($offset)) {
            $answers = Array();
            foreach ($offset as $o) {
                if (isset($options[$o])) $answers[] = $options[$o];
            }
            return $answers;
        }
        if (isset($options[$offset])) return $options[$offset];

        return FALSE;

    }//end getAnswerByOffset()


    function getOffsetByAnswer($answer='')
    {
        if (!$answer) return FALSE;

        $options = $this->getOptions();
        if (in_array($answer, $options)) {
            return array_search($answer, $options);
        }

    }//end getOffsetByAnswer()


    function isSelection()
    {
        foreach ($this->getSelectionTypeQuestions() as $types) {
            if ($this instanceof $types) return TRUE;
        }
        return FALSE;

    }//end isSelection()


    function getSelectionTypeQuestions()
    {
        $questions = Array(
                        'form_question_type_select',
                        'form_question_type_tickbox_list',
                        'form_question_type_option_list',
                        'form_question_type_country',
                     );

        return $questions;

    }//end getSelectionTypeQuestions()


    function &getMySection()
    {
        $asset = NULL;
        if (empty($this->_formid)) return $asset;

        $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->_formid);
        return $asset;

    }//end getMySection()


    function getMySectionName()
    {
        if (!$this->section_name) {
            $section = $this->getMySection();
            $this->section_name = $section->name;
        }
        return $this->section_name;

    }//end getMySectionName()


    function generateJSCode()
    {
        $rules = $this->getRules();
        $code = '';                     // blank sheet of code to start with

        foreach ($rules as $k => $rule) {
            $type_code = 'form_question_rule_type_'.$rule['rule_code'];

            $GLOBALS['SQ_SYSTEM']->am->includeAsset($type_code);
            $rule_asset = new $type_code();
            $code .= $rule_asset->generateJSCode($this, $rule);
            $code .= "\n";
        }

        return $code;

    }//end generateJSCode()


    function getAllowedRules()
    {
        return Array();

    }//end getAllowedRules()


    function &addRule($rule_code, $operator, $value)
    {
        $rules = $this->attr('rules');
        $rules[] = Array('rule_code' => $rule_code, 'operator' => $operator, 'value' => $value);
        $this->setAttrValue('rules', $rules);
        $this->saveAttributes();
        return $rules;

    }//end addRule()


    function &removeRule(&$deleted_rule)
    {
        $rules = $this->attr('rules');
        foreach (array_keys($rules) as $rule_index) {
            if ($rules[$rule_index] == $deleted_rule) {
                unset($rules[$rule_index]);
                break;
            }
        }
        $this->setAttrValue('rules', $rules);
        $this->saveAttributes();
        return $rules;

    }//end removeRule()


    function getRules()
    {
        return $this->attr('rules');

    }//end getRules()


    function getRuleCount()
    {
        return count($this->getRules());

    }//end getRuleCount()


    function isEditable()
    {
        return TRUE;

    }//end isEditable()


    function getHtmlField()
    {
        return TRUE;

    }//end getHtmlField()


    function populate(Asset $parent=NULL)
    {
        if (isset($_POST['q'.$this->id])) {
            // check if we are allowing the keywords to be replaced in answer
            if(isset($parent) && $parent->attr('disable_keyword_replacements')) {
                $value = $_POST['q'.$this->id];
                // sanitise it by removing '%' from keywords so that
                // they dont go ahead and try to fetch it replacement
                if (is_array($value)) {
                    foreach ($value as $idx => $val) {
                        $keywords = extract_keywords($val);
                        foreach ($keywords as $keyword) {
                            $pattern = '/(%*)'.$keyword.'(%*)/';
                            $value[$idx] = preg_replace($pattern, $keyword, $val);
                        }
                    }
                } else {
                    $keywords = extract_keywords($value);
                    foreach ($keywords as $keyword) {
                        $pattern = '/(%*)'.$keyword.'(%*)/';
                        $value = preg_replace($pattern, $keyword, $value);
                    }
                }
                $this->setValue($value);
            } else {
                $this->setValue($_POST['q'.$this->id]);
            }
        }
        return TRUE;

    }//end populate()


    function setValue($value)
    {
        $this->value = $value;

    }//end setValue()


    function setExtraData(Array $data=NULL)
    {
        $this->extra_data = $data;

    }//end setExtraData()


    function hasValidValue($answer=NULL, $mute_errors=FALSE)
    {
        if (is_null($answer)) $answer = $this->getValue();
        if ($mute_errors === FALSE) {
            $this->failed_rules = Array();
        }

        $rules = $this->getRules();
        $ok = TRUE;                     // We start as being all OK

        if (!$this->attr('is_required') && $answer === '') {
            return TRUE;
        }

        foreach ($rules as $k=>$rule) {
            $type_code = 'form_question_rule_type_'.$rule['rule_code'];

            $GLOBALS['SQ_SYSTEM']->am->includeAsset($type_code);
            $rule_asset = new $type_code();
            $rule_ok = $rule_asset->evaluate($answer, $rule, $this);

            if (!$rule_ok) {
                $ok = FALSE;
                if (!$mute_errors) {
                    $custom_text = array_get_index($rule, 'custom_text', '');
                    if (!empty($custom_text)) {
                        $this->failed_rules[] = $rule['custom_text'];
                    } else {
                        $this->failed_rules[] = $rule_asset->defaultError($this, $rule);
                    }
                } else {
                    // If we are muting errors, we don't need to evaluate any
                    // more rules, so we can just short-circuit and return now
                    return FALSE;
                }
            }

        }

        return $ok;

    }//end hasValidValue()


    function saveValue()
    {
        return;

    }//end saveValue()


    function getValue()
    {
        require_once SQ_FUDGE_PATH.'/general/text.inc';

        // First see if there is a sticky value for this question - if we're
        // allowed to use it
        if (is_null($this->value) && $this->attr('sticky')) {
            $this->value = $this->getStickyValue();
        }

        // Still nothing? Go to the default value then
        if (is_null($this->value)) {

            $default_value = $this->attr('default');
            // If the default value is NULL on some configuration, make it empty string to prevent infinite loop.
            if (is_null($default_value)) {
                $default_value = '';
            }//end if

            if (!is_array($default_value)) {
                $keywords = retrieve_keywords_replacements($default_value);
                $replacements = Array();

                foreach ($keywords as $keyword) {
                    if (preg_match('|^current_user_|', $keyword)) {
                        $user_keyword = preg_replace('|^current_user_|', 'asset_', $keyword);
                        $user = $GLOBALS['SQ_SYSTEM']->user;

                        // If we are the public user, this should be empty
                        if ($GLOBALS['SQ_SYSTEM']->userPublic()) {
                            $replacements[$keyword] = '';
                        } else {
                            $replacements[$keyword] = $user->getKeywordReplacement($user_keyword);
                        }
                    } else {
                        $replacements[$keyword] = $this->getKeywordReplacement($keyword);
                    }
                }

                replace_keywords($default_value, $replacements);
                replace_global_keywords($default_value);

                // If the default value is a dud, blank it
                if (!$this->hasValidValue($default_value, TRUE)) {
                    $default_value = '';
                }
            }

            return $default_value;
        }//end if (is_null($this->value))

        if (is_array($this->value)) return $this->value;

        //return htmlspecialchars($this->value, ENT_NOQUOTES);
        return $this->value;

    }//end getValue()


    function getSummary()
    {
        return $this->getValue();

    }//end getSummary()


    function getExtraData()
    {
        return $this->extra_data;

    }//end getSummary()


    function getXML()
    {
        ob_start();

        echo '<text_q id="'.addslashes($this->id).'"  name="'.htmlspecialchars($this->attr('name')).'">';
        echo htmlspecialchars($this->getSummary());
        echo '</text_q>';

        $contents = ob_get_contents();
        ob_end_clean();

        return $contents;

    }//end getXML()


    function getErrors()
    {
        return $this->failed_rules;

    }//end getErrors()


//--        PERMISSIONS/ACCESS (DEFERS TO FORM/FORM SECTION)        --//


    function readAccess($assetids=Array())
    {
        $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->_formid);
        if (is_null($form)) return FALSE;

        return $form->readAccess($assetids);

    }//end readAccess()


    function writeAccess($lock_type='', $assetids=Array())
    {
        $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->_formid);
        if (is_null($form)) return FALSE;

        return $form->writeAccess($lock_type, $assetids);

    }//end writeAccess()


    function adminAccess($lock_type='', $assetids=Array())
    {
        $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->_formid);
        if (is_null($form)) return FALSE;

        return $form->adminAccess($lock_type, $assetids);

    }//end adminAccess()


    function liveEditAccess($lock_type)
    {
        if (empty($lock_type) || $this->canLiveEdit($lock_type)) {
            return $this->checkAccess(SQ_PERMISSION_WRITE, $lock_type);
        }
        return FALSE;

    }//end liveEditAccess()


    function checkAccess($perm, $lock_type, $assetids=Array())
    {
        $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->_formid);
        if (is_null($form)) return FALSE;

        return $form->checkAccess($perm, $lock_type, $assetids);

    }//end checkAccess()


    function _checkPermissionAccess($perm, $assetids=Array())
    {
        $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->_formid);
        if (is_null($form)) return FALSE;

        return $form->_checkPermissionAccess($perm, $assetids);

    }//end _checkPermissionAccess()


    function stickValue($value)
    {
        $cookie_name = $this->_getCookieName();
        $_SESSION['SQ_FORM_STICKY'][$GLOBALS['SQ_SYSTEM']->user->id][$cookie_name] = $value;

    }//end stickValue()


    function unstickValue()
    {
        $cookie_name = $this->_getCookieName();
        unset($_SESSION['SQ_FORM_STICKY'][$GLOBALS['SQ_SYSTEM']->user->id][$cookie_name]);

    }//end unstickValue()


    function getStickyValue()
    {
        $cookie_name = $this->_getCookieName();

        if (!isset($_SESSION['SQ_FORM_STICKY'][$GLOBALS['SQ_SYSTEM']->user->id][$cookie_name])) {
            return NULL;
        }

        $value = $_SESSION['SQ_FORM_STICKY'][$GLOBALS['SQ_SYSTEM']->user->id][$cookie_name];

        // If the sticky value is a dud, blank it
        if (!$this->hasValidValue($value, TRUE)) {
            $value = NULL;
        }

        return $value;

    }//end getStickyValue()


    function _getCookieName()
    {
        // We use make_valid_web_paths() to make the name more safe to use
        list($question_name) = make_valid_web_paths(Array($this->name));
        return $question_name;

    }//end _getCookieName()


    function processStatusChange($new_status, $update_parent=TRUE)
    {
        return TRUE;

    }//end processStatusChange()


    function getHtmlLabel()
    {
        ob_start();
        label($this->attr('name'), 'q'.str_replace(':', '_', $this->id));
        $label = ob_get_contents();
        ob_end_clean();
        return $label;

    }//end getHtmlLabel()


}//end class
?>