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

game/views/level.py

@@ -5,10 +5,9 @@ from builtins import object, str
 from datetime import datetime
 
 from django.http import Http404, HttpResponse
-from django.shortcuts import render, get_object_or_404
+from django.shortcuts import get_object_or_404, redirect, render
 from django.urls import reverse
 from django.utils import timezone
-from django.utils.safestring import mark_safe
 from django.views.decorators.http import require_POST
 from rest_framework import serializers
 
@@ -17,18 +16,19 @@ import game.messages as messages
 import game.permissions as permissions
 from game import app_settings
 from game.cache import (
+    cached_custom_level,
     cached_default_level,
     cached_episode,
-    cached_custom_level,
-    cached_level_decor,
     cached_level_blocks,
+    cached_level_decor,
 )
 from game.character import get_character
 from game.decor import get_decor_element
-from game.models import Level, Attempt, Workspace
+from game.models import Attempt, Level, Workspace
 from game.theme import get_theme
 from game.views.language_code_conversions import language_code_dict
 from game.views.level_solutions import solutions
+
 from .helper import renderError
 
 
@@ -44,14 +44,42 @@ def play_custom_level(request, levelId, from_editor=False):
     return play_level(request, level, from_editor)
 
 
-def play_default_level(request, levelName):
-    level = cached_default_level(levelName)
+def play_default_level(request, level_name):
+    level_index = int(level_name)
+    if level_index > 79:
+        raise Http404
+    if (
+        level_index > 19
+        and not level_index in [29, 33, 44, 51, 61, 68]
+        and not request.user.is_authenticated
+    ):
+        return redirect(reverse("levels"))
+
+    level = cached_default_level(level_name)
     return play_level(request, level)
 
 
-def _prev_level_url(level, user, night_mode):
+def play_default_python_level(request, level_name):
+    level_index = int(level_name)
+    if level_index > 49:
+        raise Http404
+    if (
+        level_index > 26
+        and not level_index in [41]
+        and not request.user.is_authenticated
+    ):
+        return redirect(reverse("python_levels"))
+
+    levelId = int(level_name) + 1000
+
+    level = cached_default_level(levelId)
+    return play_level(request, level, from_python_den=True)
+
+
+def _prev_level_url(level, user, night_mode, from_python_den):
     """
-    Find the previous available level. Check if level is available if so, go to it.
+    Find the previous available level. Check if level is available if so, go to
+    it.
     """
 
     if not level.prev_level.all():
@@ -68,16 +96,24 @@ def _prev_level_url(level, user, night_mode):
                 prev_level = prev_level.prev_level.all()[0]
                 is_prev_level_locked = klass in prev_level.locked_for_class.all()
 
-    return _level_url(prev_level, night_mode)
+    return _level_url(prev_level, night_mode, from_python_den)
 
 
-def _next_level_url(level, user, night_mode):
+def _next_level_url(level, user, night_mode, from_python_den):
     """
-    Find the next available level. By default, this will be the `next_level` field in the Level model, but in the case
-    where the user is a student and the teacher has locked certain levels, then loop until we find the next unlocked
-    level (or we run out of levels).
+    Find the next available level. By default, this will be the `next_level`
+    field in the Level model, but in the case where the user is a student and
+    the teacher has locked certain levels, then loop until we find the next
+    unlocked level (or we run out of levels).
     """
+
     if not level.next_level:
+        if (
+            level.episode
+            and level.episode.next_episode
+            and len(level.episode.next_episode.levels) == 0
+        ):
+            return reverse("python_levels")
         return ""
 
     next_level = level.next_level
@@ -89,11 +125,13 @@ def _next_level_url(level, user, night_mode):
         is_next_level_locked = klass in next_level.locked_for_class.all()
 
         if is_next_level_locked:
-            while is_next_level_locked and int(next_level.name) < 109:
+            while is_next_level_locked and (
+                int(next_level.name) < 1050 if from_python_den else 80
+            ):
                 next_level = next_level.next_level
                 is_next_level_locked = klass in next_level.locked_for_class.all()
 
-    return _level_url(next_level, night_mode)
+    return _level_url(next_level, night_mode, from_python_den)
 
 
 def add_night(url, night_mode):
