rapid-router 5.4.1__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 UserProfile, Student
+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():
@@ -19,17 +21,33 @@ def character_choices():
 
 class Block(models.Model):
     type = models.CharField(max_length=200)
+    block_type = models.IntegerField(
+        choices=[
+            (0, "Start"),
+            (1, "Action"),
+            (2, "Condition"),
+            (3, "Procedure"),
+            (4, "ControlFlow"),
+            (5, "Variable"),
+            (6, "Math"),
+        ]
+    )
 
     def __str__(self):
         return self.type
 
+    class Meta:
+        ordering = ["block_type", "pk"]
+
 
 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)
 
@@ -39,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
@@ -70,8 +88,23 @@ class Episode(models.Model):
             7: "medium-hard",
             8: "medium-hard",
             9: "brainteasers",
-            10: "hard",
-            11: "advanced",
+            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")
@@ -85,7 +118,11 @@ class LevelManager(models.Manager):
         # Sorts all the levels by integer conversion of "name" which should equate to the correct play order
         # Custom levels do not have an episode
 
-        return sort_levels(self.model.objects.filter(episode__isnull=False))
+        return sort_levels(
+            self.model.objects.filter(episode__isnull=False).exclude(
+                episode__name__icontains="coming soon"
+            )
+        )
 
 
 def sort_levels(levels):
@@ -93,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
@@ -112,26 +151,94 @@ 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, default=None, on_delete=models.SET_NULL
+        "self",
+        null=True,
+        blank=True,
+        default=None,
+        on_delete=models.SET_NULL,
+        related_name="prev_level",
     )
     shared_with = models.ManyToManyField(User, related_name="shared", blank=True)
     model_solution = models.CharField(blank=True, max_length=20, default="[]")
     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}"
 
@@ -180,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):
@@ -196,6 +303,7 @@ class Workspace(models.Model):
     python_contents = models.TextField(default="")
     blockly_enabled = models.BooleanField(default=False)
     python_enabled = models.BooleanField(default=False)
+    python_view_enabled = models.BooleanField(default=False)
 
     def __str__(self):
         return str(self.name)
@@ -220,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,9 +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
 
 
@@ -37,6 +30,7 @@ def can_save_workspace(user, workspace):
 def can_delete_workspace(user, workspace):
     return not user.is_anonymous and workspace.owner == user.userprofile
 
+
 #####################
 # Level permissions #
 #####################
@@ -51,15 +45,32 @@ def can_play_or_delete_level(user, level):
     # 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
+            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 level.default and not level.episode.in_development:
+    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.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:
         return False
@@ -115,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):
@@ -137,20 +148,19 @@ class CanShareLevel(permissions.BasePermission):
         ):
             return True
         else:
-            return obj.owner == request.user.userprofile
+            return obj.owner == request.user.userprofile and not obj.needs_approval
 
 
 class CanShareLevelWith(permissions.BasePermission):
     """
-    Used to verify that an the user who is requesting to share their level is
-    authorised to share the level with a specific recipient.
+    Used to verify that the user who is requesting to share their level is authorised to share the level with a specific
+    recipient.
     The user is authorised if:
     - neither they nor the recipient are anonymous,
     - neither they nor the recipient are independent students,
-    - they are a student and the recipient is a student in the same class, or their
-    teacher
-    - they are a teacher and the recipient is a teacher in the same school, or their
-    student
+    - they are a student and the recipient is a student in the same class, or their teacher
+    - they are a teacher and the recipient is a teacher in the same school, or their student
+    - they are an admin teacher and the recipient is a student in the same school
     """
 
     def has_permission(self, request, view):
@@ -193,6 +203,11 @@ class CanShareLevelWith(permissions.BasePermission):
         ):
             # 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
+            )
         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"),
+]