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

game/views/level.py

@@ -1,15 +1,13 @@
-from __future__ import division
-from __future__ import absolute_import
+from __future__ import absolute_import, division
 
-from builtins import str
-from builtins import object
 import json
+from builtins import object, str
+from datetime import datetime
 
-from django.urls import reverse
 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
 
@@ -18,15 +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
 
 
@@ -42,16 +44,94 @@ 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 _next_level_url(level, 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.
+    """
+
+    if not level.prev_level.all():
+        return ""
+
+    prev_level = level.prev_level.all()[0]
+    if not user.is_anonymous and hasattr(user.userprofile, "student"):
+        student = user.userprofile.student
+        klass = student.class_field
+
+        is_prev_level_locked = klass in prev_level.locked_for_class.all()
+        if is_prev_level_locked:
+            while is_prev_level_locked and int(prev_level.name) > 1:
+                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, from_python_den)
+
+
+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).
+    """
+
     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 ""
 
-    return _level_url(level.next_level, night_mode)
+    next_level = level.next_level
+
+    if not user.is_anonymous and hasattr(user.userprofile, "student"):
+        student = user.userprofile.student
+        klass = student.class_field
+
+        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) < 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, from_python_den)
 
 
 def add_night(url, night_mode):
@@ -60,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**
@@ -105,34 +189,43 @@ def play_level(request, level, from_editor=False):
         request.user, level, app_settings.EARLY_ACCESS_FUNCTION(request)
     ):
         return renderError(
-            request, messages.noPermissionTitle(), messages.notSharedLevel()
+            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
-
-    lesson = mark_safe(lessonCall())
-    hint = mark_safe(hintCall())
-
-    house = get_decor_element("house", level.theme).url
-    cfc = get_decor_element("cfc", level.theme).url
-    background = get_decor_element("tile1", level.theme).url
+    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"
+
+    if datetime.now().month == 12:
+        house = get_decor_element("house", get_theme("snow")).url
+        cfc = get_decor_element("cfc", get_theme("snow")).url
+        background = get_decor_element("tile1", get_theme("snow")).url
+
+        if character == get_character("Van"):
+            character_url = "characters/top_view/Sleigh.svg"
+            wreckage_url = "sleigh_wreckage.svg"
+    else:
+        house = get_decor_element("house", level.theme).url
+        cfc = get_decor_element("cfc", level.theme).url
+        background = get_decor_element("tile1", level.theme).url
+
+    character_width = character.width
+    character_height = character.height
 
     workspace = None
     python_workspace = None
@@ -162,11 +255,6 @@ def play_level(request, level, from_editor=False):
 
     decor_data = cached_level_decor(level)
 
-    character_url = character.top_down
-    character_width = character.width
-    character_height = character.height
-    wreckage_url = "van_wreckage.svg"
-
     if night_mode:
         block_data = level_management.get_night_blocks(level)
         night_mode_javascript = "true"
@@ -177,21 +265,36 @@ 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
+    ]
+
+    block_data = temp_block_data
 
     return render(
         request,
         "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),
@@ -204,8 +307,14 @@ def play_level(request, level, from_editor=False):
                 app_settings.NIGHT_MODE_FEATURE_ENABLED
             ).lower(),
             "model_solution": model_solution,
-            "next_level_url": _next_level_url(level, night_mode),
-            "flip_night_mode_url": _level_url(level, not night_mode),
+            "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,
         },
     )
 
@@ -213,7 +322,9 @@ def play_level(request, level, from_editor=False):
 def fetch_workspace_from_last_attempt(attempt):
     latest_attempt = (
         Attempt.objects.filter(
-            level=attempt.level, student=attempt.student, night_mode=attempt.night_mode
+            level=attempt.level,
+            student=attempt.student,
+            night_mode=attempt.night_mode,
         )
         .order_by("-start_time")
         .first()
@@ -323,11 +434,25 @@ def load_workspace(request, workspaceID):
 
 
 def save_workspace(request, workspaceID=None):
+    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
+        )
     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("python_view_enabled"))
 
     workspace = None
     if workspaceID:
@@ -341,26 +466,28 @@ def save_workspace(request, workspaceID=None):
         workspace.python_contents = python_contents
         workspace.blockly_enabled = blockly_enabled
         workspace.python_enabled = python_enabled
+        workspace.python_view_enabled = python_view_enabled
         workspace.save()
 
     return load_list_of_workspaces(request)
 
 
-def load_workspace_solution(request, levelName):
-
-    if levelName in solutions:
+def load_workspace_solution(request, level_name):
+    if level_name in solutions:
         workspace = Workspace(owner=request.user.userprofile)
-        workspace.id = levelName
-        workspace.name = levelName
+        workspace.id = level_name
+        workspace.name = level_name
         workspace.contents = solutions["blockly_default"]
         workspace.python_contents = solutions["python_default"]
 
-        if int(levelName) <= 91:
-            workspace.contents = solutions[levelName]
+        level = Level.objects.get(name=level_name, default=True)
+
+        if level.blockly_enabled:
+            workspace.contents = solutions[level_name]
             workspace.blockly_enabled = True
             workspace.python_enabled = False
         else:
-            workspace.python_contents = solutions[levelName]
+            workspace.python_contents = solutions[level_name]
             workspace.blockly_enabled = False
             workspace.python_enabled = True
 
@@ -378,8 +505,19 @@ def load_workspace_solution(request, levelName):
 
 
 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,16 +2,14 @@ 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, Class, Teacher
+from common.models import Student, Teacher
 from django.contrib.auth.models import User
-from django.urls import reverse
 from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, render, redirect
