ToolConsumer.php

Go to the documentation of this file.

<?php

namespace ceLTIc\LTI;

use ceLTIc\LTI\DataConnector;
use ceLTIc\LTI\Service;
use ceLTIc\LTI\HTTPMessage;
use ceLTIc\LTI\OAuth;

class ToolConsumer
{

    public $name = null;

    public $secret = null;

    public $ltiVersion = null;

    public $signatureMethod = 'HMAC-SHA1';

    public $consumerName = null;

    public $consumerVersion = null;

    public $profile = null;

    public $consumerGuid = null;

    public $cssPath = null;

    public $protected = false;

    public $enabled = false;

    public $enableFrom = null;

    public $enableUntil = null;

    public $lastAccess = null;

    public $idScope = ToolProvider::ID_SCOPE_ID_ONLY;

    public $defaultEmail = '';

    public $lastServiceRequest = null;

    public $created = null;

    public $updated = null;

    private $id = null;

    private $key = null;

    private $settings = null;

    private $settingsChanged = false;

    private $dataConnector = null;

    public function __construct($key = null, $dataConnector = null, $autoEnable = false)
    {
        $this->initialize();
        if (empty($dataConnector)) {
            $dataConnector = DataConnector\DataConnector::getDataConnector();
        }
        $this->dataConnector = $dataConnector;
        if (!is_null($key) && (strlen($key) > 0)) {
            $this->load($key, $autoEnable);
        } else {
            $this->secret = DataConnector\DataConnector::getRandomString(32);
        }
    }

    public function initialize()
    {
        $this->id = null;
        $this->key = null;
        $this->name = null;
        $this->secret = null;
        $this->signatureMethod = 'HMAC-SHA1';
        $this->ltiVersion = null;
        $this->consumerName = null;
        $this->consumerVersion = null;
        $this->consumerGuid = null;
        $this->profile = null;
        $this->toolProxy = null;
        $this->settings = array();
        $this->protected = false;
        $this->enabled = false;
        $this->enableFrom = null;
        $this->enableUntil = null;
        $this->lastAccess = null;
        $this->idScope = ToolProvider::ID_SCOPE_ID_ONLY;
        $this->defaultEmail = '';
        $this->created = null;
        $this->updated = null;
    }

    public function initialise()
    {
        $this->initialize();
    }

    public function save()
    {
        $ok = $this->dataConnector->saveToolConsumer($this);
        if ($ok) {
            $this->settingsChanged = false;
        }

        return $ok;
    }

    public function delete()
    {
        return $this->dataConnector->deleteToolConsumer($this);
    }

    public function getRecordId()
    {
        return $this->id;
    }

    public function setRecordId($id)
    {
        $this->id = $id;
    }

    public function getKey()
    {
        return $this->key;
    }

    public function setKey($key)
    {
        $this->key = $key;
    }

    public function getFamilyCode()
    {
        $familyCode = '';
        if (!empty($this->consumerVersion)) {
            list($familyCode, $version) = explode('-', $this->consumerVersion, 2);
        }

        return $familyCode;
    }

    public function getDataConnector()
    {
        return $this->dataConnector;
    }

    public function getIsAvailable()
    {
        $ok = $this->enabled;

        $now = time();
        if ($ok && !is_null($this->enableFrom)) {
            $ok = $this->enableFrom <= $now;
        }
        if ($ok && !is_null($this->enableUntil)) {
            $ok = $this->enableUntil > $now;
        }

        return $ok;
    }

    public function getSetting($name, $default = '')
    {
        if (array_key_exists($name, $this->settings)) {
            $value = $this->settings[$name];
        } else {
            $value = $default;
        }

        return $value;
    }

    public function setSetting($name, $value = null)
    {
        $old_value = $this->getSetting($name);
        if ($value !== $old_value) {
            if (!empty($value)) {
                $this->settings[$name] = $value;
            } else {
                unset($this->settings[$name]);
            }
            $this->settingsChanged = true;
        }
    }

    public function getSettings()
    {
        return $this->settings;
    }

    public function setSettings($settings)
    {
        $this->settings = $settings;
    }

    public function saveSettings()
    {
        if ($this->settingsChanged) {
            $ok = $this->save();
        } else {
            $ok = true;
        }

        return $ok;
    }

    public function hasToolSettingsService()
    {
        $has = !empty($this->getSetting('custom_system_setting_url'));
        if (!$has) {
            $has = self::hasApiHook(self::$TOOL_SETTINGS_SERVICE_HOOK, $this->getConsumer()->getFamilyCode());
        }
        return $has;
    }

    public function getToolSettings($simple = true)
    {
        $ok = false;
        $settings = array();
        if (!empty($this->getSetting('custom_system_setting_url'))) {
            $url = $this->getSetting('custom_system_setting_url');
            $service = new Service\ToolSettings($this, $url, $simple);
            $settings = $service->get($mode);
            $this->lastServiceRequest = $service->getHTTPMessage();
            $ok = $settings !== false;
        }
        if (!$ok && $this->hasApiHook(self::$TOOL_SETTINGS_SERVICE_HOOK, $this->getConsumer()->getFamilyCode())) {
            $className = $this->getApiHook(self::$TOOL_SETTINGS_SERVICE_HOOK, $this->getConsumer()->getFamilyCode());
            $hook = new $className($this);
            $settings = $hook->getToolSettings($mode, $simple);
        }

        return $settings;
    }

