ff-ltitoolkit 0.1.0__py3-none-any.whl

ltitoolkit/core/contrib/flask/request.py

@@ -0,0 +1,40 @@
+from flask import request  # type: ignore
+from flask import session as flask_session
+from ltitoolkit.core.request import Request
+
+
+class FlaskRequest(Request):
+    _cookies = None
+    _request_data = None
+    _request_is_secure = None
+    _session = None
+
+    def __init__(
+        self, cookies=None, session=None, request_data=None, request_is_secure=None
+    ):
+        super().__init__()
+        self._cookies = request.cookies if cookies is None else cookies
+        self._session = flask_session if session is None else session
+        self._request_is_secure = (
+            request.is_secure if request_is_secure is None else request_is_secure
+        )
+
+        if request_data:
+            self._request_data = request_data
+
+    @property
+    def session(self):
+        return self._session
+
+    def get_param(self, key):
+        if self._request_data:
+            return self._request_data.get(key)
+        if request.method == "GET":
+            return request.args.get(key, None)
+        return request.form.get(key, None)
+
+    def get_cookie(self, key):
+        return self._cookies.get(key)
+
+    def is_secure(self):
+        return self._request_is_secure

ltitoolkit/core/contrib/flask/session.py

@@ -0,0 +1,5 @@
+from ltitoolkit.core.session import SessionService
+
+
+class FlaskSessionService(SessionService):
+    pass

ltitoolkit/core/cookie.py

