DataConnector.php

<?php
 
namespace ceLTIc\LTI\DataConnector;
 
use ceLTIc\LTI\PlatformNonce;
use ceLTIc\LTI\Context;
use ceLTIc\LTI\ResourceLink;
use ceLTIc\LTI\ResourceLinkShare;
use ceLTIc\LTI\ResourceLinkShareKey;
use ceLTIc\LTI\Platform;
use ceLTIc\LTI\AccessToken;
use ceLTIc\LTI\UserResult;
use ceLTIc\LTI\Tool;
use ceLTIc\LTI\Util;
 
class DataConnector
{
 
    const PLATFORM_TABLE_NAME = 'lti2_consumer';
 
    const CONSUMER_TABLE_NAME = self::PLATFORM_TABLE_NAME;
 
    const CONTEXT_TABLE_NAME = 'lti2_context';
 
    const RESOURCE_LINK_TABLE_NAME = 'lti2_resource_link';
 
    const USER_RESULT_TABLE_NAME = 'lti2_user_result';
 
    const RESOURCE_LINK_SHARE_KEY_TABLE_NAME = 'lti2_share_key';
 
    const NONCE_TABLE_NAME = 'lti2_nonce';
 
    const ACCESS_TOKEN_TABLE_NAME = 'lti2_access_token';
 
    const TOOL_TABLE_NAME = 'lti2_tool';
 
    protected $db = null;
 
    protected $dbTableNamePrefix = '';
 
    protected $dateFormat = 'Y-m-d';
 
    protected $timeFormat = 'H:i:s';
 
    private static $memcache = null;
 
    protected function __construct($db, $dbTableNamePrefix = '')
    {
        $this->db = $db;
        $this->dbTableNamePrefix = $dbTableNamePrefix;
    }
 
    public static function useMemcache($host = null, $port = -1)
    {
        if (is_null($host)) {
            $useMemcache = !empty(self::$memcache);
        } else {
            $useMemcache = !empty($host);
            if ($useMemcache) {
                if (!class_exists('Memcache')) {
                    $useMemcache = false;
                    Util::logError("Memcache extension not installed");
                } else {
                    if ($port < 0) {
                        self::$memcache = memcache_connect($host);
                    } else {
                        self::$memcache = memcache_connect($host, $port);
                    }
                    $useMemcache = !empty(self::$memcache);
                    if (!$useMemcache) {
                        if ($port < 0) {
                            Util::logError("Unable to connect to memcache at {$host}");
                        } else {
                            Util::logError("Unable to connect to memcache at {$host}:{$port}");
                        }
                    }
                }
            }
            if (!$useMemcache) {
                self::$memcache = null;
            }
        }
 
        return $useMemcache;
    }
 
###
###  Platform methods
###
 
    public function loadToolConsumer($consumer)
    {
        Util::logDebug('Method ceLTIc\LTI\DataConnector\DataConnector::loadToolConsumer() has been deprecated; please use ceLTIc\LTI\DataConnector\DataConnector::loadPlatform() instead.',
            true);
        return $this->loadPlatform($consumer);
    }
 
    public function saveToolConsumer($consumer)
    {
        Util::logDebug('Method ceLTIc\LTI\DataConnector\DataConnector::saveToolConsumer() has been deprecated; please use ceLTIc\LTI\DataConnector\DataConnector::savePlatform() instead.',
            true);
        return $this->savePlatform($consumer);
    }
 
    public function deleteToolConsumer($consumer)
    {
        Util::logDebug('Method ceLTIc\LTI\DataConnector\DataConnector::deleteToolConsumer() has been deprecated; please use ceLTIc\LTI\DataConnector\DataConnector::deletePlatform() instead.',
            true);
        return $this->deletePlatform($consumer);
    }
 
    public function getToolConsumers()
    {
        Util::logDebug('Method ceLTIc\LTI\DataConnector\DataConnector::getToolConsumers() has been deprecated; please use ceLTIc\LTI\DataConnector\DataConnector::getPlatforms() instead.',
            true);
        return $this->getPlatforms();
    }
 
    public function loadPlatform($platform)
    {
        $platform->secret = 'secret';
        $platform->enabled = true;
        $now = time();
        $platform->created = $now;
        $platform->updated = $now;
 
        return true;
    }
 
    public function savePlatform($platform)
    {
        $platform->updated = time();
 
        return true;
    }
 
    public function deletePlatform($platform)
    {
        $platform->initialize();
 
        return true;
    }
 
    public function getPlatforms()
    {
        return array();
    }
 
###
###  Context methods
###
 
    public function loadContext($context)
    {
        $now = time();
        $context->created = $now;
        $context->updated = $now;
 
        return true;
    }
 
    public function saveContext($context)
    {
        $context->updated = time();
 
        return true;
    }
 
    public function deleteContext($context)
    {
        $context->initialize();
 
        return true;
    }
 
###
###  ResourceLink methods
###
 
    public function loadResourceLink($resourceLink)
    {
        $now = time();
        $resourceLink->created = $now;
        $resourceLink->updated = $now;
 
        return true;
    }
 
