rapid-router 5.4.1__py2.py3-none-any.whl → 7.6.8__py2.py3-none-any.whl

game/views/level_moderation.py

@@ -2,7 +2,10 @@ from __future__ import absolute_import
 from __future__ import division
 
 from common.models import Student, Class
+from django.http import HttpResponse, HttpResponseRedirect
 from django.shortcuts import render
+from django.urls import reverse_lazy
+from django.views.decorators.http import require_POST
 from portal.templatetags import app_tags
 
 import game.messages as messages
@@ -34,8 +37,8 @@ def level_moderation(request):
     if not permissions.can_see_level_moderation(request.user):
         return renderError(
             request,
-            messages.noPermissionLevelModerationTitle(),
-            messages.noPermissionLevelModerationPage(),
+            messages.no_permission_level_moderation_title(),
+            messages.no_permission_level_moderation_page(),
         )
 
     teacher = request.user.userprofile.teacher
@@ -54,8 +57,8 @@ def level_moderation(request):
     if len(classes_taught) <= 0:
         return renderError(
             request,
-            messages.noPermissionLevelModerationTitle(),
-            messages.noDataToShowLevelModeration(),
+            messages.no_permission_level_moderation_title(),
+            messages.no_data_to_show_level_moderation(),
         )
 
     classes_taught_ids = [class_.id for class_ in classes_taught]
@@ -74,8 +77,8 @@ def level_moderation(request):
             if not all(class_id in classes_taught_ids for class_id in class_ids):
                 return renderError(
                     request,
-                    messages.noPermissionLevelModerationTitle(),
-                    messages.noPermissionLevelModerationClass(),
+                    messages.no_permission_level_moderation_title(),
+                    messages.no_permission_level_moderation_class(),
                 )
         else:
             class_ids = []
@@ -132,6 +135,7 @@ def level_moderation(request):
                     "id": level.id,
                     "name": level.name,
                     "shared_with": shared_str,
+                    "needs_approval": level.needs_approval,
                 }
             )
 
@@ -144,3 +148,22 @@ def level_moderation(request):
             "thead": table_headers,
         },
     )
+
+
+@require_POST
+def approve_level(request, levelID):
+    level = Level.objects.get(id=levelID)
+    if permissions.can_approve_level(request.user, level):
+        level.needs_approval = False
+        level.save()
+
+        return HttpResponseRedirect(reverse_lazy("level_moderation"))
+    else:
+        return HttpResponseUnauthorized()
+
+
+class HttpResponseUnauthorized(HttpResponse):
+    def __init__(self):
+        super(HttpResponseUnauthorized, self).__init__(
+            content="Unauthorized", status=401
+        )

game/views/level_selection.py

@@ -1,19 +1,17 @@
-from __future__ import absolute_import
-from __future__ import division
+from __future__ import absolute_import, division
 
 from builtins import str
 
+import game.level_management as level_management
+import game.messages as messages
 from django.core.cache import cache
 from django.db.models import Max
 from django.shortcuts import render
 from django.utils.safestring import mark_safe
-
-import game.level_management as level_management
-import game.messages as messages
-from game import app_settings
-from game import random_road
+from game import app_settings, random_road
 from game.cache import cached_episode
-from game.models import Attempt, Episode
+from game.models import Attempt, Episode, Level, Worksheet
+
 from .level_editor import play_anonymous_level
 
 
@@ -29,7 +27,7 @@ def max_score(level):
 def fetch_episode_data_from_database(early_access, start, end):
     episode_data = []
     episode = Episode.objects.get(pk=start)
-    current = start
+
     while episode is not None:
         if episode.in_development and not early_access:
             break
@@ -63,12 +61,12 @@ def fetch_episode_data_from_database(early_access, start, end):
         }
 
         episode_data.append(e)
-        episode = episode.next_episode
 
-        current += 1
-        if current > end:
+        if episode.id == end:
             break
 
+        episode = episode.next_episode
+
     return episode_data
 
 
@@ -81,17 +79,56 @@ def fetch_episode_data(early_access, start=1, end=12):
     if data is None:
         data = fetch_episode_data_from_database(early_access, start, end)
         cache.set(key, data)
