openedx-next-tutor 1.0.0__py3-none-any.whl

nex_chat_tutor/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

nex_chat_tutor/patches/mfe-dockerfile-post-npm-install

@@ -0,0 +1,5 @@
+# Install frontend-plugin-framework for MFE Plugin Slots support
+RUN npm install @openedx/frontend-plugin-framework@^1.7.0 --save
+
+# Copy the prebuilt Nex Chat widget plugin into the MFE app root
+COPY nex-chat-plugin.js /openedx/app/nex-chat-plugin.js

nex_chat_tutor/patches/mfe-env-config-buildtime-definitions

@@ -0,0 +1,38 @@
+// Nex Chat widget mounted through the Frontend Plugin Framework
+const NexChatWidgetInjector = () => {
+  React.useEffect(() => {
+    let cleanup;
+    let disposed = false;
+
+    if (!{{ NEX_CHAT_ENABLED | tojson }}) {
+      return undefined;
+    }
+
+    window.NEX_CHAT_API_BASE_URL = {{ NEX_CHAT_API_BASE_URL | tojson }};
+    window.NEX_CHAT_WS_URL = {{ NEX_CHAT_WS_URL | tojson }};
+    window.NEX_CHAT_ASSERTION_URL = {{ NEX_CHAT_ASSERTION_URL | tojson }};
+
+    import('./nex-chat-plugin.js')
+      .then((mod) => {
+        if (disposed) {
+          return;
+        }
+        if (typeof mod.default !== 'function') {
+          throw new TypeError('Nex Chat bundle does not export a mount function');
+        }
+        cleanup = mod.default();
+      })
+      .catch((error) => {
+        console.error('NexChatWidget: failed to load widget bundle', error);
+      });
+
+    return () => {
+      disposed = true;
+      if (typeof cleanup === 'function') {
+        cleanup();
+      }
+    };
+  }, []);
+
+  return null;
+};

nex_chat_tutor/patches/mfe-env-config-buildtime-imports

@@ -0,0 +1 @@
+import React from 'react';

nex_chat_tutor/patches/openedx-dockerfile-post-git-checkout

@@ -0,0 +1,8 @@
+# Install the Nex Chat bundle and its legacy learner-dashboard mount.
+COPY nex-chat-plugin.js /openedx/edx-platform/lms/static/nex-chat-plugin.js
+COPY nex-chat-dashboard-loader.js /openedx/edx-platform/lms/static/nex-chat-dashboard-loader.js
+COPY nex-chat-dashboard.html /openedx/edx-platform/lms/templates/nex-chat-dashboard.html
+COPY nex-chat-lms.py /openedx/edx-platform/nex_chat_lms.py
+COPY nex-chat-lms-urls.py /openedx/edx-platform/nex_chat_lms_urls.py
+COPY nex-chat-dashboard.patch /tmp/nex-chat-dashboard.patch
+RUN git apply /tmp/nex-chat-dashboard.patch

nex_chat_tutor/patches/openedx-lms-common-settings

@@ -0,0 +1,9 @@
+ROOT_URLCONF = "nex_chat_lms_urls"
+NEX_CHAT_ENABLED = {{ "True" if NEX_CHAT_ENABLED else "False" }}
+NEX_CHAT_ASSERTION_ISSUER = {{ NEX_CHAT_ASSERTION_ISSUER | tojson }}
+NEX_CHAT_ASSERTION_AUDIENCE = {{ NEX_CHAT_ASSERTION_AUDIENCE | tojson }}
+NEX_CHAT_ASSERTION_KEY_ID = {{ NEX_CHAT_ASSERTION_KEY_ID | tojson }}
+NEX_CHAT_ASSERTION_PRIVATE_KEY = {{ NEX_CHAT_ASSERTION_PRIVATE_KEY | tojson }}
+NEX_CHAT_ASSERTION_JWKS = {{ NEX_CHAT_ASSERTION_JWKS | tojson }}
+NEX_CHAT_ASSERTION_ALLOWED_ORIGINS = {{ NEX_CHAT_ASSERTION_ALLOWED_ORIGINS | tojson }}
+CSRF_TRUSTED_ORIGINS += NEX_CHAT_ASSERTION_ALLOWED_ORIGINS