    public function saveResourceLink($resourceLink)
    {
        $resourceLink->updated = time();
 
        return true;
    }
 
    public function deleteResourceLink($resourceLink)
    {
        $resourceLink->initialize();
 
        return true;
    }
 
    public function getUserResultSourcedIDsResourceLink($resourceLink, $localOnly, $idScope)
    {
        return array();
    }
 
    public function getSharesResourceLink($resourceLink)
    {
        return array();
    }
 
###
###  PlatformNonce methods
###
 
    public function loadConsumerNonce($nonce)
    {
        Util::logDebug('Method ceLTIc\LTI\DataConnector\DataConnector::loadConsumerNonce() has been deprecated; please use ceLTIc\LTI\DataConnector\DataConnector::loadPlatformNonce() instead.',
            true);
        return $this->loadPlatformNonce($nonce);
    }
 
    public function saveConsumerNonce($nonce)
    {
        Util::logDebug('Method ceLTIc\LTI\DataConnector\DataConnector::saveConsumerNonce() has been deprecated; please use ceLTIc\LTI\DataConnector\DataConnector::savePlatformNonce() instead.',
            true);
        return $this->savePlatformNonce($nonce);
    }
 
    public function deleteConsumerNonce($nonce)
    {
        Util::logDebug('Method ceLTIc\LTI\DataConnector\DataConnector::deleteConsumerNonce() has been deprecated; please use ceLTIc\LTI\DataConnector\DataConnector::deletePlatformNonce() instead.',
            true);
        return $this->deletePlatformNonce($nonce);
    }
 
    public function loadPlatformNonce($nonce)
    {
        $ok = false;  // assume the nonce does not already exist
        if (!empty(self::$memcache)) {
            $id = $nonce->getPlatform()->getRecordId();
            $value = $nonce->getValue();
            $name = self::NONCE_TABLE_NAME . "_{$id}_{$value}";
            $ok = self::$memcache->get($name) !== false;
        }
 
        return $ok;
    }
 
    public function savePlatformNonce($nonce)
    {
        $ok = true;  // assume the nonce was saved
        if (!empty(self::$memcache)) {
            $ok = false;
            $id = $nonce->getPlatform()->getRecordId();
            $value = $nonce->getValue();
            $expires = $nonce->expires;
            $name = self::NONCE_TABLE_NAME . "_{$id}_{$value}";
            $current = self::$memcache->get($name);
            if ($current === false) {
                $ok = self::$memcache->set($name, true, 0, $expires);
            }
        }
 
        return $ok;
    }
 
    public function deletePlatformNonce($nonce)
    {
        $ok = true;  // assume the nonce was deleted
        if (!empty(self::$memcache)) {
            $id = $nonce->getPlatform()->getRecordId();
            $value = $nonce->getValue();
            $name = self::NONCE_TABLE_NAME . "_{$id}_{$value}";
            $ok = self::$memcache->get($name);
            if ($ok !== false) {
                $ok = self::$memcache->delete($name);
            }
        }
 
        return $ok;
    }
 
###
###  AccessToken methods
###
 
    public function loadAccessToken($accessToken)
    {
        $ok = false;  // assume the access token does not already exist
        if (!empty(self::$memcache)) {
            $id = $accessToken->getPlatform()->getRecordId();
            $value = $accessToken->token;
            $name = self::ACCESS_TOKEN_TABLE_NAME . "_{$id}_{$value}";
            $current = self::$memcache->get($name);
            $ok = is_array($current);
            if ($ok) {
                $accessToken->scopes = $current['scopes'];
                $accessToken->token = $current['token'];
                $accessToken->expires = $current['expires'];
                $accessToken->created = $current['created'];
                $accessToken->updated = $current['updated'];
            }
        }
 
        return $ok;
    }
 
    public function saveAccessToken($accessToken)
    {
        $ok = true;  // assume the access token was saved
        if (!empty(self::$memcache)) {
            $ok = false;
            $id = $accessToken->getPlatform()->getRecordId();
            $value = $accessToken->token;
            $expires = $accessToken->expires;
            $name = self::ACCESS_TOKEN_TABLE_NAME . "_{$id}_{$value}";
            $current = self::$memcache->get($name);
            if ($current === false) {
                $current = array(
                    'scopes' => $accessToken->scopes,
                    'token' => $value,
                    'expires' => $expires,
                    'created' => $accessToken->created,
                    'updated' => $accessToken->updated
                );
                $ok = self::$memcache->set($name, $current, 0, $expires);
            }
        }
 
        return $ok;
    }
 
###
###  ResourceLinkShareKey methods
###
 
    public function loadResourceLinkShareKey($shareKey)
    {
        return true;
    }
 
    public function saveResourceLinkShareKey($shareKey)
    {
        return true;
    }
 
    public function deleteResourceLinkShareKey($shareKey)
    {
        return true;
    }
 
###
###  UserResult methods
###
 
    public function loadUserResult($userresult)
    {
        $now = time();
        $userresult->created = $now;
        $userresult->updated = $now;
 
        return true;
    }
 