@@ -102,24 +140,28 @@ def add_night(url, night_mode):
     return url
 
 
-def _level_url(level, night_mode):
+def _level_url(level, night_mode, from_python_den):
     if level.default:
-        result = _default_level_url(level)
+        result = _default_level_url(level, from_python_den)
     else:
         result = _custom_level_url(level)
 
     return add_night(result, night_mode)
 
 
-def _default_level_url(level):
-    return reverse("play_default_level", args=[level.name])
+def _default_level_url(level, from_python_den):
+    viewname = "play_python_default_level" if from_python_den else "play_default_level"
+
+    level_name = int(level.name) - 1000 if from_python_den else level.name
+
+    return reverse(viewname, args=[level_name])
 
 
 def _custom_level_url(level):
     return reverse("play_custom_level", args=[level.id])
 
 
-def play_level(request, level, from_editor=False):
+def play_level(request, level, from_editor=False, from_python_den=False):
     """Loads a level for rendering in the game.
 
     **Context**
@@ -139,32 +181,32 @@ def play_level(request, level, from_editor=False):
     :template:`game/game.html`
     """
 
-    night_mode = False if not app_settings.NIGHT_MODE_FEATURE_ENABLED else "night" in request.GET
-
-    if not permissions.can_play_level(request.user, level, app_settings.EARLY_ACCESS_FUNCTION(request)):
-        return renderError(request, messages.no_permission_title(), messages.not_shared_level())
-
-    # Set default level description/hint lookups
-    lesson = "description_level_default"
-    hint = "hint_level_default"
-
-    # If it's one of our levels, set level description/hint lookups
-    # to point to what they should be
-    if level.default:
-        lesson = "description_level" + str(level.name)
-        hint = "hint_level" + str(level.name)
-
-    # Try to get the relevant message, and fall back on defaults
-    try:
-        lessonCall = getattr(messages, lesson)
-        hintCall = getattr(messages, hint)
-    except AttributeError:
-        lessonCall = messages.description_level_default
-        hintCall = messages.hint_level_default
+    night_mode = (
+        False if not app_settings.NIGHT_MODE_FEATURE_ENABLED else "night" in request.GET
+    )
 
-    lesson = mark_safe(lessonCall())
-    hint = mark_safe(hintCall())
+    if not permissions.can_play_level(
+        request.user, level, app_settings.EARLY_ACCESS_FUNCTION(request)
+    ):
+        return renderError(
+            request, messages.no_permission_title(), messages.not_shared_level()
+        )
 
+    subtitle = level.subtitle
+    lesson = (
+        getattr(messages, "description_level" + str(level.name))
+        if level.default
+        else level.lesson
+    )
+    hint = (
+        getattr(messages, "hint_level" + str(level.name))
+        if level.default
+        else level.hint
+    )
+    commands_attr = "commands_level" + str(level.name)
+    commands = (
+        getattr(messages, commands_attr, None) if level.default else level.commands
+    )
     character = level.character
     character_url = character.top_down
     wreckage_url = "van_wreckage.svg"
@@ -200,7 +242,9 @@ def play_level(request, level, from_editor=False):
             .first()
         )
         if not attempt:
-            attempt = Attempt(level=level, student=student, score=None, night_mode=night_mode)
+            attempt = Attempt(
+                level=level, student=student, score=None, night_mode=night_mode
+            )
             fetch_workspace_from_last_attempt(attempt)
             attempt.save()
         else:
@@ -221,10 +265,18 @@ def play_level(request, level, from_editor=False):
         night_mode_javascript = "false"
         model_solution = level.model_solution
 
-    return_view = "level_editor" if from_editor else "levels"
+    return_view = (
+        "level_editor"
+        if from_editor
+        else "python_levels" if from_python_den else "levels"
+    )
 
     temp_block_data = []
-    [temp_block_data.append(block) for block in block_data if block not in temp_block_data]
+    [
+        temp_block_data.append(block)
+        for block in block_data
+        if block not in temp_block_data
+    ]
 
     block_data = temp_block_data
 