nex_chat_tutor/plugin.py

@@ -0,0 +1,67 @@
+import os
+from glob import glob
+
+from tutor import hooks
+from tutormfe.hooks import PLUGIN_SLOTS
+
+
+PLUGIN_DIR = os.path.dirname(__file__)
+
+hooks.Filters.CONFIG_DEFAULTS.add_items(
+    [
+        ("NEX_CHAT_ENABLED", True),
+        ("NEX_CHAT_API_BASE_URL", "http://local.openedx.io:3010/api/v1"),
+        ("NEX_CHAT_WS_URL", "ws://local.openedx.io:3010/api/v1/ws"),
+        ("NEX_CHAT_ASSERTION_URL", "http://local.openedx.io:8000/nex-chat/assertion"),
+        ("NEX_CHAT_ASSERTION_ISSUER", "http://local.openedx.io:8000"),
+        ("NEX_CHAT_ASSERTION_AUDIENCE", "nex-chat"),
+        ("NEX_CHAT_ASSERTION_KEY_ID", "nex-chat"),
+        ("NEX_CHAT_ASSERTION_PRIVATE_KEY", ""),
+        ("NEX_CHAT_ASSERTION_JWKS", "{\"keys\": []}"),
+        ("NEX_CHAT_ASSERTION_ALLOWED_ORIGINS", ["http://apps.local.openedx.io:2000"]),
+    ]
+)
+hooks.Filters.ENV_TEMPLATE_TARGETS.add_items(
+    [
+        ("nex-chat-plugin.js", "plugins/mfe/build/mfe"),
+        ("nex-chat-plugin.js", "build/openedx"),
+        ("nex-chat-dashboard.html", "build/openedx"),
+        ("nex-chat-dashboard-loader.js", "build/openedx"),
+        ("nex-chat-dashboard.patch", "build/openedx"),
+        ("nex-chat-lms.py", "build/openedx"),
+        ("nex-chat-lms-urls.py", "build/openedx"),
+    ]
+)
+
+
+NEX_CHAT_SLOT_CONFIG = """
+{
+  op: PLUGIN_OPERATIONS.Insert,
+  widget: {
+    id: 'nexChatWidget',
+    type: DIRECT_PLUGIN,
+    priority: 99,
+    RenderWidget: NexChatWidgetInjector,
+  },
+}
+"""
+
+PLUGIN_SLOTS.add_items(
+    [
+        ("learner-dashboard", "footer_slot", NEX_CHAT_SLOT_CONFIG),
+        ("learning", "footer_slot", NEX_CHAT_SLOT_CONFIG),
+    ]
+)
+
+@hooks.Filters.ENV_TEMPLATE_ROOTS.add()
+def _add_template_roots(roots):
+    roots.append(os.path.join(PLUGIN_DIR, "templates"))
+    return roots
+
+
+
+
+for path in glob(os.path.join(PLUGIN_DIR, "patches", "*")):
+    with open(path, encoding="utf-8") as patch_file:
+        patch_name = os.path.basename(path)
+        hooks.Filters.ENV_PATCHES.add_item((patch_name, patch_file.read()))

nex_chat_tutor/templates/nex-chat-dashboard-loader.js

@@ -0,0 +1,20 @@
+const configuration = document.getElementById('nex-chat-config');
+
+if (!configuration) {
+  throw new Error('Nex Chat dashboard configuration is unavailable');
+}
+
+window.NEX_CHAT_API_BASE_URL = configuration.dataset.apiBaseUrl;
+window.NEX_CHAT_WS_URL = configuration.dataset.wsUrl;
+window.NEX_CHAT_ASSERTION_URL = configuration.dataset.assertionUrl;
+
+import('./nex-chat-plugin.js')
+  .then((module) => {
+    if (typeof module.default !== 'function') {
+      throw new TypeError('Nex Chat bundle does not export a mount function');
+    }
+    module.default();
+  })
+  .catch((error) => {
+    console.error('NexChatWidget: failed to load widget bundle', error);
+  });

