Has actual responses different to the model response for this class?

@return bool whether this analysis has a response class with more than one
different actual response, or if the actual response is different from
the model response.
773337
public function has_actual_responses() {
        foreach ($this->get_response_class_ids() as $responseclassid) {
            if ($this->get_response_class($responseclassid)->has_actual_responses()) {
                return true;
            }
        }
        return false;
    }
166222
protected function isMatchingRequestVariables()
    {
        foreach ($this->getMatchRequestVariables() as $key => $value)
        {
            if ($this->getRequest()->get($key) != $value)
            {
                return false;
            }
        }

        return true;
    }
846594
public function isChanged()
    {
        $snapshot = $this->_snapshot;
        if (!is_array($snapshot)) {
            return true;
        }
        $metadata = $this->getModelsMetaData();
        $attrs = $metadata->getNonPrimaryKeyAttributes($this);
        $automatic = $metadata->getAutomaticUpdateAttributes($this);
        $bindDataTypes = $metadata->getBindTypes($this);
        foreach ($attrs as $name) {
            if (isset($automatic[$name])) {
                continue;
            }
            $value = $this->readAttribute($name);
            $snapshotValue = ArrayHelper::fetch($snapshot, $name);
            if ($value === null) {
                if ($snapshotValue !== null) {
                    return true;
                }
            } else {
                if ($snapshotValue === null) {
                    return true;
                }
                $bindType = ArrayHelper::fetch($bindDataTypes, $name);
                switch ($bindType) {
                    case Column::TYPE_DATE:
                    case Column::TYPE_VARCHAR:
                    case Column::TYPE_DATETIME:
                    case Column::TYPE_CHAR:
                    case Column::TYPE_TEXT:
                    case Column::TYPE_VARCHAR:
                    case Column::TYPE_BIGINTEGER:
                        if (((string)$value) !== ((string)$snapshotValue)) {
                            return true;
                        }
                        break;
                    default:
                        if ($value != $snapshotValue) {
                            return true;
                        }
                }
            }
        }
        return false;
    }
558805
public function isSelected()
    {
        if (!is_null($this->isSelected))
            return $this->isSelected;
        if (is_string($this->url) && $this->url == \mpf\WebApp::get()->request()->getCurrentURL()) {
            return true;
        } elseif (is_array($this->url)) {
            $controller = isset($this->url[0]) ? $this->url[0] : 'home';
            if ($controller != \mpf\WebApp::get()->request()->getController()) {
                return false;
            }

            if ($this->getModule() != \mpf\WebApp::get()->request()->getModule()) {
                return false; // different module;
            }
            if (\mpf\WebApp::get()->getController()) {
                $action = isset($this->url[1]) ? $this->url[1] : \mpf\WebApp::get()->getController()->defaultAction;
                return ($action == \mpf\WebApp::get()->getController()->getActiveAction());
            }
        }
        return false;
    }
831433
public function checkHas() {
        /* @var $model Record */
        $model = get_called_class();
        $model = $model::get($this->getPk());
        if ($model) {
            $this->isUpdate(true);
            return true;
        }
        return false;
    }
782988
protected function inferResponseType()
    {
        static $primitives = array('array' => 1, 'boolean' => 1, 'string' => 1, 'integer' => 1, '' => 1);
        if (isset($primitives[$this->responseClass])) {
            $this->responseType = self::TYPE_PRIMITIVE;
        } elseif ($this->description && $this->description->hasModel($this->responseClass)) {
            $this->responseType = self::TYPE_MODEL;
        } else {
            $this->responseType = self::TYPE_CLASS;
        }
    }
164965
public function success()
    {
        $inputOtp = $this->getInputOtp();
        $inputNonce = $this->getInputNonce();

        if ($inputNonce === null || $inputOtp === null) {
            return false;
        }

        return (
            $inputOtp == $this->otp
            && $inputNonce === $this->nonce
            && $this->status === Response::SUCCESS
        ) ? true : false;
    }
286349
public function checkRegistryRequestsAnswers()
    {
        if (! $this->db instanceof \Zend_Db_Adapter_Abstract) {
            return false;
        }

        $select = $this->db->select();
        $select->from(['nw'=> 'gems__tokens'], [
            'gtrp_id_token_new' => 'gto_id_token',
            'gtrp_created' => 'gto_created',
            'gtrp_created_by' => 'gto_created_by',
            ])->joinInner(
                    ['pr' => 'gems__tokens'],
                    "nw.gto_id_respondent_track = pr.gto_id_respondent_track AND
                     nw.gto_id_round            = pr.gto_id_round AND
                     nw.gto_round_order         = pr.gto_round_order AND
                     nw.gto_created             > pr.gto_created
                     ",
                    ['gtrp_id_token_old' => 'gto_id_token',]
                    )
                ->where('nw.gto_id_token NOT IN (SELECT gtrp_id_token_new FROM gems__token_replacements)')
                ->order('nw.gto_id_token')
                ->order('pr.gto_created');

        $this->_stmt = $this->db->query($select);

        return parent::checkRegistryRequestsAnswers();
    }