-    return [
-        dict(
-            episode,
-            name=messages.get_episode_title(episode["id"]),
-            levels=[
-                dict(level, title=get_level_title(level["name"]))
-                for level in episode["levels"]
-            ],
+
+    def worksheet_to_dict(index, worksheet):
+        return {
+            "id": worksheet.id,
+            "index": index,
+            "before_level": worksheet.before_level_id,
+            "lesson_plan_link": worksheet.lesson_plan_link,
+            "slides_link": worksheet.slides_link,
+            "student_worksheet_link": worksheet.student_worksheet_link,
+            "indy_worksheet_link": worksheet.indy_worksheet_link,
+            "video_link": worksheet.video_link,
+        }
+
+    episodes = []
+    for episode in data:
+        worksheets = [
+            worksheet_to_dict(index, worksheet)
+            for index, worksheet in enumerate(
+                Worksheet.objects.filter(
+                    episode=episode["id"],
+                    before_level__isnull=False,
+                ).order_by("before_level"),
+                start=1,
+            )
+        ]
+        
+        worksheets += [
+            worksheet_to_dict(index, worksheet)
+            for index, worksheet in enumerate(
+                Worksheet.objects.filter(
+                    episode=episode["id"],
+                    before_level__isnull=True,
+                ),
+                start=1 + len(worksheets),
+            )
+        ]
+        
+        episodes.append(
+            dict(
+                episode,
+                name=messages.get_episode_title(episode["id"]),
+                levels=[
+                    dict(level, title=get_level_title(level["name"]))
+                    for level in episode["levels"]
+                ],
+                worksheets=worksheets,
+            )
         )
-        for episode in data
-    ]
+    
+    return episodes
 
 
 def get_level_title(i):
@@ -111,7 +148,28 @@ def is_student(user):
     return hasattr(user.userprofile, "student")
 
 
-def levels(request):
+def is_teacher(user):
+    return hasattr(user.userprofile, "teacher")
+
+
+def is_admin_teacher(user):
+    return (
+        hasattr(user.userprofile, "teacher")
+        and user.userprofile.teacher.is_admin
+    )
+
+
+def get_blockly_episodes(request):
+    return fetch_episode_data(app_settings.EARLY_ACCESS_FUNCTION(request), 1, 9)
+
+
+def get_python_episodes(request):
+    return fetch_episode_data(
+        app_settings.EARLY_ACCESS_FUNCTION(request), 16, 24
+    )
+
+
+def levels(request, language):
     """Loads a page with all levels listed.
 
     **Context**
@@ -136,24 +194,13 @@ def levels(request):
     else:
         attempts = {}
 
-    blockly_episodes = fetch_episode_data(
-        app_settings.EARLY_ACCESS_FUNCTION(request), 1, 9
-    )
-    for episode in blockly_episodes:
-        for level in episode["levels"]:
-            attach_attempts_to_level(attempts, level)
-
-    python_episodes = fetch_episode_data(
-        app_settings.EARLY_ACCESS_FUNCTION(request), 10, 11
-    )
-    for episode in python_episodes:
-        for level in episode["levels"]:
-            attach_attempts_to_level(attempts, level)
-
     owned_level_data = []
-    shared_level_data = []
+    directly_shared_levels = []
+    indirectly_shared_levels = {}
     if not request.user.is_anonymous:
-        owned_levels, shared_levels = level_management.get_loadable_levels(request.user)
+        owned_levels, shared_levels = level_management.get_loadable_levels(
+            request.user
+        )
 
         for level in owned_levels:
             owned_level_data.append(
@@ -166,29 +213,105 @@ def levels(request):
             )
 
         for level in shared_levels:
-            shared_level_data.append(
-                {
-                    "id": level.id,
-                    "title": level.name,
-                    "owner": level.owner.user,
-                    "score": attempts.get(level.id),
-                    "maxScore": 10,
-                }
-            )
+            # if user is an admin teacher, sort levels by their own classes first (directly shared levels) and then by
+            # other classes in the school (indirectly shared levels). For each of those, get the levels owned by a
+            # teacher as well as those owned by a student.
+            if is_admin_teacher(user):
+                # get levels shared by fellow teachers
+                if is_teacher(level.owner.user):
+                    teacher = level.owner.teacher.new_user
+
+                    if teacher not in indirectly_shared_levels:
+                        indirectly_shared_levels[teacher] = []
+
+                    indirectly_shared_levels[teacher].append(
+                        get_shared_level(level, attempts)
+                    )
+                else:
+                    student_class = level.owner.student.class_field
+                    class_teacher = student_class.teacher.new_user
+
+                    # get levels shared by students in the current user's classes
+                    if class_teacher == user:
+                        directly_shared_levels.append(
+                            get_shared_level(level, attempts, student_class)
+                        )
+                    # get levels shared by students in the other teachers' classes
+                    else:
+                        if class_teacher not in indirectly_shared_levels:
+                            indirectly_shared_levels[class_teacher] = []
+
+                        indirectly_shared_levels[class_teacher].append(
+                            get_shared_level(level, attempts, student_class)
+                        )
+            # if user is a student or a standard teacher, just get levels shared with them directly.
+            else:
+                directly_shared_levels.append(get_shared_level(level, attempts))
+
+    context = {
+        "owned_levels": owned_level_data,
+        "directly_shared_levels": directly_shared_levels,
+        "indirectly_shared_levels": indirectly_shared_levels,
+        "scores": attempts,
+    }
+
+    if language == "blockly":
+        blockly_episodes = get_blockly_episodes(request)
+
+        for episode in blockly_episodes:
+            for level in episode["levels"]:
+                attach_attempts_to_level(attempts, level)
+                level["locked_for_class"] = Level.objects.get(
+                    id=level["id"]
+                ).locked_for_class
+
+        context["blocklyEpisodes"] = blockly_episodes
+
+    elif language == "python":
+        python_episodes = get_python_episodes(request)
+
+        for episode in python_episodes:
+            for level in episode["levels"]:
+                attach_attempts_to_level(attempts, level)
+                level["locked_for_class"] = Level.objects.get(
+                    id=level["id"]
+                ).locked_for_class
+
+            for worksheet in episode["worksheets"]:
+                worksheet["locked_classes"] = Worksheet.objects.get(
+                    id=worksheet["id"]
+                ).locked_classes
+
+        context["pythonEpisodes"] = python_episodes
+
+    return context
+
+
+def blockly_levels(request):
+    return render(
+        request, "game/level_selection.html", context=levels(request, "blockly")
+    )
+
 
+def python_levels(request):
     return render(
         request,
-        "game/level_selection.html",
-        context={
-            "blocklyEpisodes": blockly_episodes,
-            "pythonEpisodes": python_episodes,
-            "owned_levels": owned_level_data,
-            "shared_levels": shared_level_data,
-            "scores": attempts,
-        },
+        "game/python_den_level_selection.html",
+        context=levels(request, "python"),
     )
 
 
+def get_shared_level(level, attempts, student_class=None):
+    return {
+        "id": level.id,
+        "title": level.name,
+        "owner": level.owner.user,
+        "class": student_class,
+        "score": attempts.get(level.id),
+        "maxScore": 10,
+    }
+
+
 def random_level_for_episode(request, episodeID):
     """Generates a new random level based on the episodeID