@@ -233,14 +285,16 @@ def play_level(request, level, from_editor=False):
         "game/game.html",
         context={
             "level": level,
+            "subtitle": subtitle,
             "lesson": lesson,
+            "hint": hint,
+            "commands": commands if commands is not None else level.commands,
             "blocks": block_data,
             "decor": decor_data,
             "character": character,
             "background": background,
             "house": house,
             "cfc": cfc,
-            "hint": hint,
             "workspace": workspace,
             "python_workspace": python_workspace,
             "return_url": reverse(return_view),
@@ -249,19 +303,29 @@ def play_level(request, level, from_editor=False):
             "character_height": character_height,
             "wreckage_url": wreckage_url,
             "night_mode": night_mode_javascript,
-            "night_mode_feature_enabled": str(app_settings.NIGHT_MODE_FEATURE_ENABLED).lower(),
+            "night_mode_feature_enabled": str(
+                app_settings.NIGHT_MODE_FEATURE_ENABLED
+            ).lower(),
             "model_solution": model_solution,
-            "prev_level_url": _prev_level_url(level, request.user, night_mode),
-            "next_level_url": _next_level_url(level, request.user, night_mode),
-            "flip_night_mode_url": _level_url(level, not night_mode),
-            "available_language_dict": language_code_dict
+            "prev_level_url": _prev_level_url(
+                level, request.user, night_mode, from_python_den
+            ),
+            "next_level_url": _next_level_url(
+                level, request.user, night_mode, from_python_den
+            ),
+            "flip_night_mode_url": _level_url(level, not night_mode, from_python_den),
+            "available_language_dict": language_code_dict,
         },
     )
 
 
 def fetch_workspace_from_last_attempt(attempt):
     latest_attempt = (
-        Attempt.objects.filter(level=attempt.level, student=attempt.student, night_mode=attempt.night_mode)
+        Attempt.objects.filter(
+            level=attempt.level,
+            student=attempt.student,
+            night_mode=attempt.night_mode,
+        )
         .order_by("-start_time")
         .first()
     )
@@ -277,15 +341,23 @@ def delete_level(request, levelID):
         level_management.delete_level(level)
         success = True
 
-    return HttpResponse(json.dumps({"success": success}), content_type="application/javascript")
+    return HttpResponse(
+        json.dumps({"success": success}), content_type="application/javascript"
+    )
 
 
 def submit_attempt(request):
     """Processes a request on submission of the program solving the current level."""
-    if not request.user.is_anonymous and request.method == "POST" and hasattr(request.user.userprofile, "student"):
+    if (
+        not request.user.is_anonymous
+        and request.method == "POST"
+        and hasattr(request.user.userprofile, "student")
+    ):
         level = get_object_or_404(Level, id=request.POST.get("level", 1))
         student = request.user.userprofile.student
-        attempt = Attempt.objects.filter(level=level, student=student, finish_time__isnull=True).first()
+        attempt = Attempt.objects.filter(
+            level=level, student=student, finish_time__isnull=True
+        ).first()
         if attempt:
             attempt.score = float(request.POST.get("score"))
             attempt.workspace = request.POST.get("workspace")
@@ -362,16 +434,25 @@ def load_workspace(request, workspaceID):
 
 
 def save_workspace(request, workspaceID=None):
-    request_params = ["name", "contents", "python_contents", "blockly_enabled", "python_enabled", "pythonViewEnabled"]
+    request_params = [
+        "name",
+        "contents",
+        "python_contents",
+        "blockly_enabled",
+        "python_enabled",
+        "python_view_enabled",
+    ]
     missing_params = [param for param in request_params if param not in request.POST]
     if missing_params != []:
-        raise Exception("Request missing the following required parameters", missing_params)
+        raise Exception(
+            "Request missing the following required parameters", missing_params
+        )
     name = request.POST.get("name")
     contents = request.POST.get("contents")
     python_contents = request.POST.get("python_contents")
     blockly_enabled = json.loads(request.POST.get("blockly_enabled"))
     python_enabled = json.loads(request.POST.get("python_enabled"))
-    python_view_enabled = json.loads(request.POST.get("pythonViewEnabled"))
+    python_view_enabled = json.loads(request.POST.get("python_view_enabled"))
 
     workspace = None
     if workspaceID:
@@ -401,7 +482,7 @@ def load_workspace_solution(request, level_name):
 
         level = Level.objects.get(name=level_name, default=True)
 
-        if level.blocklyEnabled:
+        if level.blockly_enabled:
             workspace.contents = solutions[level_name]
             workspace.blockly_enabled = True
             workspace.python_enabled = False
@@ -424,8 +505,19 @@ def load_workspace_solution(request, level_name):
 
 
 def start_episode(request, episodeId):
+    if int(episodeId) > 9:
+        raise Http404
+
+    episode = cached_episode(episodeId)
+    return play_level(request, episode.first_level)
+
+
+def start_python_episode(request, episodeId):
+    if int(episodeId) < 12:
+        raise Http404
+
     episode = cached_episode(episodeId)
-    return play_level(request, episode.first_level, False)
+    return play_level(request, episode.first_level, from_python_den=True)
 
 
 @require_POST

game/views/level_editor.py

@@ -2,8 +2,7 @@ from __future__ import division
 
 import json
 import re
-from builtins import map
-from builtins import str
+from builtins import map, str
 
 from common.models import Student, Teacher
 from django.contrib.auth.models import User
@@ -11,7 +10,6 @@ from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, render, redirect
 from django.urls import reverse
-from django.utils.safestring import mark_safe
 from django.views.decorators.http import require_POST
 from portal.templatetags import app_tags
 from rest_framework.authentication import SessionAuthentication
@@ -20,8 +18,7 @@ from rest_framework.views import APIView
 import game.level_management as level_management
 import game.messages as messages
 import game.permissions as permissions
-from game import app_settings
-from game import random_road
+from game import app_settings, random_road
 from game.cache import cached_level_decor, cached_level_blocks
 from game.character import get_all_character
 from game.decor import get_all_decor, get_decor_element