nex_chat_tutor/templates/nex-chat-dashboard.html

@@ -0,0 +1,11 @@
+{% if NEX_CHAT_ENABLED %}
+<%namespace name="static" file="static_content.html"/>
+<div
+  id="nex-chat-config"
+  hidden
+  data-api-base-url={{ NEX_CHAT_API_BASE_URL | tojson }}
+  data-ws-url={{ NEX_CHAT_WS_URL | tojson }}
+  data-assertion-url={{ NEX_CHAT_ASSERTION_URL | tojson }}
+></div>
+<script type="module" src="${static.url('nex-chat-dashboard-loader.js')}"></script>
+{% endif %}

nex_chat_tutor/templates/nex-chat-dashboard.patch

@@ -0,0 +1,11 @@
+diff --git a/lms/templates/dashboard.html b/lms/templates/dashboard.html
+--- a/lms/templates/dashboard.html
++++ b/lms/templates/dashboard.html
+@@ -42,6 +42,7 @@
+   <script src="${static.url('js/commerce/credit.js')}"></script>
+   <script type="text/javascript" src="${static.url('js/learner_dashboard/certificate_api.js')}"></script>
+   <%static:js group='dashboard'/>
++  <%include file="nex-chat-dashboard.html"/>
+   <script type="text/javascript">
+     $(document).ready(function() {
+       edx.dashboard.legacy.init({

nex_chat_tutor/templates/nex-chat-lms-urls.py

@@ -0,0 +1,4 @@
+from lms.urls import urlpatterns as lms_urlpatterns
+from nex_chat_lms import urlpatterns as nex_chat_urlpatterns
+
+urlpatterns = [*lms_urlpatterns, *nex_chat_urlpatterns]

nex_chat_tutor/templates/nex-chat-lms.py

@@ -0,0 +1,158 @@
+import json
+import time
+import uuid
+
+import jwt
+from django.conf import settings
+from django.http import HttpResponseNotAllowed, JsonResponse
+from django.http.request import split_domain_port
+from django.middleware.csrf import get_token
+from django.urls import path
+from django.utils.cache import patch_vary_headers
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.keys import CourseKey
+from common.djangoapps.student.roles import CourseStaffRole
+from common.djangoapps.student.models import CourseEnrollment
+
+
+MAX_REQUEST_BYTES = 4096
+ASSERTION_LIFETIME_SECONDS = 300
+
+
+def _allowed_origins():
+    configured = settings.NEX_CHAT_ASSERTION_ALLOWED_ORIGINS
+    if isinstance(configured, str):
+        try:
+            configured = json.loads(configured)
+        except json.JSONDecodeError:
+            return set()
+    if not isinstance(configured, list):
+        return set()
+    return {origin for origin in configured if isinstance(origin, str)}
+
+
+def _cors_response(response, request):
+    origin = request.headers.get("Origin")
+    if origin and origin in _allowed_origins():
+        response["Access-Control-Allow-Origin"] = origin
+        response["Access-Control-Allow-Credentials"] = "true"
+        response["Access-Control-Allow-Headers"] = "Content-Type, X-CSRFToken"
+        response["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
+        patch_vary_headers(response, ("Origin",))
+    return response
+
+
+def _json_error(request, message, status):
+    return _cors_response(JsonResponse({"error": message}, status=status), request)
+
+
+def _request_course_id(request):
+    if len(request.body) > MAX_REQUEST_BYTES:
+        raise ValueError("request is too large")
+    payload = json.loads(request.body or b"{}")
+    if not isinstance(payload, dict) or set(payload) - {"course_id"}:
+        raise ValueError("request is invalid")
+    course_id = payload.get("course_id")
+    if course_id is not None and not isinstance(course_id, str):
+        raise ValueError("course ID is invalid")
+    return course_id
+
+
+def _course_role(user, course_id):
+    if not course_id.startswith("course-v1:"):
+        raise ValueError("course ID is invalid")
+    try:
+        course_key = CourseKey.from_string(course_id)
+    except InvalidKeyError as exc:
+        raise ValueError("course ID is invalid") from exc
+    if str(course_key) != course_id:
+        raise ValueError("course ID is invalid")
+
+    is_staff = CourseStaffRole(course_key).has_user(user)
+    if not is_staff and not CourseEnrollment.is_enrolled(user, course_key):
+        raise PermissionError("user is not enrolled in this course")
+    return "staff" if is_staff else "student"
+
+
+def _assertion_configuration():
+    private_key = settings.NEX_CHAT_ASSERTION_PRIVATE_KEY
+    key_id = settings.NEX_CHAT_ASSERTION_KEY_ID
+    if not isinstance(private_key, str) or not private_key or not isinstance(key_id, str) or not key_id:
+        raise RuntimeError("Nex Chat assertion signing is not configured")
+    private_key = private_key.strip()
+    private_key = private_key.replace(
+        "-----BEGIN PRIVATE KEY-----",
+        "-----BEGIN PRIVATE KEY-----\n",
+    ).replace(
+        "-----END PRIVATE KEY-----",
+        "\n-----END PRIVATE KEY-----",
+    )
+    return private_key, key_id
+
+
+def assertion(request):
+    if request.method == "OPTIONS":
+        return _cors_response(JsonResponse({}, status=204), request)
+    if request.method not in {"GET", "POST"}:
+        return HttpResponseNotAllowed(["GET", "POST", "OPTIONS"])
+    if not settings.NEX_CHAT_ENABLED:
+        return _json_error(request, "not found", 404)
+    if not request.user.is_authenticated:
+        return _json_error(request, "authentication required", 401)
+    if request.method == "GET":
+        return _cors_response(JsonResponse({"csrf_token": get_token(request)}), request)
+
+    try:
+        course_id = _request_course_id(request)
+        role = _course_role(request.user, course_id) if course_id else (
+            "staff" if request.user.is_staff else "student"
+        )
+        private_key, key_id = _assertion_configuration()
+    except (ValueError, json.JSONDecodeError) as exc:
+        return _json_error(request, str(exc), 400)
+    except PermissionError as exc:
+        return _json_error(request, str(exc), 403)
+    except RuntimeError:
+        return _json_error(request, "chat assertion service is unavailable", 503)
+
+    now = int(time.time())
+    site, _ = split_domain_port(request.get_host())
+    claims = {
+        "iss": settings.NEX_CHAT_ASSERTION_ISSUER,
+        "aud": settings.NEX_CHAT_ASSERTION_AUDIENCE,
+        "sub": str(request.user.id),
+        "username": request.user.get_username(),
+        "email": request.user.email or None,
+        "roles": [role],
+        "site": site.lower(),
+        "course_id": course_id,
+        "iat": now,
+        "exp": now + ASSERTION_LIFETIME_SECONDS,
+        "jti": str(uuid.uuid4()),
+    }
+    signed_assertion = jwt.encode(
+        claims,
+        private_key,
+        algorithm="RS256",
+        headers={"kid": key_id, "typ": "JWT"},
+    )
+    return _cors_response(JsonResponse({"assertion": signed_assertion}), request)
+
+
+def jwks(request):
+    if request.method != "GET":
+        return HttpResponseNotAllowed(["GET"])
+    try:
+        configured = settings.NEX_CHAT_ASSERTION_JWKS
+        value = json.loads(configured) if isinstance(configured, str) else configured
+        if not isinstance(value, dict) or not isinstance(value.get("keys"), list):
+            raise ValueError
+    except (ValueError, json.JSONDecodeError):
+        return JsonResponse({"error": "chat signing keys are unavailable"}, status=503)
+    return JsonResponse(value)
+
+
+urlpatterns = [
+    path("nex-chat/assertion", assertion, name="nex-chat-assertion"),
+    path(".well-known/nex-chat/jwks.json", jwks, name="nex-chat-jwks"),
+]