lti changes

src/graderservice/graderservice/graderservice.py

@@ -35,9 +35,6 @@
     "ILLUMIDESK_NB_EXCHANGE_MNT_ROOT", "/illumidesk-nb-exchange"
 )
 GRADER_PVC = os.environ.get("GRADER_PVC", "grader-setup-pvc")
-GRADER_EXCHANGE_SHARED_PVC = os.environ.get(
-    "GRADER_SHARED_PVC", "exchange-shared-volume"
-)
 
 # user UI and GID to use within the grader container
 NB_UID = os.environ.get("NB_UID", 10001)
@@ -184,7 +181,7 @@ def _create_nbgrader_files(self):
         grader_home_nbconfig_content = NBGRADER_HOME_CONFIG_TEMPLATE.format(
             grader_name=self.grader_name,
             course_id=self.course_id,
-            db_url=f"postgresql://{nbgrader_db_user}:{nbgrader_db_password}@{nbgrader_db_host}:5432/{self.org_name}_{self.course_id}",
+            db_url=f"postgresql://{nbgrader_db_user}:{nbgrader_db_password}@{nbgrader_db_host}:5432/{nbgrader_db_name}",
         )
         grader_nbconfig_path.write_text(grader_home_nbconfig_content)
         # Write the nbgrader_config.py file at grader home directory
@@ -278,7 +275,7 @@ def _create_deployment_object(self):
                 ),
                 client.V1VolumeMount(
                     mount_path="/srv/nbgrader/exchange",
-                    name=GRADER_EXCHANGE_SHARED_PVC,
+                    name=GRADER_PVC,
                     sub_path=sub_path_exchange,
                 ),
             ],
@@ -298,12 +295,6 @@ def _create_deployment_object(self):
                             claim_name=GRADER_PVC
                         ),
                     ),
-                    client.V1Volume(
-                        name=GRADER_EXCHANGE_SHARED_PVC,
-                        persistent_volume_claim=client.V1PersistentVolumeClaimVolumeSource(
-                            claim_name=GRADER_EXCHANGE_SHARED_PVC
-                        ),
-                    ),
                 ],
             ),
         )

src/illumidesk/illumidesk/apis/nbgrader_service.py

@@ -5,8 +5,6 @@
 from nbgrader.api import Course
 from nbgrader.api import Gradebook
 from nbgrader.api import InvalidEntry
-from sqlalchemy_utils import create_database
-from sqlalchemy_utils import database_exists
 
 from illumidesk.authenticators.utils import LTIUtils
 
@@ -18,24 +16,23 @@
 nbgrader_db_port = os.environ.get("POSTGRES_NBGRADER_PORT") or 5432
 nbgrader_db_password = os.environ.get("POSTGRES_NBGRADER_PASSWORD")
 nbgrader_db_user = os.environ.get("POSTGRES_NBGRADER_USER")
+nbgrader_db_name = os.environ.get("POSTGRES_NBGRADER_DATABASE")
 mnt_root = os.environ.get("ILLUMIDESK_MNT_ROOT", "/illumidesk-courses")
 
 org_name = os.environ.get("ORGANIZATION_NAME") or "my-org"
 
 if not org_name:
     raise EnvironmentError("ORGANIZATION_NAME env-var is not set")
 
+CAMPUS_ID = os.environ.get("CAMPUS_ID")
+if not CAMPUS_ID:
+    raise EnvironmentError("CAMPUS_ID env-var is not set")
 
-def nbgrader_format_db_url(course_id: str) -> str:
+def nbgrader_format_db_url() -> str:
     """
-    Returns the nbgrader database url with the format: <org_name>_<course-id>
-
-    Args:
-      course_id: the course id (usually associated with the course label) from which the launch was initiated.
+    Returns the nbgrader database url
     """
-    course_id = LTIUtils().normalize_string(course_id)
-    database_name = f"{org_name}_{course_id}"
-    return f"postgresql://{nbgrader_db_user}:{nbgrader_db_password}@{nbgrader_db_host}:{nbgrader_db_port}/{database_name}"
+    return f"postgresql://{nbgrader_db_user}:{nbgrader_db_password}@{nbgrader_db_host}:{nbgrader_db_port}/{nbgrader_db_name}"
 
 
 class NbGraderServiceHelper:
@@ -51,7 +48,7 @@ class NbGraderServiceHelper:
       database_name: the database name
     """
 
-    def __init__(self, course_id: str, check_database_exists: bool = False):
+    def __init__(self, course_id: str):
         if not course_id:
             raise ValueError("course_id missing")
 
@@ -62,56 +59,48 @@ def __init__(self, course_id: str, check_database_exists: bool = False):
         self.uid = int(os.environ.get("NB_GRADER_UID") or "10001")
         self.gid = int(os.environ.get("NB_GRADER_GID") or "100")
 
-        self.db_url = nbgrader_format_db_url(course_id)
-        self.database_name = f"{org_name}_{self.course_id}"
-        if check_database_exists:
-            self.create_database_if_not_exists()
-
-    def create_database_if_not_exists(self) -> None:
-        """Creates a new database if it doesn't exist"""
-        conn_uri = nbgrader_format_db_url(self.course_id)
-
-        if not database_exists(conn_uri):
-            logger.debug("db not exist, create database")
-            create_database(conn_uri)
+        self.db_url = nbgrader_format_db_url()
 
-    def add_user_to_nbgrader_gradebook(self, username: str, lms_user_id: str) -> None:
+    def add_user_to_nbgrader_gradebook(self, email: str, external_user_id: str, source: str, source_type: str, role: str) -> None:
         """
         Adds a user to the nbgrader gradebook database for the course.
 
         Args:
-            username: The user's username
-            lms_user_id: The user's id on the LMS
+            email: The user's email
+            external_user_id: The user's id on the external system
+            source: source from where user was authenticated
+            source_type: source_type
         Raises:
             InvalidEntry: when there was an error adding the user to the database
         """
-        if not username:
-            raise ValueError("username missing")
-        if not lms_user_id:
-            raise ValueError("lms_user_id missing")
+        if not email:
+            raise ValueError("email missing")
+        if not external_user_id:
+            raise ValueError("external_user_id missing")
 
-        with Gradebook(self.db_url, course_id=self.course_id) as gb:
+        with Gradebook(self.db_url, course_id=self.course_id, campus_id=CAMPUS_ID) as gb:
             try:
-                gb.update_or_create_student(username, lms_user_id=lms_user_id)
+                user = gb.update_or_create_user_by_email(email, role=role, external_user_id=external_user_id, source=source, source_type=source_type)
                 logger.debug(
-                    "Added user %s with lms_user_id %s to gradebook"
-                    % (username, lms_user_id)
+                    "Added user %s with external_user_id %s to gradebook"
+                    % (email, external_user_id)
                 )
+                return user.to_dict()
             except InvalidEntry as e:
                 logger.debug("Error during adding student to gradebook: %s" % e)
 
     def update_course(self, **kwargs) -> None:
         """
         Updates the course in nbgrader database
         """
-        with Gradebook(self.db_url, course_id=self.course_id) as gb:
+        with Gradebook(self.db_url, course_id=self.course_id, campus_id=CAMPUS_ID) as gb:
             gb.update_course(self.course_id, **kwargs)
 
     def get_course(self) -> Course:
         """
         Gets the course model instance
         """
-        with Gradebook(self.db_url, course_id=self.course_id) as gb:
+        with Gradebook(self.db_url, course_id=self.course_id, campus_id=CAMPUS_ID) as gb:
             course = gb.check_course(self.course_id)
             logger.debug(f"course got from db:{course}")
             return course
@@ -131,7 +120,7 @@ def register_assignment(self, assignment_name: str, **kwargs: dict) -> Assignmen
             "Assignment name normalized %s to save in gradebook" % assignment_name
         )
         assignment = None
-        with Gradebook(self.db_url, course_id=self.course_id) as gb:
+        with Gradebook(self.db_url, course_id=self.course_id, campus_id=CAMPUS_ID) as gb:
             try:
                 assignment = gb.update_or_create_assignment(assignment_name, **kwargs)
                 logger.debug("Added assignment %s to gradebook" % assignment_name)

src/illumidesk/illumidesk/authenticators/authenticator.py