-from django.utils.safestring import mark_safe
+from django.urls import reverse
 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
@@ -69,9 +66,7 @@ def available_blocks():
     if app_settings.COW_FEATURE_ENABLED:
         return Block.objects.all()
     else:
-        return Block.objects.all().exclude(
-            type__in=["declare_event", "puff_up", "sound_horn"]
-        )
+        return Block.objects.all().exclude(type__in=["cow_crossing", "sound_horn"])
 
 
 def play_anonymous_level(request, levelId, from_level_editor=True, random_level=False):
@@ -88,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
@@ -125,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),
@@ -197,12 +194,12 @@ def load_level_for_editor(request, levelID):
 
     level_dict = LevelSerializer(level).data
     level_dict["theme"] = level.theme.id
-    level_dict["decor"] = cached_level_decor(level)
+    level_dict["decor"] = level_management.get_decor(level)
     level_dict["blocks"] = cached_level_blocks(level)
 
     response = {"owned": level.owner == request.user.userprofile, "level": level_dict}
 
-    return HttpResponse(json.dumps(response), content_type="application/javascript")
+    return HttpResponse(json.dumps(response), content_type="application/json")
 
 
 @transaction.atomic
@@ -210,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
@@ -222,19 +221,74 @@ 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)
-        # Add the teacher automatically if it is a new level and the student is not
-        # independent
-        if (
-            (levelId is None)
-            and hasattr(level.owner, "student")
-            and not level.owner.student.is_independent()
-        ):
-            level.shared_with.add(level.owner.student.class_field.teacher.user.user)
-            level.save()
+    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()
+
+                [
+                    level.shared_with.add(school_admin.new_user)
+                    for school_admin in school_admins
+                    if school_admin.new_user != request.user
+                ]
+
+    # 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,
@@ -242,14 +296,13 @@ def save_level_for_editor(request, levelId=None):
                     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,
                 )
-        response = {"id": level.id}
-        return HttpResponse(json.dumps(response), content_type="application/javascript")
-    else:
-        return HttpResponseUnauthorized()
+
+    level.save()
+    response = {"id": level.id}
+    return HttpResponse(json.dumps(response), content_type="application/json")
 
 
 @transaction.atomic
@@ -286,7 +339,7 @@ def generate_random_map_for_editor(request):
 
 
 class SharingInformationForEditor(APIView):
-    """Returns a information about who the level can be and is shared with. This uses
+    """Returns information about who the level can be and is shared with. This uses
     the CanShareLevel permission."""
 
     authentication_classes = (SessionAuthentication,)
@@ -320,10 +373,10 @@ class SharingInformationForEditor(APIView):
             ).exclude(id=student.id)
             valid_recipients["classmates"] = [
                 {
-                    "id": classmate.user.user.id,
-                    "name": app_tags.make_into_username(classmate.user.user),
+                    "id": classmate.new_user.id,
+                    "name": app_tags.make_into_username(classmate.new_user),
                     "shared": level.owner == classmate.user
-                    or level.shared_with.filter(id=classmate.user.user.id).exists(),
+                    or level.shared_with.filter(id=classmate.new_user.id).exists(),
                 }
                 for classmate in classmates
             ]
@@ -331,10 +384,10 @@ class SharingInformationForEditor(APIView):
             # Then add their teacher as well
             teacher = class_.teacher
             valid_recipients["teacher"] = {
-                "id": teacher.user.user.id,
-                "name": app_tags.make_into_username(teacher.user.user),
+                "id": teacher.new_user.id,
+                "name": app_tags.make_into_username(teacher.new_user),
                 "shared": level.owner == teacher.user
-                or level.shared_with.filter(id=teacher.user.user.id).exists(),
+                or level.shared_with.filter(id=teacher.new_user.id).exists(),
             }
 
         elif hasattr(userprofile, "teacher"):
@@ -342,22 +395,29 @@ class SharingInformationForEditor(APIView):
 
             # First get all the students they teach
             valid_recipients["classes"] = []
-            classes_taught = Class.objects.filter(teacher=teacher)
+            if teacher.is_admin:
+                classes_taught = teacher.school.classes()
+            else:
+                classes_taught = teacher.class_teacher.all()
             for class_ in classes_taught:
                 students = Student.objects.filter(
                     class_field=class_, new_user__is_active=True
                 )
                 valid_recipients["classes"].append(
                     {
-                        "name": 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": [
                             {
-                                "id": student.user.user.id,
-                                "name": app_tags.make_into_username(student.user.user),
+                                "id": student.new_user.id,
+                                "name": app_tags.make_into_username(student.new_user),
                                 "shared": level.owner == student.user
                                 or level.shared_with.filter(
-                                    id=student.user.user.id
+                                    id=student.new_user.id
                                 ).exists(),
                             }
                             for student in students
@@ -371,11 +431,12 @@ class SharingInformationForEditor(APIView):
                 fellow_teachers = Teacher.objects.filter(school=teacher.school)
                 valid_recipients["teachers"] = [
                     {
-                        "id": fellow_teacher.user.user.id,
-                        "name": app_tags.make_into_username(fellow_teacher.user.user),
+                        "id": fellow_teacher.new_user.id,
+                        "name": app_tags.make_into_username(fellow_teacher.new_user),
+                        "admin": fellow_teacher.is_admin,
                         "shared": level.owner == fellow_teacher.user
                         or level.shared_with.filter(
-                            id=fellow_teacher.user.user.id
+                            id=fellow_teacher.new_user.id
                         ).exists(),
                     }
                     for fellow_teacher in fellow_teachers