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

game/models.py

@@ -1,8 +1,10 @@
+import typing as t
 from builtins import str
 
 from common.models import Class, Student, UserProfile
 from django.contrib.auth.models import User
 from django.db import models
+from django.db.models.query import QuerySet
 
 
 def theme_choices():
@@ -41,9 +43,11 @@ class Block(models.Model):
 class Episode(models.Model):
     """Variables prefixed with r_ signify they are parameters for random level generation"""
 
+    worksheets: QuerySet["Worksheet"]
+
     name = models.CharField(max_length=200)
     next_episode = models.ForeignKey(
-        "self", null=True, default=None, on_delete=models.SET_NULL
+        "self", null=True, blank=True, default=None, on_delete=models.SET_NULL
     )
     in_development = models.BooleanField(default=False)
 
@@ -53,9 +57,9 @@ class Episode(models.Model):
     r_curviness = models.FloatField(default=0, null=True)
     r_num_tiles = models.IntegerField(default=5, null=True)
     r_blocks = models.ManyToManyField(Block, related_name="episodes")
-    r_blocklyEnabled = models.BooleanField(default=True)
-    r_pythonEnabled = models.BooleanField(default=False)
-    r_trafficLights = models.BooleanField(default=False)
+    r_blockly_enabled = models.BooleanField(default=True)
+    r_python_enabled = models.BooleanField(default=False)
+    r_traffic_lights = models.BooleanField(default=False)
     r_cows = models.BooleanField(default=False)
 
     @property
@@ -84,12 +88,23 @@ class Episode(models.Model):
             7: "medium-hard",
             8: "medium-hard",
             9: "brainteasers",
-            10: "hard",
-            11: "advanced",
-            12: "loops",
-            13: "loops",
-            14: "loops",
-            15: "loops",
+            10: "early-python",
+            11: "early-python",
+            12: "late-python",
+            13: "late-python",
+            14: "late-python",
+            15: "late-python",
+            16: "early-python",
+            17: "early-python",
+            18: "early-python",
+            19: "early-python",
+            20: "late-python",
+            21: "late-python",
+            22: "late-python",
+            23: "late-python",
+            24: "late-python",
+            25: "late-python",
+            26: "late-python",
         }
 
         return difficulty_map.get(self.id, "easy")
@@ -115,6 +130,8 @@ def sort_levels(levels):
 
 
 class Level(models.Model):
+    after_worksheet: t.Optional["Worksheet"]
+
     name = models.CharField(max_length=100)
     episode = models.ForeignKey(
         Episode, blank=True, null=True, default=None, on_delete=models.PROTECT
@@ -134,10 +151,10 @@ class Level(models.Model):
     )
     fuel_gauge = models.BooleanField(default=True)
     max_fuel = models.IntegerField(default=50)