@@ -0,0 +1,17 @@
+import typing as t
+from abc import ABCMeta, abstractmethod
+
+
+class CookieService:
+    __metaclass__ = ABCMeta
+    _cookie_prefix: str = "lti1p3"
+
+    @abstractmethod
+    def get_cookie(self, name: str) -> t.Optional[str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_cookie(
+        self, name: str, value: t.Union[str, int], exp: t.Optional[int] = 3600
+    ):
+        raise NotImplementedError

ltitoolkit/core/cookies_allowed_check.py

@@ -0,0 +1,151 @@
+from html import escape  # type: ignore
+import json
+import typing as t
+
+
+class CookiesAllowedCheckPage:
+    _params: t.Mapping[str, str] = {}
+    _protocol: str = "http"
+    _main_text: str = ""
+    _click_text: str = ""
+    _loading_text: str = ""
+
+    def __init__(
+        self,
+        params: t.Mapping[str, str],
+        protocol: str,
+        main_text: str,
+        click_text: str,
+        loading_text: str,
+        *args,
+        **kwargs
+    ):
+        # pylint: disable=unused-argument
+        self._params = params
+        self._protocol = protocol
+        self._main_text = main_text
+        self._click_text = click_text
+        self._loading_text = loading_text
+
+    def get_css_block(self) -> str:
+        css_block = """\
+        body {
+        font-family: Geneva, Arial, Helvetica, sans-serif;
+        }
+        """
+        return css_block
+
+    def get_js_block(self) -> str:
+        js_block = """\
+        var siteProtocol = '%s';
+        var urlParams = %s;
+        var htmlEntities = {
+            "&lt;": "<",
+            "&gt;": ">",
+            "&amp;": "&",
+            "&quot;": '"',
+            "&#x27;": "'"
+        };
+
+        function unescapeHtmlEntities(str) {
+            for (var htmlCode in htmlEntities) {
+                str = str.replace(new RegExp(htmlCode, "g"), htmlEntities[htmlCode]);
+            }
+            return str;
+        }
+
+        function getUpdatedUrl() {
+            var newSearchParams = [];
+            for (var key in urlParams) {
+                if (window.location.search.indexOf(key + '=') === -1) {
+                    newSearchParams.push(key + '=' + encodeURIComponent(unescapeHtmlEntities(urlParams[key])));
+                }
+            }
+            var searchParamsStr = newSearchParams.join('&');
+            if (window.location.search !== '') {
+                searchParamsStr = window.location.search + '&' + searchParamsStr;
+            } else {
+                searchParamsStr = '?' + searchParamsStr;
+            }
+            return window.location.protocol + '//' + window.location.hostname +
+                (window.location.port ? (":" + window.location.port) : "") +
+                window.location.pathname + searchParamsStr;
+        }
+
+        function displayLoadingBlock() {
+            document.getElementById("lti1p3-loading-msg").style.display = "block";
+        }
+
+        function displayWarningBlock() {
+            document.getElementById("lti1p3-warning-msg").style.display = "block";
+            var newTabLink = document.getElementById("lti1p3-new-tab-link");
+            var contentUrl = getUpdatedUrl();
+            newTabLink.onclick = function() {
+                window.open(contentUrl , '_blank');
+                newTabLink.parentNode.removeChild(newTabLink);
+            };
+        }
+
+        function checkCookiesAllowed() {
+            var cookie = "lti1p3_test_cookie=1; path=/";
+            if (siteProtocol === 'https') {
+                cookie = cookie + '; SameSite=None; secure';
+            }
+            document.cookie = cookie;
+            var res = document.cookie.indexOf("lti1p3_test_cookie") !== -1;
+            if (res) {
+                // remove test cookie and reload page
+                document.cookie = "lti1p3_test_cookie=1; expires=Thu, 01-Jan-1970 00:00:01 GMT";
+                displayLoadingBlock();
+                window.location.href = getUpdatedUrl();
+            } else {
+                displayWarningBlock();
+            }
+        }
+
+        document.addEventListener("DOMContentLoaded", checkCookiesAllowed);
+        """
+        # pylint: disable=deprecated-method
+        js_block = js_block % (
+            self._protocol,
+            json.dumps({k: escape(v, True) for k, v in self._params.items()}),
+        )
+        return js_block
+
+    def get_header_block(self) -> str:
+        return ""
+
+    def get_html(self) -> str:
+        html = """\
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+        <title></title>
+        <meta charset="UTF-8">
+        <style type="text/css">
+        {css_block}
+        </style>
+        <script type="text/javascript">
+        {js_block}
+        </script>
+        </head>
+        <body>
+        <div id="lti1p3-loading-msg" style="display: none;">
+        {loading_text}
+        </div>
+        <div id="lti1p3-warning-msg" style="display: none;">
+        {header_block}
+        <p><strong>{main_text}</strong> <a href="javascript: void(0);" id="lti1p3-new-tab-link">{click_text}</a></p>
+        </div>
+        </body>
+        </html>
+        """
+        html = html.format(
+            css_block=self.get_css_block(),
+            js_block=self.get_js_block(),
+            loading_text=self._loading_text,
+            header_block=self.get_header_block(),
+            main_text=self._main_text,
+            click_text=self._click_text,
+        )
+        return html

ltitoolkit/core/course_groups.py

@@ -0,0 +1,115 @@
+import typing as t
+import typing_extensions as te
+from .utils import add_param_to_url
+from .service_connector import ServiceConnector
+
+TGroupsServiceData = te.TypedDict(
+    "TGroupsServiceData",
+    {
+        # Required data
+        "context_groups_url": str,
+        "scope": t.List[
+            te.Literal[
+                "https://purl.imsglobal.org/spec/lti-gs/scope/contextgroup.readonly"
+            ]
+        ],
+        "service_versions": t.List[str],
+        # Optional data
+        "context_group_sets_url": str,
+    },
+    total=False,
+)
+
+TGroup = te.TypedDict(
+    "TGroup",
+    {
+        # Required data
+        "id": t.Union[str, int],
+        "name": str,
+        # Optional data
+        "tag": str,
+        "set_id": t.Union[str, int],
+    },
+    total=False,
+)
+
+TSet = te.TypedDict(
+    "TSet",
+    {
+        # Required data
+        "id": t.Union[str, int],
+        "name": str,
+        # Optional data
+        "groups": t.List[TGroup],
+    },
+    total=False,
+)
+
+
+class CourseGroupsService:
+    _service_connector: ServiceConnector
+    _service_data: TGroupsServiceData
+
+    def __init__(
+        self,
+        service_connector: ServiceConnector,
+        groups_service_data: TGroupsServiceData,
+    ):
+        self._service_connector = service_connector
+        self._service_data = groups_service_data
+
+    def get_page(
+        self, data_url: str, data_key: str = "groups"
+    ) -> t.Tuple[list, t.Optional[str]]:
+        """
+        Get one page with the groups/sets.
+
+        :param data_url
+        :param data_key
+        :return: tuple in format: (list with data items, next page url)
+        """
+        data = self._service_connector.make_service_request(
+            self._service_data["scope"],
+            data_url,
+            accept="application/vnd.ims.lti-gs.v1.contextgroupcontainer+json",
+        )
+        data_body = t.cast(t.Any, data.get("body", {}))
+        return data_body.get(data_key, []), data["next_page_url"]
+
+    def get_groups(self, user_id=None):
+        groups_res_lst = []
+        groups_url = self._service_data.get("context_groups_url")
+        if user_id:
+            groups_url = add_param_to_url(groups_url, "user_id", user_id)
+
+        while groups_url:
+            groups, groups_url = self.get_page(groups_url, data_key="groups")
+            groups_res_lst.extend(groups)
+
+        return groups_res_lst
+
+    def has_sets(self):
+        return "context_group_sets_url" in self._service_data
+
+    def get_sets(self, include_groups=False):
+        sets_res_lst = []
+        sets_url = self._service_data.get("context_group_sets_url")
+
+        while sets_url:
+            sets, sets_url = self.get_page(sets_url, data_key="sets")
+            sets_res_lst.extend(sets)
+
+        if include_groups and sets_res_lst:
+            set_id_to_index = {}
+            for i, s in enumerate(sets_res_lst):
+                set_id_to_index[s["id"]] = i
+                sets_res_lst[i]["groups"] = []
+
+            groups = self.get_groups()
+            for group in groups:
+                set_id = group.get("set_id")
+                if set_id and set_id in set_id_to_index:
+                    index = set_id_to_index[set_id]
+                    sets_res_lst[index]["groups"].append(group)
+
+        return sets_res_lst

ltitoolkit/core/deep_link.py

@@ -0,0 +1,100 @@
+import time
+import typing as t
+import uuid
+
+import jwt  # type: ignore
+import typing_extensions as te
+from .deep_link_resource import DeepLinkResource
+from .registration import Registration
+
+TDeepLinkData = te.TypedDict(
+    "TDeepLinkData",
+    {
+        # Required data:
+        "deep_link_return_url": str,
+        "accept_types": t.List[te.Literal["link", "ltiResourceLink"]],
+        "accept_presentation_document_targets": t.List[
+            te.Literal["iframe", "window", "embed"]
+        ],
+        # Optional data
+        "accept_multiple": t.Union[bool, te.Literal["true", "false"]],
+        "auto_create": t.Union[bool, te.Literal["true", "false"]],
+        "title": str,
+        "text": str,
+        "data": object,
+    },
+    total=False,
+)
+
+
+class DeepLink:
+    _registration: Registration
+    _deployment_id: str
+    _deep_link_settings: TDeepLinkData
+
+    def __init__(
+        self,
+        registration: Registration,
+        deployment_id: str,
+        deep_link_settings: TDeepLinkData,
+    ):
+        self._registration = registration
+        self._deployment_id = deployment_id
+        self._deep_link_settings = deep_link_settings
+
+    def _generate_nonce(self):
+        return uuid.uuid4().hex + uuid.uuid1().hex
+
+    def get_message_jwt(
+        self, resources: t.Sequence[DeepLinkResource]
+    ) -> t.Dict[str, object]:
+        message_jwt = {
+            "iss": self._registration.get_client_id(),
+            "aud": [self._registration.get_issuer()],
+            "exp": int(time.time()) + 600,
+            "iat": int(time.time()),
+            "nonce": "nonce-" + self._generate_nonce(),
+            "https://purl.imsglobal.org/spec/lti/claim/deployment_id": self._deployment_id,
+            "https://purl.imsglobal.org/spec/lti/claim/message_type": "LtiDeepLinkingResponse",
+            "https://purl.imsglobal.org/spec/lti/claim/version": "1.3.0",
+            "https://purl.imsglobal.org/spec/lti-dl/claim/content_items": [
+                r.to_dict() for r in resources
+            ],
+            "https://purl.imsglobal.org/spec/lti-dl/claim/data": self._deep_link_settings.get(
+                "data"
+            ),
+        }
+        return message_jwt
+
+    def encode_jwt(self, message):
+        headers = None
+        kid = self._registration.get_kid()
+        if kid:
+            headers = {"kid": kid}
+        encoded_jwt = jwt.encode(
+            message,
+            self._registration.get_tool_private_key(),
+            algorithm="RS256",
+            headers=headers,
+        )
+        if isinstance(encoded_jwt, bytes):
+            return encoded_jwt.decode("utf-8")
+        return encoded_jwt
+
+    def get_response_jwt(self, resources: t.Sequence[DeepLinkResource]) -> str:
+        message_jwt = self.get_message_jwt(resources)
+        return self.encode_jwt(message_jwt)
+
+    def get_response_form_html(self, jwt_val: str) -> str:
+        deep_link_return_url = self._deep_link_settings["deep_link_return_url"]
+        html = (
+            f'<form id="lti13_deep_link_auto_submit" action="{deep_link_return_url}" method="POST">'
+            f'<input type="hidden" name="JWT" value="{jwt_val}" /></form>'
+            f"<script type=\"text/javascript\">document.getElementById('lti13_deep_link_auto_submit').submit();"
+            f"</script>"
+        )
+        return html
+
+    def output_response_form(self, resources: t.List[DeepLinkResource]) -> str:
+        jwt_val = self.get_response_jwt(resources)
+        return self.get_response_form_html(jwt_val)

ltitoolkit/core/deep_link_resource.py

@@ -0,0 +1,96 @@
+import typing as t
+from .lineitem import LineItem
+
+
+class DeepLinkResource:
+    _type: str = "ltiResourceLink"
+    _title: t.Optional[str] = None
+    _url: t.Optional[str] = None
+    _lineitem: t.Optional[LineItem] = None
+    _custom_params: t.Mapping[str, str] = {}
+    _target: str = "iframe"
+    _icon_url: t.Optional[str] = None
+
+    def get_type(self):
+        return self._type
+
+    def set_type(self, value: str) -> "DeepLinkResource":
+        self._type = value
+        return self
+
+    def get_title(self) -> t.Optional[str]:
+        return self._title
+
+    def set_title(self, value: str) -> "DeepLinkResource":
+        self._title = value
+        return self
+
+    def get_url(self) -> t.Optional[str]:
+        return self._url
+
+    def set_url(self, value: str) -> "DeepLinkResource":
+        self._url = value
+        return self
+
+    def get_lineitem(self) -> t.Optional[LineItem]:
+        return self._lineitem
+
+    def set_lineitem(self, value: LineItem) -> "DeepLinkResource":
+        self._lineitem = value
+        return self
+
+    def get_custom_params(self) -> t.Mapping[str, str]:
+        return self._custom_params
+
+    def set_custom_params(self, value: t.Mapping[str, str]) -> "DeepLinkResource":
+        self._custom_params = value
+        return self
+
+    def get_target(self) -> str:
+        return self._target
+
+    def set_target(self, value: str) -> "DeepLinkResource":
+        self._target = value
+        return self
+
+    def get_icon_url(self) -> t.Optional[str]:
+        return self._icon_url
+
+    def set_icon_url(self, value: str) -> "DeepLinkResource":
+        self._icon_url = value
+        return self
+
+    def to_dict(self) -> t.Dict[str, object]:
+        res: t.Dict[str, object] = {
+            "type": self._type,
+            "title": self._title,
+            "url": self._url,
+            "custom": self._custom_params,
+        }
+        if self._lineitem:
+            line_item: t.Dict[str, object] = {
+                "scoreMaximum": self._lineitem.get_score_maximum(),
+            }
+
+            label = self._lineitem.get_label()
+            if label:
+                line_item["label"] = label
+
+            resource_id = self._lineitem.get_resource_id()
+            if resource_id:
+                line_item["resourceId"] = resource_id
+
+            tag = self._lineitem.get_tag()
+            if tag:
+                line_item["tag"] = tag
+
+            submission_review = self._lineitem.get_submission_review()
+            if submission_review:
+                line_item["submissionReview"] = submission_review
+
+            res["lineItem"] = line_item
+
+        if self._icon_url:
+            res["icon"] = {"url": self._icon_url}
+
+        return res

ltitoolkit/core/deployment.py

@@ -0,0 +1,13 @@
+import typing as t
+
+
+class Deployment:
+
+    _deployment_id: t.Optional[str] = None
+
+    def get_deployment_id(self) -> t.Optional[str]:
+        return self._deployment_id
+
+    def set_deployment_id(self, deployment_id: str) -> "Deployment":
+        self._deployment_id = deployment_id
+        return self

ltitoolkit/core/exception.py

@@ -0,0 +1,16 @@
+import requests
+
+
+class LtiException(Exception):
+    pass
+
+
+class OIDCException(Exception):
+    pass
+
+
+class LtiServiceException(LtiException):
+    def __init__(self, response: requests.Response):
+        msg = f"HTTP response [{response.url}]: {str(response.status_code)} - {response.text}"
+        super().__init__(msg)
+        self.response = response