    public function saveUserResult($userresult)
    {
        $userresult->updated = time();
 
        return true;
    }
 
    public function deleteUserResult($userresult)
    {
        $userresult->initialize();
 
        return true;
    }
 
###
###  Tool methods
###
 
    public function loadTool($tool)
    {
        $tool->secret = 'secret';
        $tool->enabled = true;
        $now = time();
        $tool->created = $now;
        $tool->updated = $now;
 
        return true;
    }
 
    public function saveTool($tool)
    {
        $tool->updated = time();
 
        return true;
    }
 
    public function deleteTool($tool)
    {
        $tool->initialize();
 
        return true;
    }
 
    public function getTools()
    {
        return array();
    }
 
###
###  Other methods
###
 
    public static function getDataConnector($db = null, $dbTableNamePrefix = '', $type = '')
    {
        if (is_null($dbTableNamePrefix)) {
            $dbTableNamePrefix = '';
        }
        if (!is_null($db) && empty($type)) {
            if (is_object($db)) {
                $type = get_class($db);
            } elseif (is_resource($db)) {
                $type = strtok(get_resource_type($db), ' ');
            }
        }
        $type = strtolower($type);
        if ($type === 'pdo') {
            if ($db->getAttribute(\PDO::ATTR_DRIVER_NAME) === 'pgsql') {
                $type .= '_pgsql';
            } elseif ($db->getAttribute(\PDO::ATTR_DRIVER_NAME) === 'oci') {
                $type .= '_oci';
            }
        }
        if (!empty($type)) {
            $type = "DataConnector_{$type}";
        } else {
            $type = 'DataConnector';
        }
        $type = "\\ceLTIc\\LTI\\DataConnector\\{$type}";
        $dataConnector = new $type($db, $dbTableNamePrefix);
 
        return $dataConnector;
    }
 
    public static function getRandomString($length = 8)
    {
        Util::logDebug('Method ceLTIc\LTI\DataConnector::getRandomString() has been deprecated; please use ceLTIc\LTI\Util::getRandomString() instead.',
            true);
        return Util::getRandomString($length);
    }
 
    public function escape($value, $addQuotes = true)
    {
        return static::quoted($value, $addQuotes);
    }
 
    public static function quoted($value, $addQuotes = true)
    {
        if (is_null($value)) {
            $value = 'null';
        } else {
            $value = str_replace('\'', '\'\'', $value);
            if ($addQuotes) {
                $value = "'{$value}'";
            }
        }
 
        return $value;
    }
 
    protected function fixPlatformSettings($platform, $isSave)
    {
        if (!$isSave) {
            $platform->authorizationServerId = $platform->getSetting('_authorization_server_id', $platform->authorizationServerId);
            $platform->setSetting('_authorization_server_id');
            $platform->authenticationUrl = $platform->getSetting('_authentication_request_url', $platform->authenticationUrl);
            $platform->setSetting('_authentication_request_url');
            $platform->accessTokenUrl = $platform->getSetting('_oauth2_access_token_url', $platform->accessTokenUrl);
            $platform->setSetting('_oauth2_access_token_url');
            $platform->jku = $platform->getSetting('_jku', $platform->jku);
            $platform->setSetting('_jku');
            $platform->encryptionMethod = $platform->getSetting('_encryption_method', $platform->encryptionMethod);
            $platform->setSetting('_encryption_method');
            $platform->debugMode = $platform->getSetting('_debug', $platform->debugMode ? 'true' : 'false') === 'true';
            $platform->setSetting('_debug');
            if ($platform->debugMode) {
                Util::$logLevel = Util::LOGLEVEL_DEBUG;
            }
        } else {
            $platform->setSetting('_authorization_server_id',
                !empty($platform->authorizationServerId) ? $platform->authorizationServerId : null);
            $platform->setSetting('_authentication_request_url',
                !empty($platform->authenticationUrl) ? $platform->authenticationUrl : null);
            $platform->setSetting('_oauth2_access_token_url', !empty($platform->accessTokenUrl) ? $platform->accessTokenUrl : null);
            $platform->setSetting('_jku', !empty($platform->jku) ? $platform->jku : null);
            $platform->setSetting('_encryption_method', !empty($platform->encryptionMethod) ? $platform->encryptionMethod : null);
            $platform->setSetting('_debug', $platform->debugMode ? 'true' : null);
        }
    }
 
    protected function fixToolSettings($tool, $isSave)
    {
        if (!$isSave) {
            $tool->encryptionMethod = $tool->getSetting('_encryption_method', $tool->encryptionMethod);
            $tool->setSetting('_encryption_method');
            $tool->debugMode = $tool->getSetting('_debug', $tool->debugMode ? 'true' : 'false') === 'true';
            $tool->setSetting('_debug');
            if ($tool->debugMode) {
                Util::$logLevel = Util::LOGLEVEL_DEBUG;
            }
        } else {
            $tool->setSetting('_encryption_method', !empty($tool->encryptionMethod) ? $tool->encryptionMethod : null);
            $tool->setSetting('_debug', $tool->debugMode ? 'true' : null);
        }
    }
 
}