@@ -86,8 +83,9 @@ def play_anonymous_level(request, levelId, from_level_editor=True, random_level=
     if not level.anonymous:
         return redirect(reverse("level_editor"), permanent=True)
 
-    lesson = mark_safe(messages.description_level_default())
-    hint = mark_safe(messages.hint_level_default())
+    subtitle = level.subtitle
+    lesson = level.lesson
+    hint = level.hint
 
     attempt = None
     house = get_decor_element("house", level.theme).url
@@ -123,12 +121,13 @@ def play_anonymous_level(request, levelId, from_level_editor=True, random_level=
             "level": level,
             "decor": decor_data,
             "blocks": block_data,
+            "subtitle": subtitle,
             "lesson": lesson,
+            "hint": hint,
             "character": character,
             "background": background,
             "house": house,
             "cfc": cfc,
-            "hint": hint,
             "attempt": attempt,
             "random_level": random_level,
             "return_url": reverse(return_view_name),
@@ -208,6 +207,8 @@ def load_level_for_editor(request, levelID):
 def save_level_for_editor(request, levelId=None):
     """Processes a request on creation of the map in the level editor"""
     data = json.loads(request.POST["data"])
+    data["disable_algorithm_score"] = True
+
     if ("character" not in data) or (not data["character"]):
         # Set a default, to deal with issue #1158 "Cannot save custom level"
         data["character"] = 1
@@ -220,45 +221,61 @@ def save_level_for_editor(request, levelId=None):
     if not permissions.can_save_level(request.user, level):
         return HttpResponseUnauthorized()
 
-    pattern = re.compile("^(\w?[ ]?)*$")
-
-    if pattern.match(data["name"]):
-        level_management.save_level(level, data)
-
-        if levelId is None:
-            teacher = None
-
-            is_user_school_student = (
-                hasattr(level.owner, "student")
-                and not level.owner.student.is_independent()
-            )
-            is_user_independent = (
-                hasattr(level.owner, "student") and level.owner.student.is_independent()
-            )
-            is_user_teacher = hasattr(level.owner, "teacher")
-
-            # if level owner is a school student, share with teacher automatically if they aren't an admin
-            if is_user_school_student:
-                teacher = level.owner.student.class_field.teacher
-                if not teacher.is_admin:
-                    level.shared_with.add(teacher.new_user)
-
-                if not data["anonymous"]:
-                    level_management.email_new_custom_level(
-                        level.owner.student.class_field.teacher.new_user.email,
-                        request.build_absolute_uri(reverse("level_moderation")),
-                        request.build_absolute_uri(
-                            reverse("play_custom_level", kwargs={"levelId": level.id})
-                        ),
-                        request.build_absolute_uri(reverse("home")),
-                        str(level.owner.student),
-                        level.owner.student.class_field.name,
-                    )
-            elif is_user_teacher:
-                teacher = level.owner.teacher
-
-            # share with all admins of the school if user is in a school
-            if not is_user_independent:
+    name_pattern = re.compile("^(\w?[ ]?)*$")
+    fields_pattern = re.compile("^[\w.?!', ]*$")
+
+    name_is_safe = name_pattern.match(data["name"])
+    fields_are_safe = all(
+        [
+            field not in data or fields_pattern.match(data[field])
+            for field in ["subtitle", "lesson", "hint"]
+        ]
+    )
+
+    if not (name_is_safe and fields_are_safe):
+        return HttpResponseUnauthorized()
+
+    level_management.save_level(level, data)
+
+    is_user_school_student = (
+        hasattr(level.owner, "student") and not level.owner.student.is_independent()
+    )
+    is_user_independent = (
+        hasattr(level.owner, "student") and level.owner.student.is_independent()
+    )
+    is_user_teacher = hasattr(level.owner, "teacher")
+
+    # when level is created
+    if levelId is None:
+        teacher = None
+
+        # if level owner is a school student, share with teacher automatically if they aren't an admin
+        if is_user_school_student:
+            teacher = level.owner.student.class_field.teacher
+            if not teacher.is_admin:
+                level.shared_with.add(teacher.new_user)
+
+            if not data["anonymous"]:
+                level_management.email_new_custom_level(
+                    teacher.new_user.email,
+                    request.build_absolute_uri(reverse("level_moderation")),
+                    request.build_absolute_uri(
+                        reverse("play_custom_level", kwargs={"levelId": level.id})
+                    ),
+                    str(level.owner.student),
+                    level.owner.student.class_field.name,
+                )
+
+        elif is_user_teacher:
+            teacher = level.owner.teacher
+
+        # if level owner is a teacher or an indy user, approval isn't needed
+        if not is_user_school_student:
+            level.needs_approval = False
+
+        # share with all admins of the school if user is in a school
+        if not is_user_independent:
+            if not teacher.school is None:
                 school_admins = teacher.school.admins()
 
                 [
@@ -267,11 +284,25 @@ def save_level_for_editor(request, levelId=None):
                     if school_admin.new_user != request.user
                 ]
 
-            level.save()
-        response = {"id": level.id}
-        return HttpResponse(json.dumps(response), content_type="application/javascript")
-    else:
-        return HttpResponseUnauthorized()
+    # anytime a student edits their level
+    if is_user_school_student:
+        if not level.needs_approval:
+            level.needs_approval = True
+
+            if not data["anonymous"]:
+                level_management.email_new_custom_level(
+                    level.owner.student.class_field.teacher.new_user.email,
+                    request.build_absolute_uri(reverse("level_moderation")),
+                    request.build_absolute_uri(
+                        reverse("play_custom_level", kwargs={"levelId": level.id})
+                    ),
+                    str(level.owner.student),
+                    level.owner.student.class_field.name,
+                )
+
+    level.save()
+    response = {"id": level.id}
+    return HttpResponse(json.dumps(response), content_type="application/json")
 
 
 @transaction.atomic
@@ -374,9 +405,11 @@ class SharingInformationForEditor(APIView):
                 )
                 valid_recipients["classes"].append(
                     {
-                        "name": f"{class_.name} ({app_tags.make_into_username(class_.teacher.new_user)})"
-                        if teacher.is_admin
-                        else class_.name,
+                        "name": (
+                            f"{class_.name} ({app_tags.make_into_username(class_.teacher.new_user)})"
+                            if teacher.is_admin
+                            else class_.name
+                        ),
                         "id": class_.id,
                         "students": [
                             {

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
@@ -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
+        )