-    direct_drive = models.BooleanField(default=False)
     next_level = models.ForeignKey(
         "self",
         null=True,
+        blank=True,
         default=None,
         on_delete=models.SET_NULL,
         related_name="prev_level",
@@ -147,21 +164,81 @@ class Level(models.Model):
     disable_route_score = models.BooleanField(default=False)
     disable_algorithm_score = models.BooleanField(default=False)
     threads = models.IntegerField(blank=False, default=1)
-    blocklyEnabled = models.BooleanField(default=True)
-    pythonEnabled = models.BooleanField(default=True)
-    pythonViewEnabled = models.BooleanField(default=False)
+    blockly_enabled = models.BooleanField(default=True)
+    python_enabled = models.BooleanField(default=True)
+    python_view_enabled = models.BooleanField(default=False)
     theme_name = models.CharField(
-        max_length=10, choices=theme_choices(), blank=True, null=True, default=None
+        max_length=10,
+        choices=theme_choices(),
+        blank=True,
+        null=True,
+        default=None,
     )
     character_name = models.CharField(
-        max_length=20, choices=character_choices(), blank=True, null=True, default=None
+        max_length=20,
+        choices=character_choices(),
+        blank=True,
+        null=True,
+        default=None,
+    )
+    subtitle = models.TextField(max_length=100, blank=True, null=True)
+    lesson = models.TextField(
+        max_length=10000, default="Can you find the shortest route?"
+    )
+    hint = models.TextField(
+        max_length=10000,
+        default="Think back to earlier levels. What did you learn?",
+    )
+    commands = models.TextField(
+        max_length=10000,
+        default='<div class="row">'
+        + '<div class="large-4 columns">'
+        + "<p><b>Movement</b>"
+        + "<br>my_van.move_forwards()"
+        + "<br>my_van.turn_around()"
+        + "<br>my_van.turn_left()"
+        + "<br>my_van.turn_right()"
+        + "<br>my_van.wait()<p></div>"
+        + '<div class="large-4 columns">'
+        + "<p><b>Position</b>"
+        + "<br>my_van.at_dead_end()"
+        + "<br>my_van.at_destination()"
+        + "<br>my_van.at_red_traffic_light()"
+        + "<br>my_van.at_green_traffic_light()"
+        + "<br>my_van.at_traffic_light(c)"
+        + "<br><i>where c is 'RED' or 'GREEN'</i></p></div>"
+        + '<div class="large-4 columns">'
+        + "<p><br>my_van.is_road_right()"
+        + "<br>my_van.is_road_left()"
+        + "<br>my_van.is_road_forward()"
+        + "<br>my_van.is_road(d)"
+        + "<br><i>where d is 'FORWARD', 'LEFT', or 'RIGHT'</i></p></div>"
+        + "</div>"
+        + '<div class="row">'
+        + '<div class="large-4 columns">'
+        + "<p><b>Animals</b>"
+        + "<br>my_van.is_animal_crossing()"
+        + "<br>my_van.sound_horn()</div>"
+        + "</div>",
     )
     anonymous = models.BooleanField(default=False)
     locked_for_class = models.ManyToManyField(
         Class, blank=True, related_name="locked_levels"
     )
+    needs_approval = models.BooleanField(default=True)
     objects = LevelManager()
 
+    class Meta:
+        constraints = [
+            models.CheckConstraint(
+                check=~models.Q(
+                    default=True,
+                    needs_approval=True,
+                ),
+                name="level__default_does_not_need_approval",
+            ),
+        ]
+
     def __str__(self):
         return f"Level {self.name}"
 
@@ -210,7 +287,7 @@ class LevelDecor(models.Model):
     x = models.IntegerField()
     y = models.IntegerField()
     level = models.ForeignKey(Level, on_delete=models.CASCADE)
-    decorName = models.CharField(max_length=100, default="tree1")
+    decor_name = models.CharField(max_length=100, default="tree1")
 
 
 class Workspace(models.Model):
@@ -251,3 +328,36 @@ class Attempt(models.Model):
 
     def elapsed_time(self):
         return self.finish_time - self.start_time
+
+
+class Worksheet(models.Model):
+    episode = models.ForeignKey(
+        Episode,
+        blank=True,
+        null=True,
+        default=None,
+        on_delete=models.PROTECT,
+        related_name="worksheets",
+    )
+    before_level = models.OneToOneField(
+        Level,
+        blank=True,
+        null=True,
+        default=None,
+        on_delete=models.PROTECT,
+        related_name="after_worksheet",
+    )
+    lesson_plan_link = models.CharField(
+        max_length=500, null=True, blank=True, default=None
+    )
+    slides_link = models.CharField(max_length=500, null=True, blank=True, default=None)
+    student_worksheet_link = models.CharField(
+        max_length=500, null=True, blank=True, default=None
+    )
+    indy_worksheet_link = models.CharField(
+        max_length=500, null=True, blank=True, default=None
+    )
+    video_link = models.CharField(max_length=500, null=True, blank=True, default=None)
+    locked_classes = models.ManyToManyField(
+        Class, blank=True, related_name="locked_worksheets"
+    )

game/permissions.py

@@ -1,9 +1,5 @@
-import logging
-
 from rest_framework import permissions
 
-LOGGER = logging.getLogger(__name__)
-
 
 def _get_userprofile_school(userprofile):
     if hasattr(userprofile, "teacher"):
@@ -11,7 +7,6 @@ def _get_userprofile_school(userprofile):
     elif hasattr(userprofile, "student"):
         return userprofile.student.class_field.teacher.school
     else:
-        LOGGER.error(f"Userprofile ID {userprofile.id} has no teacher or student attribute")
         return None
 
 
@@ -49,15 +44,32 @@ def can_play_or_delete_level(user, level):
     # If the teacher is an admin, they can play any student's level in the school, otherwise only student levels
     # from their own classes
     if user.userprofile.teacher.is_admin and hasattr(level.owner, "student"):
-        return user.userprofile.teacher.school == level.owner.student.class_field.teacher.school
+        return (
+            user.userprofile.teacher.school
+            == level.owner.student.class_field.teacher.school
+        )
     else:
         return user.userprofile.teacher.teaches(level.owner)
 
 
+def can_approve_level(user, level):
+    return (
+        hasattr(user.userprofile, "teacher")
+        and level.shared_with.filter(id=user.id).exists()
+    )
+
+
 def can_play_level(user, level, early_access):
-    if not user.is_anonymous and hasattr(user.userprofile, "student") and user.userprofile.student.class_field:
+    if (
+        not user.is_anonymous
+        and hasattr(user.userprofile, "student")
+        and user.userprofile.student.class_field
+    ):
         # If the user is a student, check that the level isn't locked for their class
-        return user.userprofile.student.class_field not in level.locked_for_class.all()
+        return user.userprofile.id == level.owner_id or (
+            user.userprofile.student.class_field not in level.locked_for_class.all()
+            and not level.needs_approval
+        )
     elif level.default and not level.episode.in_development:
         return True
     elif level.anonymous:
@@ -86,7 +98,9 @@ def can_load_level(user, level):
         owner_school = _get_userprofile_school(level.owner)
         return user_school is not None and user_school == owner_school
     else:
-        return hasattr(user.userprofile, "teacher") and user.userprofile.teacher.teaches(level.owner)
+        return hasattr(
+            user.userprofile, "teacher"
+        ) and user.userprofile.teacher.teaches(level.owner)
 
 
 def can_save_level(user, level):
@@ -112,8 +126,8 @@ def can_delete_level(user, level):
 class CanShareLevel(permissions.BasePermission):
     """
     Used to verify that an incoming request is made by a user who is authorised to share
-    the level - that is, that they are the owner of the level as a student, or if they're a teacher that the level was
-    shared with them.
+    the level - that is, that they are the owner of the level as a student and the level has been approved by a teacher,
+    or if they're a teacher that the level was shared with them.
     """
 
     def has_permission(self, request, view):
@@ -122,13 +136,19 @@ class CanShareLevel(permissions.BasePermission):
     def has_object_permission(self, request, view, obj):
         if request.user.is_anonymous:
             return False
-        elif hasattr(request.user.userprofile, "student") and request.user.userprofile.student.is_independent():
+        elif (
+            hasattr(request.user.userprofile, "student")
+            and request.user.userprofile.student.is_independent()
+        ):
             return False
         # if the user is a teacher and the level is shared with them
-        elif hasattr(request.user.userprofile, "teacher") and obj.shared_with.filter(id=request.user.id).exists():
+        elif (
+            hasattr(request.user.userprofile, "teacher")
+            and obj.shared_with.filter(id=request.user.id).exists()
+        ):
             return True
         else:
-            return obj.owner == request.user.userprofile
+            return obj.owner == request.user.userprofile and not obj.needs_approval
 
 
 class CanShareLevelWith(permissions.BasePermission):
@@ -164,18 +184,30 @@ class CanShareLevelWith(permissions.BasePermission):
             and not (recipient_profile.student.is_independent())
         ):
             # Are they in the same class?