1162245
final public function hasChanged() {

		$class = get_called_class();
		$varFields = $class::getBinds();

		// create a new similar object that populates properly
		$newObj = new $class($this->{$this->keyProperties});
		
		if (!$newObj) return TRUE;
		
		foreach ($varFields as $property => $field) {
			if ($this->$property != $newObj->$property) {
				return TRUE;
			}
		}
		
		return FALSE;
		
	}
734233
public function isDirty()
    {
        if (count($this) != $this->_original) {
            return true;
        }
        if (count($this->_deleted)) {
            return true;
        }
        foreach ($this as $model) {
            if (is_object($model)
                && ($model->isDirty() || $model->isNew())
            ) {
                return true;
            }
        }
        return false;
    }
146940
public function IsSponsored()
    {
        $bIsSponsored = $this->GetFromInternalCache('bVoucherIsSponsored');
        if (is_null($bIsSponsored)) {
            $bIsSponsored = false;
            $oVoucherSeries = $this->GetFieldShopVoucherSeries();
            if ($oVoucherSeries && !empty($oVoucherSeries->fieldShopVoucherSeriesSponsorId)) {
                $bIsSponsored = true;
            }
            $this->SetInternalCache('bVoucherIsSponsored', $bIsSponsored);
        }

        return $bIsSponsored;
    }
744213
public function isUnique()
    {
        $unique = false;

        //Get the unique states
        $states = $this->getData(true);

        if (!empty($states)) {
            $unique = true;

            //If a state contains multiple values the state is not unique
            foreach ($states as $state) {
                if (is_array($state) && count($state) > 1) {
                    $unique = false;
                    break;
                }
            }
        }

        return $unique;
    }
1133765
public function isSupported()
    {
        $result = true;
        $table  = $this->getMixer();

        //Only check if we are connected with a table object, otherwise just return true.
        if($table instanceof DatabaseTableInterface)
        {
            if($table->hasColumn('slug'))
            {
                //If unique is NULL use the column metadata
                if(is_null($this->_unique)) {
                    $this->_unique = $table->getColumn('slug', true)->unique;
                }
            }
            else $result = false;
        }

        return $result;
    }
119450
public function hasReturnTypes()
    {
        if (\count($this->returnTypes)) {
            return true;
        }

        if (\count($this->returnClassTypes)) {
            return true;
        }

        return false;
    }
849451
public function isSupported()
    {
        $mixer = $this->getMixer();

        //Disable controller persistency on requests containing the tmpl variable set to component (modal boxes)
        if ($mixer->getRequest()->query->get('tmpl', 'cmd') === 'component') {
            return false;
        }

        return parent::isSupported();
    }
1269833
public static function get_responses_analysis_returns() {
        $responsestructure = new external_multiple_structure(
            new external_single_structure(
                array(
                    'id' => new external_value(PARAM_INT, 'Response id'),
                    'name' => new external_value(PARAM_RAW, 'Response name'),
                    'printval' => new external_value(PARAM_RAW, 'Response ready for output'),
                    'rawval' => new external_value(PARAM_RAW, 'Response raw value'),
                )
            )
        );

        return new external_single_structure(
            array(
                'attempts' => new external_multiple_structure(
                    new external_single_structure(
                        array(
                            'id' => new external_value(PARAM_INT, 'Completed id'),
                            'courseid' => new external_value(PARAM_INT, 'Course id'),
                            'userid' => new external_value(PARAM_INT, 'User who responded'),
                            'timemodified' => new external_value(PARAM_INT, 'Time modified for the response'),
                            'fullname' => new external_value(PARAM_TEXT, 'User full name'),
                            'responses' => $responsestructure
                        )
                    )
                ),
                'totalattempts' => new external_value(PARAM_INT, 'Total responses count.'),
                'anonattempts' => new external_multiple_structure(
                    new external_single_structure(
                        array(
                            'id' => new external_value(PARAM_INT, 'Completed id'),
                            'courseid' => new external_value(PARAM_INT, 'Course id'),
                            'number' => new external_value(PARAM_INT, 'Response number'),
                            'responses' => $responsestructure
                        )
                    )
                ),
                'totalanonattempts' => new external_value(PARAM_INT, 'Total anonymous responses count.'),
                'warnings' => new external_warnings(),
            )
        );
    }
1161612
public function hasChange()
    {
        return !is_null($this->resource) && ($this->resource->hasFields() || $this->resource->hasIndexes());
    }