class.ilXapiStatementEvaluation.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
class ilXapiStatementEvaluation
{
    protected array $resultStatusByXapiVerbMap = [
        ilCmiXapiVerbList::COMPLETED => "completed",
        ilCmiXapiVerbList::PASSED => "passed",
        ilCmiXapiVerbList::FAILED => "failed",
        ilCmiXapiVerbList::SATISFIED => "passed"
    ];
 
    protected array $resultProgressByXapiVerbMap = [
        ilCmiXapiVerbList::PROGRESSED => "progressed",
        ilCmiXapiVerbList::EXPERIENCED => "experienced"
    ];
 
    protected ilObject $object;
 
    //todo
    protected ilLogger $log;
 
    protected ?int $lpMode;
 
    public function __construct(ilLogger $log, ilObject $object)
    {
        $this->log = $log;
        $this->object = $object;
 
        $objLP = ilObjectLP::getInstance($this->object->getId());
        $this->lpMode = $objLP->getCurrentMode();
    }
 
    public function evaluateReport(ilCmiXapiStatementsReport $report): void
    {
        foreach ($report->getStatements() as $xapiStatement) {
            #$this->log->debug(
            #   "handle statement:\n".json_encode($xapiStatement, JSON_PRETTY_PRINT)
            #);
 
            // ensure json decoded non assoc
            $xapiStatement = json_decode(json_encode($xapiStatement));
            $cmixUser = $this->getCmixUser($xapiStatement);
 
            if ($cmixUser != null) {
                $this->evaluateStatement($xapiStatement, $cmixUser->getUsrId());
 
                $this->log->debug('update lp for object (' . $this->object->getId() . ')');
                if ($cmixUser->getUsrId() != ANONYMOUS_USER_ID) {
                    ilLPStatusWrapper::_updateStatus($this->object->getId(), $cmixUser->getUsrId());
                }
            }
        }
    }
 
    public function getCmixUser(object $xapiStatement): ?\ilCmiXapiUser
    {
        $cmixUser = null;
        if ($this->object->getContentType() == ilObjCmiXapi::CONT_TYPE_CMI5) {
            if (isset($xapiStatement->actor->account->name)) {
                $cmixUser = ilCmiXapiUser::getInstanceByObjectIdAndUsrIdent(
                    $this->object->getId(),
                    $xapiStatement->actor->account->name
                );
            }
        } else {
            $cmixUser = ilCmiXapiUser::getInstanceByObjectIdAndUsrIdent(
                $this->object->getId(),
                str_replace('mailto:', '', $xapiStatement->actor->mbox)
            );
        }
        return $cmixUser;
    }
 
    public function evaluateStatement(object $xapiStatement, int $usrId): void
    {
        global $DIC;
        $xapiVerb = $this->getXapiVerb($xapiStatement);
 
        if ($this->isValidXapiStatement($xapiStatement)) {
            // result status and if exists scaled score
            if ($this->hasResultStatusRelevantXapiVerb($xapiVerb)) {
                if (!$this->isValidObject($xapiStatement)) {
                    return;
                }
                $userResult = $this->getUserResult($usrId);
 
                $oldResultStatus = $userResult->getStatus();
                $newResultStatus = $this->getResultStatusForXapiVerb($xapiVerb);
 
                // this is for both xapi and cmi5
                if ($this->isResultStatusToBeReplaced($oldResultStatus, $newResultStatus)) {
                    $this->log->debug("isResultStatusToBeReplaced: true");
                    $userResult->setStatus($newResultStatus);
                }
 
                if ($this->hasXapiScore($xapiStatement)) {
                    $xapiScore = $this->getXapiScore($xapiStatement);
                    $this->log->debug("Score: " . $xapiScore);
                    $userResult->setScore((float) $xapiScore);
                }
                $userResult->save();
 
                // only cmi5
                if ($this->object->getContentType() == ilObjCmiXapi::CONT_TYPE_CMI5) {
                    if (($xapiVerb == ilCmiXapiVerbList::COMPLETED || $xapiVerb == ilCmiXapiVerbList::PASSED) && $this->isLpModeInterestedInResultStatus($newResultStatus, false)) {
                        // it is possible to check against authToken usrId!
                        $cmixUser = $this->getCmixUser($xapiStatement);
                        if ($cmixUser != null) {
                            $cmixUser->setSatisfied(true);
                            $cmixUser->save();
                            $this->sendSatisfiedStatement($cmixUser);
                        }
                    }
                }
            }
            // result progress (i think only cmi5 relevant)
            if ($this->hasResultProgressRelevantXapiVerb($xapiVerb)) {
                $userResult = $this->getUserResult($usrId);
                $progressedScore = $this->getProgressedScore($xapiStatement);
                if ($progressedScore !== null && $progressedScore > 0) {
                    $userResult->setScore((float) ($progressedScore / 100));
                    $userResult->save();
                }
            }
        }
    }
 