-            return sharer_profile.student.class_field == recipient_profile.student.class_field
-        elif hasattr(sharer_profile, "teacher") and sharer_profile.teacher.teaches(recipient_profile):
+            return (
+                sharer_profile.student.class_field
+                == recipient_profile.student.class_field
+            )
+        elif hasattr(sharer_profile, "teacher") and sharer_profile.teacher.teaches(
+            recipient_profile
+        ):
             # Is the recipient taught by the sharer?
             return True
-        elif hasattr(recipient_profile, "teacher") and recipient_profile.teacher.teaches(sharer_profile):
+        elif hasattr(
+            recipient_profile, "teacher"
+        ) and recipient_profile.teacher.teaches(sharer_profile):
             # Is the sharer taught by the recipient?
             return True
-        elif hasattr(sharer_profile, "teacher") and hasattr(recipient_profile, "teacher"):
+        elif hasattr(sharer_profile, "teacher") and hasattr(
+            recipient_profile, "teacher"
+        ):
             # Are they in the same organisation?
             return recipient_profile.teacher.school == sharer_profile.teacher.school
         elif hasattr(sharer_profile, "teacher") and sharer_profile.teacher.is_admin:
-            return recipient_profile.student.class_field.teacher.school == sharer_profile.teacher.school
+            return (
+                recipient_profile.student.class_field.teacher.school
+                == sharer_profile.teacher.school
+            )
         else:
             return False
 