@@ -60,7 +60,7 @@ async def setup_course_hook_lti11(
     jupyterhub_api = JupyterHubAPI()
 
     # normalize the name and course_id strings in authentication dictionary
-    username = authentication["name"]
+    name = authentication["name"]
     lms_user_id = authentication["auth_state"]["user_id"]
     user_role = authentication["auth_state"]["roles"].split(",")[0]
     course_id = lti_utils.normalize_string(
@@ -69,25 +69,28 @@ async def setup_course_hook_lti11(
     nb_service = NbGraderServiceHelper(course_id, True)
 
     # register the user (it doesn't matter if it is a student or instructor) with her/his lms_user_id in nbgrader
-    nb_service.add_user_to_nbgrader_gradebook(username, lms_user_id)
+    role = "STUDENT"
+    if not user_is_a_student(user_role) and user_is_an_instructor(user_role):
+        role = "INSTRUCTOR"
+    nb_service.add_user_to_nbgrader_gradebook(name, lms_user_id, role)
     # TODO: verify the logic to simplify groups creation and membership
-    if user_is_a_student(user_role):
+    if role == "STUDENT":
         try:
             # assign the user to 'nbgrader-<course_id>' group in jupyterhub and gradebook
-            await jupyterhub_api.add_student_to_jupyterhub_group(course_id, username)
+            await jupyterhub_api.add_student_to_jupyterhub_group(course_id, lms_user_id)
         except AddJupyterHubUserException as e:
             logger.error(
-                "An error when adding student username: %s to course_id: %s with exception %s",
-                (username, course_id, e),
+                "An error when adding student user_id: %s to course_id: %s with exception %s",
+                (lms_user_id, course_id, e),
             )
-    elif user_is_an_instructor(user_role):
+    elif role == "INSTRUCTOR":
         try:
             # assign the user in 'formgrade-<course_id>' group
-            await jupyterhub_api.add_instructor_to_jupyterhub_group(course_id, username)
+            await jupyterhub_api.add_instructor_to_jupyterhub_group(course_id, lms_user_id)
         except AddJupyterHubUserException as e:
             logger.error(
-                "An error when adding instructor username: %s to course_id: %s with exception %s",
-                (username, course_id, e),
+                "An error when adding instructor user_id: %s to course_id: %s with exception %s",
+                (lms_user_id, course_id, e),
             )
 
     # launch the new grader-notebook as a service
@@ -128,30 +131,33 @@ async def setup_course_hook(
     # normalize the name and course_id strings in authentication dictionary
     course_id = lti_utils.normalize_string(authentication["auth_state"]["course_id"])
     nb_service = NbGraderServiceHelper(course_id, True)
-    username = lti_utils.normalize_string(authentication["name"])
     lms_user_id = authentication["auth_state"]["lms_user_id"]
+    email = authentication["auth_state"]["email"]
     user_role = authentication["auth_state"]["user_role"]
+    source = authentication["auth_state"]["source"]
+    source_type = authentication["auth_state"]["source_type"]
 
     # register the user (it doesn't matter if it is a student or instructor) with her/his lms_user_id in nbgrader
-    nb_service.add_user_to_nbgrader_gradebook(username, lms_user_id)
+    user = nb_service.add_user_to_nbgrader_gradebook(email, lms_user_id, source, source_type)
+    authentication["name"] = user["id"]
     # TODO: verify the logic to simplify groups creation and membership
     if user_is_a_student(user_role):
         try:
             # assign the user to 'nbgrader-<course_id>' group in jupyterhub and gradebook
-            await jupyterhub_api.add_student_to_jupyterhub_group(course_id, username)
+            await jupyterhub_api.add_student_to_jupyterhub_group(course_id, user["id"])
         except AddJupyterHubUserException as e:
             logger.error(
-                "An error when adding student username: %s to course_id: %s with exception %s",
-                (username, course_id, e),
+                "An error when adding student user_id: %s to course_id: %s with exception %s",
+                (lms_user_id, course_id, e),
             )
     elif user_is_an_instructor(user_role):
         try:
             # assign the user in 'formgrade-<course_id>' group
-            await jupyterhub_api.add_instructor_to_jupyterhub_group(course_id, username)
+            await jupyterhub_api.add_instructor_to_jupyterhub_group(course_id, user["id"])
         except AddJupyterHubUserException as e:
             logger.error(
-                "An error when adding instructor username: %s to course_id: %s with exception %s",
-                (username, course_id, e),
+                "An error when adding instructor user_id: %s to course_id: %s with exception %s",
+                (lms_user_id, course_id, e),
             )
 
     # launch the new grader-notebook as a service
@@ -163,6 +169,48 @@ async def setup_course_hook(
     return authentication
 
 
+async def setup_user_hook_auth0(
+    authenticator: Authenticator,
+    handler: RequestHandler,
+    authentication: Dict[str, str],
+) -> Dict[str, str]:
+    """
+    Calls the microservice to create a new user in case it does not exist.
+    The data needed is received from auth_state within authentication object. This
+    function assumes that the required k/v's in the auth_state dictionary are available,
+    since the Authenticator(s) validates the data beforehand.
+
+    This function requires `Authenticator.enable_auth_state = True` and is intended
+    to be used as a post_auth_hook.
+
+    Args:
+        authenticator: the JupyterHub Authenticator object
+        handler: the JupyterHub handler object
+        authentication: the authentication object returned by the
+          authenticator class
+
+    Returns:
+        authentication (Required): updated authentication object
+    """
+    lti_utils = LTIUtils()
+
+    # normalize the name and course_id strings in authentication dictionary
+    course_id = lti_utils.normalize_string(authentication["auth_state"]["course_id"])
+    nb_service = NbGraderServiceHelper(course_id, True)
+    oauth_user = authentication["auth_state"]["oauth_user"] or {}
+
+    lms_user_id = oauth_user.get("user_id") or oauth_user.get("username") or oauth_user.get("sub")
+    email = oauth_user.get("email") or oauth_user.get("sub")
+    # user_role = authentication["auth_state"]["user_role"]
+    source = "auth0"
+    source_type = "generic-oauth"
+
+    # register the user (it doesn't matter if it is a student or instructor) with her/his lms_user_id in nbgrader
+    user = nb_service.add_user_to_nbgrader_gradebook(email, lms_user_id, source, source_type)
+    authentication["name"] = user["id"]
+    return authentication
+
+
 class LTI13Authenticator(OAuthenticator):
     """Custom authenticator used with LTI 1.3 requests"""
 
@@ -235,7 +283,9 @@ async def authenticate(  # noqa: C901
             course_id = lti_utils.normalize_string(course_id)
             self.log.debug("Normalized course label is %s" % course_id)
             username = ""
+            email = ""
             if "email" in jwt_decoded and jwt_decoded["email"]:
+                email = jwt_decoded["email"]
                 username = lti_utils.email_to_username(jwt_decoded["email"])
             elif "name" in jwt_decoded and jwt_decoded["name"]:
                 username = jwt_decoded["name"]
@@ -294,6 +344,7 @@ async def authenticate(  # noqa: C901
                 await process_resource_link_lti_13(self.log, course_id, jwt_decoded)
 
             lms_user_id = jwt_decoded["sub"] if "sub" in jwt_decoded else username
+            lms_id = (jwt_decoded.get("https://purl.imsglobal.org/spec/lti/claim/tool_platform") or {}).get("guid")
 
             # ensure the username is normalized
             self.log.debug("username is %s" % username)
@@ -303,14 +354,19 @@ async def authenticate(  # noqa: C901
             # ensure the user name is normalized
             username_normalized = lti_utils.normalize_string(username)
             self.log.debug("Assigned username is: %s" % username_normalized)
+            self.log.debug("Assigned id is: %s for username %s" % (lms_user_id, username))
 
             return {
-                "name": username_normalized,
+                "name": email or lms_user_id,
                 "auth_state": {
                     "course_id": course_id,
                     "user_role": user_role,
                     "lms_user_id": lms_user_id,
+                    "username": username,
+                    "email": email or lms_user_id,
                     "launch_return_url": launch_return_url,
+                    "source": lms_id,
+                    "source_type": "lti13"
                 },  # noqa: E231
             }
 

src/illumidesk/requirements.txt

@@ -48,7 +48,7 @@ matplotlib-inline==0.1.2  # via ipython
 mistune==0.8.4            # via nbconvert
 nbconvert==5.6.1          # via jupyter, nbgrader, notebook
 nbformat==5.1.3           # via ipywidgets, nbconvert, nbgrader, notebook
-nbgrader==0.6.2           # via illumidesk (setup.py)
+git+ssh://git@github.com/IllumiDesk/illumidesk-next.git@feature/refactor-modals-lti#subdirectory=packages/nbgrader           # via illumidesk (setup.py)
 notebook==6.4.1           # via jupyter, nbgrader, widgetsnbextension
 oauthenticator==14.2.0    # via illumidesk (setup.py)
 oauthlib==3.1.0           # via illumidesk (setup.py), jupyterhub, jupyterhub-ltiauthenticator, requests-oauthlib

src/illumidesk/setup.py

@@ -40,7 +40,7 @@
         "jupyterhub-kubespawner==0.14.1",
         "jupyterhub-ltiauthenticator@git+git://github.com/jupyterhub/ltiauthenticator.git@71d86a9da2562df4bdcc9f374af834a172ac52d5",
         "jwcrypto==0.8",
-        "nbgrader==0.6.2",
+        "git+ssh://git@github.com/IllumiDesk/illumidesk-next.git@feature/refactor-modals-lti#subdirectory=packages/nbgrader",
         "oauthlib==3.1",
         "oauthenticator>=0.13.0",
         "pem==20.1.0",

src/illumidesk/tests/illumidesk/conftest.py

@@ -27,7 +27,7 @@
 @pytest.fixture(scope="module")
 def auth_state_dict():
     authenticator_auth_state = {
-        "name": "student1",
+        "name": "185d6c59731a553009ca9b59ca3a885100000",
         "auth_state": {
             "course_id": "intro101",
             "lms_user_id": "185d6c59731a553009ca9b59ca3a885100000",