    protected function isValidXapiStatement(object $xapiStatement): bool
    {
        if (!isset($xapiStatement->actor)) {
            return false;
        }
 
        if (!isset($xapiStatement->verb) || !isset($xapiStatement->verb->id)) {
            return false;
        }
 
        if (!isset($xapiStatement->object) || !isset($xapiStatement->object->id)) {
            return false;
        }
 
        return true;
    }
 
    protected function isValidObject(object $xapiStatement): bool
    {
        if ($xapiStatement->object->id != $this->object->getActivityId()) {
            $this->log->debug($xapiStatement->object->id . " != " . $this->object->getActivityId());
            return false;
        }
        return true;
    }
 
 
    protected function getXapiVerb(object $xapiStatement): string
    {
        return $xapiStatement->verb->id;
    }
 
    protected function getResultStatusForXapiVerb(string $xapiVerb): string
    {
        return $this->resultStatusByXapiVerbMap[$xapiVerb];
    }
 
    protected function hasResultStatusRelevantXapiVerb(string $xapiVerb): bool
    {
        return isset($this->resultStatusByXapiVerbMap[$xapiVerb]);
    }
 
    protected function getResultProgressForXapiVerb(string $xapiVerb)
    {
        return $this->resultProgressByXapiVerbMap[$xapiVerb];
    }
 
    protected function hasResultProgressRelevantXapiVerb(string $xapiVerb): bool
    {
        return isset($this->resultProgressByXapiVerbMap[$xapiVerb]);
    }
 
    protected function hasXapiScore(object $xapiStatement): bool
    {
        if (!isset($xapiStatement->result)) {
            return false;
        }
 
        if (!isset($xapiStatement->result->score)) {
            return false;
        }
 
        if (!isset($xapiStatement->result->score->scaled)) {
            return false;
        }
 
        return true;
    }
 
    protected function getXapiScore(object $xapiStatement)
    {
        return $xapiStatement->result->score->scaled;
    }
 
    protected function getProgressedScore(object $xapiStatement): ?float
    {
        if (!isset($xapiStatement->result)) {
            return null;
        }
 
        if (!isset($xapiStatement->result->extensions)) {
            return null;
        }
 
        if (!isset($xapiStatement->result->extensions->{'https://w3id.org/xapi/cmi5/result/extensions/progress'})) {
            return null;
        }
        return (float) $xapiStatement->result->extensions->{'https://w3id.org/xapi/cmi5/result/extensions/progress'};
    }
 
    protected function getUserResult(int $usrId): \ilCmiXapiResult
    {
        try {
            $result = ilCmiXapiResult::getInstanceByObjIdAndUsrId($this->object->getId(), $usrId);
        } catch (ilCmiXapiException $e) {
            $result = ilCmiXapiResult::getEmptyInstance();
            $result->setObjId($this->object->getId());
            $result->setUsrId($usrId);
        }
 
        return $result;
    }
 
    protected function isResultStatusToBeReplaced(string $oldResultStatus, string $newResultStatus): bool
    {
        if (!$this->isLpModeInterestedInResultStatus($newResultStatus)) {
            $this->log->debug("isLpModeInterestedInResultStatus: false");
            return false;
        }
 
        if (!$this->doesNewResultStatusDominateOldOne($oldResultStatus, $newResultStatus)) {
            $this->log->debug("doesNewResultStatusDominateOldOne: false");
            return false;
        }
 
        if ($this->needsAvoidFailedEvaluation($oldResultStatus, $newResultStatus)) {
            $this->log->debug("needsAvoidFailedEvaluation: false");
            return false;
        }
 
        return true;
    }
 
