feat: Manage courses

- Added tables of courses and usercourses
- Added some columns to exercise
- Fixed the view template and user template
- Fixed the upload method

Author: orronai

lms/lmsdb/models.py

@@ -1,12 +1,12 @@
-from collections import Counter
+from collections import Counter, defaultdict
 import enum
 import html
 import secrets
 import string
 from datetime import datetime
 from typing import (
-    Any, Dict, Iterable, List, Optional, TYPE_CHECKING, Tuple,
-    Type, Union, cast,
+    Any, DefaultDict, Dict, Iterable, List, Optional,
+    TYPE_CHECKING, Tuple, Type, Union, cast,
 )
 
 from flask_babel import gettext as _  # type: ignore
@@ -27,7 +27,7 @@
 
 
 database = database_config.get_db_instance()
-ExercisesDictById = Dict[int, Dict[str, Any]]
+ExercisesDictById = DefaultDict[str, Dict[int, Dict[str, Any]]]
 if TYPE_CHECKING:
     from lms.extractors.base import File
 
@@ -121,6 +121,17 @@ def is_viewer(self) -> bool:
         return self.name == RoleOptions.VIEWER.value or self.is_manager
 
 
+class Course(BaseModel):
+    name = CharField(unique=True)
+    date = DateTimeField()
+    due_date = DateTimeField(null=True)
+    is_finished = BooleanField(default=False)
+    close_registration_date = DateTimeField(default=datetime.now)
+
+    def __str__(self):
+        return f'{self.name}: {self.date} - {self.due_date}'
+
+
 class User(UserMixin, BaseModel):
     username = CharField(unique=True)
     fullname = CharField()
@@ -199,6 +210,25 @@ def on_save_handler(model_class, instance, created):
         instance.api_key = generate_password_hash(instance.api_key)
 
 
+class UserCourse(BaseModel):
+    user = ForeignKeyField(User, backref='usercourses')
+    course = ForeignKeyField(Course, backref='usercourses')
+    date = DateTimeField(default=datetime.now)
+
+    @classmethod
+    def is_user_registered(cls, user_id: int, course_id: int) -> bool:
+        return (
+            cls.
+            select()
+            .join(User)
+            .where(User.id == user_id)
+            .switch()
+            .join(Course)
+            .where(Course.id == course_id)
+            .exists()
+        )
+
+
 class Notification(BaseModel):
     ID_FIELD_NAME = 'id'
     MAX_PER_USER = 10
@@ -288,15 +318,30 @@ class Exercise(BaseModel):
     due_date = DateTimeField(null=True)
     notebook_num = IntegerField(default=0)
     order = IntegerField(default=0, index=True)
+    course = ForeignKeyField(Course, backref='exercise')
+    number = IntegerField()
+
+    class Meta:
+        indexes = (
+            (('course_id', 'number'), True),
+        )
 
     def open_for_new_solutions(self) -> bool:
         if self.due_date is None:
             return not self.is_archived
         return datetime.now() < self.due_date and not self.is_archived
 
     @classmethod
-    def get_objects(cls, fetch_archived: bool = False):
-        exercises = cls.select().order_by(Exercise.order)
+    def get_objects(cls, user_id: int, fetch_archived: bool = False):
+        exercises = (
+            cls
+            .select()
+            .join(Course)
+            .join(UserCourse)
+            .where(UserCourse.user == user_id)
+            .switch()
+            .order_by(UserCourse.date, Exercise.order)
+        )
         if not fetch_archived:
             exercises = exercises.where(cls.is_archived == False)  # NOQA: E712
         return exercises
@@ -308,11 +353,17 @@ def as_dict(self) -> Dict[str, Any]:
             'is_archived': self.is_archived,
             'notebook': self.notebook_num,
             'due_date': self.due_date,
+            'exercise_number': self.number,
+            'course_id': self.course.id,
+            'course_name': self.course.name,
         }
 
     @staticmethod
     def as_dicts(exercises: Iterable['Exercise']) -> ExercisesDictById:
-        return {exercise.id: exercise.as_dict() for exercise in exercises}
+        nested_dict = defaultdict(dict)
+        for exercise in exercises:
+            nested_dict[exercise.course.name][exercise.id] = exercise.as_dict()
+        return nested_dict
 
     def __str__(self):
         return self.subject
@@ -422,25 +473,27 @@ def test_results(self) -> Iterable[dict]:
     @classmethod
     def of_user(
         cls, user_id: int, with_archived: bool = False,
-    ) -> Iterable[Dict[str, Any]]:
-        db_exercises = Exercise.get_objects(fetch_archived=with_archived)
+    ) -> Iterable[DefaultDict[str, Dict[str, Any]]]:
+        db_exercises = Exercise.get_objects(
+            user_id=user_id, fetch_archived=with_archived,
+        )
         exercises = Exercise.as_dicts(db_exercises)
-
         solutions = (
             cls
             .select(cls.exercise, cls.id, cls.state, cls.checker)
             .where(cls.exercise.in_(db_exercises), cls.solver == user_id)
             .order_by(cls.submission_timestamp.desc())
         )
         for solution in solutions:
-            exercise = exercises[solution.exercise_id]
+            course_name = solution.exercise.course.name
+            exercise = exercises[course_name][solution.exercise_id]
             if exercise.get('solution_id') is None:
                 exercise['solution_id'] = solution.id
                 exercise['is_checked'] = solution.is_checked
                 exercise['comments_num'] = len(solution.staff_comments)
                 if solution.is_checked and solution.checker:
                     exercise['checker'] = solution.checker.fullname
-        return tuple(exercises.values())
+        return exercises
 
     @property
     def comments(self):

lms/lmsweb/views.py

@@ -14,7 +14,7 @@
 
 from lms.lmsdb.models import (
     ALL_MODELS, Comment, Note, RoleOptions, SharedSolution,
-    Solution, SolutionFile, User, database,
+    Solution, SolutionFile, User, UserCourse, database,
 )
 from lms.lmsweb import babel, limiter, routes, webapp
 from lms.lmsweb.admin import (
@@ -305,10 +305,12 @@ def comment():
     return fail(400, f'Unknown or unset act value "{act}".')
 
 
-@webapp.route('/send/<int:_exercise_id>')
+@webapp.route('/send/<int:course_id>/<int:_exercise_number>')
 @login_required
-def send(_exercise_id):
-    return render_template('upload.html')
+def send(course_id: int, _exercise_number: Optional[int]):
+    if not UserCourse.is_user_registered(current_user.id, course_id):
+        return fail(403, "You aren't allowed to watch this page.")
+    return render_template('upload.html', course_id=course_id)
 
 
 @webapp.route('/user/<int:user_id>')
@@ -331,15 +333,17 @@ def user(user_id):
     )
 
 
-@webapp.route('/send', methods=['GET'])
+@webapp.route('/send/<int:course_id>', methods=['GET'])
 @login_required
-def send_():
-    return render_template('upload.html')
+def send_(course_id: int):
+    if not UserCourse.is_user_registered(current_user.id, course_id):
+        return fail(403, "You aren't allowed to watch this page.")
+    return render_template('upload.html', course_id=course_id)
 
 
-@webapp.route('/upload', methods=['POST'])
+@webapp.route('/upload/<int:course_id>', methods=['POST'])
 @login_required
-def upload_page():
+def upload_page(course_id: int):
     user_id = current_user.id
     user = User.get_or_none(User.id == user_id)  # should never happen
     if user is None:
@@ -354,7 +358,7 @@ def upload_page():
         return fail(422, 'No file was given.')
 
     try:
-        matches, misses = upload.new(user, file)
+        matches, misses = upload.new(user, file, course_id)
     except UploadError as e:
         log.debug(e)
         return fail(400, str(e))

lms/models/upload.py

@@ -3,7 +3,7 @@
 from werkzeug.datastructures import FileStorage
 
 from lms.extractors.base import Extractor, File
