Service.php

Go to the documentation of this file.

<?php

namespace ILIAS\LTI\ToolProvider\Service;

use ILIAS\LTI\ToolProvider\AccessToken;
use ILIAS\LTI\ToolProvider\Platform;
use ILIAS\LTI\ToolProvider\Http\HTTPMessage;
use ILIAS\LTI\ToolProvider\Util;

class Service
{
    public bool $unsigned = false;

    protected ?string $endpoint = null;

    protected ?string $scope = null;

    protected ?string $mediaType = null;

    private ?Platform $platform = null;

    private ?HTTPMessage $http = null;

    public function __construct(Platform $platform, string $endpoint)
    {
        $this->platform = $platform;
        $this->endpoint = $endpoint;
    }

    //    /**
    //     * Get tool consumer.
    //     *
    //     * @deprecated Use getPlatform() instead
    //     * @see Service::getPlatform()
    //     *
    //     * @return ToolConsumer Consumer for this service
    //     */
    //    public function getConsumer()
    //    {
    //        Util::logDebug('Method ceLTIc\LTI\Service::getConsumer() has been deprecated; please use ceLTIc\LTI\Service::getPlatform() instead.',
    //            true);
    //        return $this->getPlatform();
    //    }

    public function getPlatform(): ?Platform
    {
        return $this->platform;
    }

    public function getScope(): ?string
    {
        return $this->scope;
    }

    public function send(string $method, array $parameters = array(), string $body = null): ?HTTPMessage
    {
        $url = $this->endpoint;
        if (!empty($parameters)) {
            if (strpos($url, '?') === false) {
                $sep = '?';
            } else {
                $sep = '&';
            }
            foreach ($parameters as $name => $value) {
                $url .= $sep . urlencode($name) . '=' . urlencode($value);
                $sep = '&';
            }
        }
        $header = null;
        $retry = !$this->platform->useOAuth1();
        $newToken = false;
        $retried = false;
        do {
            if (!$this->unsigned) {
                $accessToken = $this->platform->getAccessToken();
                if (!$this->platform->useOAuth1()) {
                    if (empty($accessToken)) {
                        $accessToken = new AccessToken($this->platform);
                        $this->platform->setAccessToken($accessToken);
                    }
                    if (!$accessToken->hasScope($this->scope)) {
                        $accessToken->get($this->scope);
                        $newToken = true;
                        if (!$accessToken->hasScope($this->scope)) {  // Try obtaining a token for just this scope
                            $accessToken->expires = time();
                            $accessToken->get($this->scope, true);
                            $retried = true;
                            if (!$accessToken->hasScope($this->scope)) {
                                if (empty($this->http)) {
                                    $this->http = new HttpMessage($url);
                                    $this->http->error = "Unable to obtain an access token for scope: {$this->scope}";
                                }
                                break;
                            }
                        }
                    }
                }
                $header = $this->platform->signServiceRequest($url, $method, $this->mediaType, $body);
            }
            // Connect to platform and parse JSON response
            //UK changed from
            //            $this->http = new HttpMessage($url, $method, $body, $header);
            // to
            $this->http = new \ILIAS\LTI\ToolProvider\Http\HttpMessage($url, $method, $body, $header);
            if ($this->http->send() && !empty($this->http->response)) {
                $this->http->responseJson = json_decode($this->http->response);
                $this->http->ok = !is_null($this->http->responseJson);
            }
            $retry = $retry && !$retried && !$this->http->ok;
            if ($retry) {
                if (!$newToken) {  // Invalidate existing token to force a new one to be obtained
                    $accessToken->expires = time();
                    $newToken = true;
                } elseif (count($accessToken->scopes) !== 1) {  // Try obtaining a token for just this scope
                    $accessToken->expires = time();
                    $accessToken->get($this->scope, true);
                    $retried = true;
                } else {
                    $retry = false;
                }
            }
        } while ($retry);

        return $this->http;
    }

    public function getHttpMessage(): ?HTTPMessage
    {
        return $this->http;
    }

    ###
    ###  PROTECTED METHODS
    ###

    protected function parseContextsInArray(object $contexts, array $arr): array
    {
        if (is_array($contexts)) {
            $contextdefs = array();
            foreach ($contexts as $context) {
                if (is_object($context)) {
                    $contextdefs = array_merge(get_object_vars($context), $contexts);
                }
            }
            $parsed = array();
            foreach ($arr as $key => $value) {
                $parts = explode(':', $value, 2);
                if (count($parts) > 1) {
                    if (array_key_exists($parts[0], $contextdefs)) {
                        $parsed[$key] = $contextdefs[$parts[0]] . $parts[1];
                        break;
                    }
                }
                $parsed[$key] = $value;
            }
        } else {
            $parsed = $arr;
        }

        return $parsed;
    }
}