    public function setToolSettings($settings = array())
    {
        $ok = false;
        if (!empty($this->getSetting('custom_system_setting_url'))) {
            $url = $this->getSetting('custom_system_setting_url');
            $service = new Service\ToolSettings($this, $url);
            $ok = $service->set($settings);
            $this->lastServiceRequest = $service->getHTTPMessage();
        }
        if (!$ok && $this->hasApiHook(self::$TOOL_SETTINGS_SERVICE_HOOK, $this->getConsumer()->getFamilyCode())) {
            $className = $this->getApiHook(self::$TOOL_SETTINGS_SERVICE_HOOK, $this->getConsumer()->getFamilyCode());
            $hook = new $className($this);
            $ok = $hook->setToolSettings($settings);
        }

        return $ok;
    }

    public function signParameters($url, $type, $version, $params)
    {
        if (!empty($url)) {
// Add standard parameters
            $params['lti_version'] = $version;
            $params['lti_message_type'] = $type;
// Add signature
            $params = $this->addSignature($url, $params, 'POST', $type);
        }

        return $params;
    }

    public function signServiceRequest($url, $method, $type, $data = null)
    {
        $header = '';
        if (!empty($url)) {
            $header = $this->addSignature($url, $data, $method, $type);
        }

        return $header;
    }

    public function addSignature($endpoint, $data, $method = 'POST', $type = null, $forTP = false)
    {
        switch ($this->signatureMethod) {
            case 'HMAC-SHA1':
            case 'HMAC-SHA224':
            case 'HMAC-SHA256':
            case 'HMAC-SHA384':
            case 'HMAC-SHA512':
                return $this->addOAuthSignature($endpoint, $data, $method, $type);
                break;
            default:
                return $data;
                break;
        }
    }

    public function doServiceRequest($service, $method, $format, $data)
    {
        $header = $this->addSignature($service->endpoint, $data, $method, $format);

// Connect to tool consumer
        $http = new HTTPMessage($service->endpoint, $method, $data, $header);
// Parse JSON response
        if ($http->send() && !empty($http->response)) {
            $http->responseJson = json_decode($http->response);
            $http->ok = !is_null($http->responseJson);
        }

        return $http;
    }

    public static function fromRecordId($id, $dataConnector)
    {
        $toolConsumer = new ToolConsumer(null, $dataConnector);

        $toolConsumer->initialize();
        $toolConsumer->setRecordId($id);
        if (!$dataConnector->loadToolConsumer($toolConsumer)) {
            $toolConsumer->initialize();
        }

        return $toolConsumer;
    }

###
###  PRIVATE METHODS
###

    private function load($key, $autoEnable = false)
    {
        $this->key = $key;
        $ok = $this->dataConnector->loadToolConsumer($this);
        if (!$ok) {
            $this->enabled = $autoEnable;
        }

        return $ok;
    }

    private function addOAuthSignature($endpoint, $data, $method, $type)
    {
        $params = array();
        if (is_array($data)) {
            $params = $data;
            $params['oauth_callback'] = 'about:blank';
        }
// Check for query parameters which need to be included in the signature
        $queryString = parse_url($endpoint, PHP_URL_QUERY);
        $queryParams = OAuth\OAuthUtil::parse_parameters($queryString);
        $params = array_merge_recursive($queryParams, $params);

        if (!is_array($data)) {
// Calculate body hash
            switch ($this->signatureMethod) {
                case 'HMAC-SHA224':
                    $hash = base64_encode(hash('sha224', $data, TRUE));
                    break;
                case 'HMAC-SHA256':
                    $hash = base64_encode(hash('sha256', $data, TRUE));
                    break;
                case 'HMAC-SHA384':
                    $hash = base64_encode(hash('sha384', $data, TRUE));
                    break;
                case 'HMAC-SHA512':
                    $hash = base64_encode(hash('sha512', $data, TRUE));
                    break;
                default:
                    $hash = base64_encode(sha1($data, TRUE));
                    break;
            }
            $params['oauth_body_hash'] = $hash;
        }

// Add OAuth signature
        switch ($this->signatureMethod) {
            case 'HMAC-SHA224':
                $hmacMethod = new OAuth\OAuthSignatureMethod_HMAC_SHA224();
                break;
            case 'HMAC-SHA256':
                $hmacMethod = new OAuth\OAuthSignatureMethod_HMAC_SHA256();
                break;
            case 'HMAC-SHA384':
                $hmacMethod = new OAuth\OAuthSignatureMethod_HMAC_SHA384();
                break;
            case 'HMAC-SHA512':
                $hmacMethod = new OAuth\OAuthSignatureMethod_HMAC_SHA512();
                break;
            default:
                $hmacMethod = new OAuth\OAuthSignatureMethod_HMAC_SHA1();
                break;
        }
        $oauthConsumer = new OAuth\OAuthConsumer($this->key, $this->secret, null);
        $oauthReq = OAuth\OAuthRequest::from_consumer_and_token($oauthConsumer, null, $method, $endpoint, $params);
        $oauthReq->sign_request($hmacMethod, $oauthConsumer, null);
        if (!is_array($data)) {
            $header = $oauthReq->to_header();
            if (empty($data)) {
                if (!empty($type)) {
                    $header .= "\nAccept: {$type}";
                }
            } elseif (isset($type)) {
                $header .= "\nContent-Type: {$type}";
                $header .= "\nContent-Length: " . strlen($data);
            }
            return $header;
        } else {
            $params = $oauthReq->get_parameters();
            foreach ($queryParams as $key => $value) {
                if (!is_array($value)) {
                    if (!is_array($params[$key])) {
                        if ($params[$key] === $value) {
                            unset($params[$key]);
                        }
                    } else {
                        $params[$key] = array_diff($params[$key], array($value));
                    }
                } else {
                    foreach ($value as $element) {
                        $params[$key] = array_diff($params[$key], array($value));
                    }
                }
            }
            return $params;
        }
    }

}