game/python_den_urls.py

@@ -0,0 +1,26 @@
+from django.urls import re_path
+
+from game.views.level import play_default_python_level, start_python_episode
+from game.views.level_selection import python_levels
+from game.views.scoreboard import python_scoreboard
+from game.views.worksheet import worksheet
+
+urlpatterns = [
+    re_path(r"^$", python_levels, name="python_levels"),
+    re_path(
+        r"^(?P<level_name>[A-Z0-9]+)/$",
+        play_default_python_level,
+        name="play_python_default_level",
+    ),
+    re_path(
+        r"^episode/(?P<episodeId>[0-9]+)/$",
+        start_python_episode,
+        name="start_python_episode",
+    ),
+    re_path(
+        r"^worksheet/(?P<worksheetId>[0-9]+)/$",
+        worksheet,
+        name="worksheet",
+    ),
+    re_path(r"^scoreboard/$", python_scoreboard, name="python_scoreboard"),
+]

game/random_road.py

@@ -58,7 +58,7 @@ def create(episode=None):
     loopiness = episode.r_loopiness if episode else DEFAULT_LOOPINESS
     curviness = episode.r_curviness if episode else DEFAULT_CURVINESS
     blocks = episode.r_blocks.all() if episode else Block.objects.all()
-    traffic_lights = episode.r_trafficLights if episode else DEFAULT_TRAFFIC_LIGHTS
+    traffic_lights = episode.r_traffic_lights if episode else DEFAULT_TRAFFIC_LIGHTS
     cows = episode.r_cows if episode else DEFAULT_TRAFFIC_LIGHTS
     decor = DEFAULT_DECOR
 
@@ -68,8 +68,8 @@ def create(episode=None):
     level_data["theme"] = 1
     level_data["name"] = ("Random level for " + episode.name) if episode else "Default random level"
     level_data["character"] = 1
-    level_data["blocklyEnabled"] = episode.r_blocklyEnabled if episode else True
-    level_data["pythonEnabled"] = episode.r_pythonEnabled if episode else False
+    level_data["blockly_enabled"] = episode.r_blockly_enabled if episode else True
+    level_data["python_enabled"] = episode.r_python_enabled if episode else False
     level_data["blocks"] = [{"type": block.type} for block in blocks]
 
     level = Level(default=False, anonymous=True)
@@ -276,7 +276,7 @@ def generate_traffic_lights(path):
     random.shuffle(candidateNodes)
     nodesSelected = candidateNodes[:numberOfJunctions]
 
-    trafficLights = []
+    traffic_lights = []
     for node in nodesSelected:
 
         controlledNeighbours = []
@@ -291,7 +291,7 @@ def generate_traffic_lights(path):
 
             direction = get_direction(node, neighbour)
 