-from lms.lmsdb.models import Exercise, Solution, User
+from lms.lmsdb.models import Exercise, Solution, User, UserCourse
 from lms.lmstests.public.identical_tests import tasks as identical_tests_tasks
 from lms.lmstests.public.linters import tasks as linters_tasks
 from lms.lmstests.public.unittests import tasks as unittests_tasks
@@ -23,22 +23,29 @@ def _is_uploaded_before(
 
 
 def _upload_to_db(
-        exercise_id: int,
+        exercise_number: int,
+        course_id: int,
         user: User,
         files: List[File],
         solution_hash: Optional[str] = None,
 ) -> Solution:
-    exercise = Exercise.get_or_none(exercise_id)
+    exercise = Exercise.get_or_none(course=course_id, number=exercise_number)
     if exercise is None:
-        raise UploadError(f'No such exercise id: {exercise_id}')
+        raise UploadError(f'No such exercise id: {exercise_number}')
+    elif not UserCourse.is_user_registered(user.id, course_id):
+        raise UploadError(
+            f'Exercise {exercise_number} is invalid for this user.',
+        )
     elif not exercise.open_for_new_solutions():
         raise UploadError(
-            f'Exercise {exercise_id} is closed for new solutions.')
+            f'Exercise {exercise_number} is closed for new solutions.')
 
     if solution_hash and _is_uploaded_before(user, exercise, solution_hash):
         raise AlreadyExists('You try to reupload an old solution.')
     elif not files:
-        raise UploadError(f'There are no files to upload for {exercise_id}.')
+        raise UploadError(
+            f'There are no files to upload for {exercise_number}.',
+        )
 
     return Solution.create_solution(
         exercise=exercise,
@@ -56,20 +63,24 @@ def _run_auto_checks(solution: Solution) -> None:
         check_ident.apply_async(args=(solution.id,))
 
 
-def new(user: User, file: FileStorage) -> Tuple[List[int], List[int]]:
+def new(
+    user: User, file: FileStorage, course_id: int,
+) -> Tuple[List[int], List[int]]:
     matches: List[int] = []
     misses: List[int] = []
     errors: List[Union[UploadError, AlreadyExists]] = []
-    for exercise_id, files, solution_hash in Extractor(file):
+    for exercise_number, files, solution_hash in Extractor(file):
         try:
-            solution = _upload_to_db(exercise_id, user, files, solution_hash)
+            solution = _upload_to_db(
+                exercise_number, course_id, user, files, solution_hash,
+            )
             _run_auto_checks(solution)
         except (UploadError, AlreadyExists) as e:
             log.debug(e)
             errors.append(e)
-            misses.append(exercise_id)
+            misses.append(exercise_number)
         else:
-            matches.append(exercise_id)
+            matches.append(exercise_number)
 
     if not matches and errors:
         raise UploadError(errors)

lms/static/my.css

@@ -130,7 +130,7 @@ a {
   justify-content: end;
 }
 
-.exercise-id {
+.exercise-number {
   align-items: center;
   border-radius: 100%;
   border: 1px solid;
@@ -142,11 +142,11 @@ a {
   width: 3rem;
 }
 
-.rtl-language > .exercise-id {
+.rtl-language > .exercise-number {
   margin-left: 2em;
 }
 
-.ltr-language > .exercise-id {
+.ltr-language > .exercise-number {
   margin-right: 2em;
 }
 
@@ -876,7 +876,7 @@ code .grader-add .fa {
 }
 
 @media screen and (max-width: 768px) {
-  .exercise-id {
+  .exercise-number {
     display: none;
   }
   .which-notebook {

lms/templates/exercises.html

@@ -9,44 +9,47 @@ <h1 id="exercises-head">{{ _('תרגילים') }}</h1>
       </div>
     </div>
     <div id="exercises">
-      {%- for exercise in exercises %}
-      <div class="exercise">
-        <div class="right-side {{ direction }}-language">
-          <div class="exercise-id">{{ exercise['exercise_id'] }}</div>
-          <div class="exercise-name"><div class="ex-title">{{ exercise['exercise_name'] | e }}</div></div>
-        </div>
-        <div class="left-side">
-          <div class="comments-count">
-            <span class="badge bg-secondary">{{ exercise['comments_num'] }}</span>
-            <span class="visually-hidden">{{ _("הערות על התרגיל") }}</span>
+      {% for course, values in exercises.items() %}
+        <h3>{{ course }}</h3>
+        {%- for exercise in values.values() %}
+        <div class="exercise">
+          <div class="right-side {{ direction }}-language">
+            <div class="exercise-number">{{ exercise['exercise_number'] }}</div>
+            <div class="exercise-name"><div class="ex-title">{{ exercise['exercise_name'] | e }}</div></div>
           </div>
-          {%- if exercise['notebook'] %}
-          <div class="which-notebook">
-            <i class="fa fa-book" aria-hidden="true"></i>
-            {{ exercise['notebook'] }}
+          <div class="left-side">
+            <div class="comments-count">
+              <span class="badge bg-secondary">{{ exercise['comments_num'] }}</span>
+              <span class="visually-hidden">{{ _("הערות על התרגיל") }}</span>
+            </div>
+            {%- if exercise['notebook'] %}
+            <div class="which-notebook">
+              <i class="fa fa-book" aria-hidden="true"></i>
+              {{ exercise['notebook'] }}
+            </div>
+            {%- endif %}
+            {%- if exercise.get('is_checked') is none %}
+              {% set details = {'page': 'send', 'icon': 'upload', 'text': _('שלח'), 'css': 'send', 'page_id': exercise['course_id']} %}
+            {% elif not exercise.get('is_checked') %}
+              {% set details = {'page': 'view', 'icon': 'eye', 'text': _('הצצה'), 'css': 'view', 'page_id': exercise['solution_id']} %}
+            {% else %}
+              {% set details = {'page': 'view', 'icon': 'check-circle-o', 'text': _('לבדיקה'), 'css': 'checked', 'page_id': exercise['solution_id']} %}
+            {% endif -%}
+            {%- if not exercise.get('is_archived') or exercise.get('is_checked') is not none %}
+            <a class="our-button go-{{ details['css'] }}" href="{{ details['page'] }}/{{ details['page_id'] }}">
+              {{ details['text'] | e }}
+              <i class="fa fa-{{ details['icon'] }}" aria-hidden="true"></i>
+            </a>
+            {% endif -%}
+            {% if is_manager %}
+            <a class="our-button our-button-narrow go-grader" href="check/{{ exercise['exercise_id'] }}">
+              <i class="fa fa-graduation-cap" aria-hidden="true"></i>
+            </a>
+            {% endif %}
           </div>
-          {%- endif %}
-          {%- if exercise.get('is_checked') is none %}
-            {% set details = {'page': 'send', 'icon': 'upload', 'text': _('שלח'), 'css': 'send', 'page_id': exercise['exercise_id']} %}
-          {% elif not exercise.get('is_checked') %}
-            {% set details = {'page': 'view', 'icon': 'eye', 'text': _('הצצה'), 'css': 'view', 'page_id': exercise['solution_id']} %}
-          {% else %}
-            {% set details = {'page': 'view', 'icon': 'check-circle-o', 'text': _('לבדיקה'), 'css': 'checked', 'page_id': exercise['solution_id']} %}
-          {% endif -%}
-          {%- if not exercise.get('is_archived') or exercise.get('is_checked') is not none %}
-          <a class="our-button go-{{ details['css'] }}" href="{{ details['page'] }}/{{ details['page_id'] }}">
-            {{ details['text'] | e }}
-            <i class="fa fa-{{ details['icon'] }}" aria-hidden="true"></i>
-          </a>
-          {% endif -%}
-          {% if is_manager %}
-          <a class="our-button our-button-narrow go-grader" href="check/{{ exercise['exercise_id'] }}">
-            <i class="fa fa-graduation-cap" aria-hidden="true"></i>
-          </a>
-          {% endif %}
         </div>
-      </div>
-      {% endfor -%}
+        {% endfor -%}
+      {% endfor %}
       {%- if not fetch_archived %}
       <div class="exercise centered">
         <div id="show-all-exercises-action" class="right-side">