    protected function isLpModeInterestedInResultStatus(string $resultStatus, ?bool $deactivated = true): ?bool
    {
        if ($this->lpMode == ilLPObjSettings::LP_MODE_DEACTIVATED) {
            return $deactivated;
        }
 
        switch ($resultStatus) {
            case 'failed':
 
                return in_array($this->lpMode, [
                    ilLPObjSettings::LP_MODE_CMIX_COMPL_WITH_FAILED,
                    ilLPObjSettings::LP_MODE_CMIX_PASSED_WITH_FAILED,
                    ilLPObjSettings::LP_MODE_CMIX_COMPL_OR_PASSED_WITH_FAILED
                ]);
 
            case 'passed':
 
                return in_array($this->lpMode, [
                    ilLPObjSettings::LP_MODE_CMIX_PASSED,
                    ilLPObjSettings::LP_MODE_CMIX_PASSED_WITH_FAILED,
                    ilLPObjSettings::LP_MODE_CMIX_COMPLETED_OR_PASSED,
                    ilLPObjSettings::LP_MODE_CMIX_COMPL_OR_PASSED_WITH_FAILED
                ]);
 
            case 'completed':
 
                return in_array($this->lpMode, [
                    ilLPObjSettings::LP_MODE_CMIX_COMPLETED,
                    ilLPObjSettings::LP_MODE_CMIX_COMPL_WITH_FAILED,
                    ilLPObjSettings::LP_MODE_CMIX_COMPLETED_OR_PASSED,
                    ilLPObjSettings::LP_MODE_CMIX_COMPL_OR_PASSED_WITH_FAILED
                ]);
        }
 
        return false;
    }
 
    protected function doesNewResultStatusDominateOldOne(string $oldResultStatus, string $newResultStatus): bool
    {
        if ($oldResultStatus == '') {
            return true;
        }
 
        if (in_array($newResultStatus, ['passed', 'failed'])) {
            return true;
        }
 
        if (!in_array($oldResultStatus, ['passed', 'failed'])) {
            return true;
        }
 
        return false;
    }
 
    protected function needsAvoidFailedEvaluation(string $oldResultStatus, string $newResultStatus): bool
    {
        if (!$this->object->isKeepLpStatusEnabled()) {
            return false;
        }
 
        if ($newResultStatus != 'failed') {
            return false;
        }
 
        return $oldResultStatus == 'completed' || $oldResultStatus == 'passed';
    }
 
 
    protected function sendSatisfiedStatement(ilCmiXapiUser $cmixUser): void
    {
        global $DIC;
 
        $lrsType = $this->object->getLrsType();
        $defaultLrs = $lrsType->getLrsEndpoint();
        $defaultBasicAuth = $lrsType->getBasicAuth();
 
        $defaultHeaders = [
            'X-Experience-API-Version: 1.0.3',
            'Authorization: ' . $defaultBasicAuth,
            'Content-Type: application/json;charset=utf-8',
            'Cache-Control: no-cache, no-store, must-revalidate'
        ];
 
        $satisfiedStatement = $this->object->getSatisfiedStatement($cmixUser);
        $satisfiedStatementParams = ['statementId' => $satisfiedStatement['id']];
        $defaultStatementsUrl = $defaultLrs . "/statements";
        $defaultSatisfiedStatementUrl = $defaultStatementsUrl . '?' . ilCmiXapiAbstractRequest::buildQuery($satisfiedStatementParams);
 
        // --- cURL Init ---
        $ch = curl_init($defaultSatisfiedStatementUrl);
        curl_setopt_array($ch, [
            CURLOPT_CUSTOMREQUEST => "PUT",
            CURLOPT_HTTPHEADER => $defaultHeaders,
            CURLOPT_POSTFIELDS => json_encode($satisfiedStatement),
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_CONNECTTIMEOUT => 10,
            CURLOPT_SSL_VERIFYPEER => true,
        ]);
 
        $responseBody = curl_exec($ch);
        $statusCode = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
 
        if ($responseBody === false) {
            $error = curl_error($ch);
            $this->log->error('cURL error while sending satisfied statement: ' . $error);
        } else {
            try {
                ilCmiXapiAbstractRequest::checkResponse(
                    ['status' => $statusCode, 'body' => $responseBody],
                    $responseBody,
                    [204]
                );
            } catch (Exception $e) {
                $this->log->error('checkResponse failed: ' . $e->getMessage());
            }
        }
 
        curl_close($ch);
    }
 
}