-            trafficLights.append(
+            traffic_lights.append(
                 {
                     "sourceCoordinate": {"x": neighbour["coordinate"].x, "y": neighbour["coordinate"].y},
                     "direction": direction,
@@ -303,7 +303,7 @@ def generate_traffic_lights(path):
             )
             counter += 1
 
-    return trafficLights
+    return traffic_lights
 
 
 def generate_cows(path):
@@ -346,7 +346,7 @@ def generate_decor(path, num_tiles):
                     elem == "pond"
                     and (coord["x"] // GRID_SIZE == x + 1 and coord["y"] // GRID_SIZE == y or x + 1 < WIDTH)
                 )
-                or (dec["decorName"] == "pond" and coord["x"] // GRID_SIZE + 1 == x and coord["y"] // GRID_SIZE == y)
+                or (dec["decor_name"] == "pond" and coord["x"] // GRID_SIZE + 1 == x and coord["y"] // GRID_SIZE == y)
             ):
                 return True
 
@@ -368,7 +368,7 @@ def generate_decor(path, num_tiles):
         x = x * GRID_SIZE + int((GRID_SIZE - decor_object.width) * 0.5 * (1 - dx))
         y = y * GRID_SIZE + int((GRID_SIZE - decor_object.height) * 0.5 * (1 - dy))
 
-        decor.append({"coordinate": {"x": x, "y": y}, "decorName": dec, "height": decor_object.height})
+        decor.append({"coordinate": {"x": x, "y": y}, "decor_name": dec, "height": decor_object.height})
 
     def place_near_road(elem, decor, path):
         for i in range(1, len(path) - 1):
@@ -389,7 +389,7 @@ def generate_decor(path, num_tiles):
     def place_bush(elem, decor, nodes):
         bush_exists = False
         for dec in decor:
-            if dec["decorName"] == elem:
+            if dec["decor_name"] == elem:
                 bush_exists = True
                 for (dx, dy) in DIRECTIONS:
                     x = dec["coordinate"]["x"] // GRID_SIZE + dx

game/serializers.py

@@ -5,7 +5,6 @@ from builtins import object
 from rest_framework import serializers
 
 from game import messages
-from game.messages import description_level_default, hint_level_default
 from game.theme import get_theme, get_themes_url
 from .models import Workspace, Level, Episode, LevelDecor, LevelBlock, Block
 
@@ -27,8 +26,8 @@ class LevelListSerializer(serializers.HyperlinkedModelSerializer):
             "name",
             "title",
             "default",
-            "blocklyEnabled",
-            "pythonEnabled",
+            "blockly_enabled",
+            "python_enabled",
         )
 
     def get_title(self, obj):
@@ -43,6 +42,7 @@ class LevelDetailSerializer(serializers.HyperlinkedModelSerializer):
     title = serializers.SerializerMethodField()
     description = serializers.SerializerMethodField()
     hint = serializers.SerializerMethodField()
+    commands = serializers.SerializerMethodField()
     levelblock_set = serializers.HyperlinkedIdentityField(
         view_name="levelblock-for-level", read_only=True
     )
@@ -67,9 +67,9 @@ class LevelDetailSerializer(serializers.HyperlinkedModelSerializer):
             "levelblock_set",
             "map",
             "mode",
-            "blocklyEnabled",
-            "pythonEnabled",
-            "pythonViewEnabled",
+            "blockly_enabled",
+            "python_enabled",
+            "python_view_enabled",
         )
 
     def get_title(self, obj):
@@ -80,18 +80,13 @@ class LevelDetailSerializer(serializers.HyperlinkedModelSerializer):
             return "Custom Level"
 
     def get_description(self, obj):
-        if obj.default:
-            description = getattr(messages, "description_level" + obj.name)()
-            return description
-        else:
-            return description_level_default()
+        return getattr(messages, "description_level" + obj.name)() if obj.default else obj.description
 
     def get_hint(self, obj):
-        if obj.default:
-            hint = getattr(messages, "hint_level" + obj.name)()
-            return hint
-        else:
-            return hint_level_default()
+        return getattr(messages, "hint_level" + obj.name)() if obj.default else obj.hint
+
+    def get_commands(self, obj):
+        return getattr(messages, "commands_level" + obj.name)() if obj.default else obj.commands
 
     def get_leveldecor_set(self, obj):
         leveldecors = LevelDecor.objects.filter(level__id=obj.id)
@@ -106,7 +101,7 @@ class LevelDetailSerializer(serializers.HyperlinkedModelSerializer):
 class LevelModeSerializer(serializers.HyperlinkedModelSerializer):
     class Meta(object):
         model = Level
-        fields = ("blocklyEnabled", "pythonEnabled", "pythonViewEnabled")
+        fields = ("blockly_enabled", "python_enabled", "python_view_enabled")
 
 
 class LevelMapListSerializer(serializers.HyperlinkedModelSerializer):