joeni | Gitar

Split result management and course page management

Author: Maarten Vangeneugden
Date: July 18, 2018, 8:08 p.m.
Hash: 46af06c59919431bddcfae463f298f9ee1fe36b6
Parent: 197e97b68f091dd0c249af588da899a26395dee6
Modified files: administration/models.py; administration/templates/administration/roster.djhtml; courses/models.py; courses/templates/courses/course.djhtml; courses/templates/courses/course_results.djhtml; courses/templates/courses/edit_course_items.djhtml; courses/urls.py; courses/views.py

administration/models.py ¶

20 additions and 0 deletions.

View changes Hide changes

from django.core.exceptions import ValidationError
from django.core.validators import MaxValueValidator
from django.utils.translation import ugettext_lazy as _
from django.utils.text import slugify
from django.contrib.auth.models import AbstractUser
from joeni.constants import current_academic_year
import datetime
import os
import uuid
import courses
#from . import roster

def validate_IBAN(value):
    """ Validates if the given value qualifies as a valid IBAN number.
    This validator checks if the structure is valid, and calculates the control
    number if the structure is correct. If the control number fails, or the
    structure is invalid, a ValidationError will be raised. In that case,
    the Error will specify whether the structure is incorrect, or the control
    number is not valid.
    """
    # FIXME: This function is not complete. When there's time, implement
    # as specified at https://nl.wikipedia.org/wiki/International_Bank_Account_Number#Structuur
    if False:
        raise ValidationError(
            _('%(value)s is not a valid IBAN number.'),
            params={'value': value},)
def validate_BIC(value):
    """ Same functionality as validate_IBAN, but for BIC-codes. """
    # FIXME: This function is not complete. When there's time, implement
    # as specified at https://nl.wikipedia.org/wiki/Business_Identifier_Code
    pass

class User(AbstractUser):
    """ Replacement for the standard Django User model. """
    number = models.AutoField(
        primary_key=True,
        help_text=_("The number assigned to this user."),
        )
    created = models.DateField(auto_now_add=True)

    def __str__(self):
        user_data = UserData.objects.filter(user=self)
        if len(user_data) == 0:
            return self.username
        else:
            user_data = user_data[0]
            name = user_data.first_name +" "+ user_data.last_name
            titles = user_data.title.split()
            if len(titles) == 0:
                return name
            else:
                prefix_titles = ""
                suffix_titles = ""
                for title in titles:
                    if title in ["lic.", "prof.", "dr.", "drs.", "bc.", "bacc.", "ing.", "ir." "cand.", "mr.", "dr.h.c.mult.", "dr.h.c.", "dr.mult.", "em. prof.", "prof. em.", "lec."]:
                        prefix_titles += title + " "
                    elif title in ["MSc", "BSc", "MA", "BA", "LLM", "LLB", "PhD", "MD"]:
                        suffix_titles += title + " "
            return prefix_titles + name + " " + suffix_titles.strip()

class UserData(models.Model):
    user = models.OneToOneField("User", on_delete=models.CASCADE, related_name="user_data")
    first_name = models.CharField(max_length=64, blank=False)
    last_name = models.CharField(max_length=64, blank=False)
    title = models.CharField(
        max_length=64,
        blank=True,
        help_text=_("The academic title of this user, if applicable."),
        )
    DOB = models.DateField(
        blank=False,
        #editable=False,  # For testing purposes, decomment in deployment!
        help_text=_("The date of birth of this user."),
        )
    POB = models.CharField(
        max_length=64,
        blank=False,
        #editable=False,  # For testing purposes, decomment in deployment!
        help_text=_("The place of birth of this user."),
        )
    nationality = models.CharField(
        max_length=64,
        blank=False,
        help_text=_("The current nationality of this user."),
        default="Belg",
        )
    # XXX: What if this starts with zeros?
    national_registry_number = models.BigIntegerField(
        blank=True,  # Only possible if Belgian
        # TODO Validator!
        #editable=False,
        help_text=_("The assigned national registry number of this user."),
        )
    civil_status = models.CharField(
        max_length=32,
        choices = (
            ("Single", _("Single")),
            ("Married", _("Married")),
            ("Divorced", _("Divorced")),
            ("Widowed", _("Widowed")),
            ("Partnership", _("Partnership")),
            ),
        blank=False,
        # There may be more; consult http://www.aantrekkingskracht.com/trefwoord/burgerlijke-staat
        # for more information.
        help_text=_("The civil/marital status of the user."),
        )

    is_staff = models.BooleanField(
        default=False,
        help_text=_("Determines if this user is part of the university's staff."),
        )
    is_student = models.BooleanField(
        default=True,
        help_text=_("Indicates if this user is a student at the university."),
        )

    def current_courses(self):
        """Returns a set of all the courses this user has access to.
        For a student, the result is equal to the set of courses in his/her
        curriculum of the current year. For personnel, this equals the set of
        courses that they are connected to."""
        courses_set = set()
        if self.is_student:
            curriculum = Curriculum.objects.filter(student=self.user).get(year=current_academic_year())
            for course in curriculum.courses():
                courses_set.add(course)
        if self.is_staff:
            for course in courses.models.Course.objects.all():
                if self.user in course.course_team():
                    courses_set.add(course)
        return courses_set

    def slug_name(self):
        """Returns a slug name for this user which can be used to reference in
        URLs."""
        same_names = UserData.objects.filter(first_name=self.first_name).filter(last_name=self.last_name)
        if len(same_names) == 1 and same_names[0] == self:
            return slugify(self.first_name +"-"+ self.last_name, allow_unicode=True)
        else:
            number = self.user.number
            return slugify(self.first_name +"-"+ self.last_name +"-"+ str(number), allow_unicode=True)

    # Home address
    home_street = models.CharField(max_length=64, blank=False)
    home_number = models.PositiveSmallIntegerField(blank=False)
    home_bus = models.CharField(max_length=10, null=True, blank=True)
    home_postal_code = models.PositiveIntegerField(blank=False)
    home_city = models.CharField(max_length=64, blank=False)
    home_country = models.CharField(max_length=64, blank=False, default="België")
    home_telephone = models.CharField(
        max_length=64,
        help_text=_("The telephone number for the house address. Prefix 0 can be presented with the national call code in the system (\"32\" for Belgium)."),
        )
    # Study address
    study_street = models.CharField(max_length=64, blank=True, null=True)
    study_number = models.PositiveSmallIntegerField(blank=True, null=True)
    study_bus = models.CharField(max_length=10, null=True, blank=True)
    study_postal_code = models.PositiveSmallIntegerField(blank=True, null=True)
    study_country = models.CharField(max_length=64, blank=True, null=True)
    study_telephone = models.CharField(
        blank=True, null=True,
        max_length=64,
        help_text=_("The telephone number for the study address. Prefix 0 can be presented with the national call code in the system."),
        )
    study_cellphone = models.CharField(
        max_length=64, null=True, blank=True,
        help_text=_("The cellphone number of the person. Prefix 0 can be presented with then national call code in the system."),
        )
    # Titularis address
    # XXX: These fields are only required if this differs from the user itself.
    titularis_street = models.CharField(max_length=64, null=True, blank=True)
    titularis_number = models.PositiveSmallIntegerField(null=True, blank=True)
    titularis_bus = models.CharField(max_length=10, null=True, blank=True)
    titularis_postal_code = models.PositiveSmallIntegerField(null=True, blank=True)
    titularis_country = models.CharField(max_length=64, null=True, blank=True)
    titularis_telephone = models.CharField(
        max_length=64,
        help_text=_("The telephone number of the titularis. Prefix 0 can be presented with the national call code in the system."),
        null=True,
        blank=True,
        )

    # Financial details
    bank_account_number = models.CharField(
        max_length=34,  # Max length of all IBAN account numbers
        validators=[validate_IBAN],
        help_text=_("The IBAN of this user. No spaces!"),
        )
    BIC = models.CharField(
        max_length=11,
        validators=[validate_BIC],
        help_text=_("The BIC of this user's bank."),
        )

""" NOTE: What about all the other features that should be in the administration?
While there are a lot of things to cover, as of now, I have no way to know which
ones are still valid, which are deprecated, and so on...
Additionally, every feature may have a different set of requirements, data,
and it's very likely making an abstract class won't do any good. Thus I have
decided to postpone making additional tables and forms for these features until
I have clearance about certain aspects. """

class Curriculum(models.Model):
    """ The curriculum of a particular student.
    Every academic year, a student has to hand in a curriculum (s)he wishes to
    follow. This is then reviewed by a committee. A curriculum exists of all the
    courses one wants to partake in in a certain year. """
    student = models.ForeignKey(
        "User",
        on_delete=models.CASCADE,
        limit_choices_to={'groups': 1},  # 1 = Students group ID
        null=False,
        #editable=False,
        #unique_for_year="year",  # Only 1 curriculum per year # FIXME to work with integer!
        )
    year = models.PositiveIntegerField(
        null=False,
        default=datetime.date.today().year,
        help_text=_("The academic year for which this curriculum is. "
                    "If this field is equal to 2008, then that means "
                    "this curriculum is for the academic year "
                    "2008-2009."),
        )
    # TODO: Validate changes: A curriculum cannot undergo another change if the
    # academic year it was made in is history.
    last_modified = models.DateTimeField(
        auto_now=True,
        help_text=_("The last timestamp that this was updated."),
        )
    course_programmes = models.ManyToManyField(
        "courses.CourseProgramme",
        blank=False,  # An empty curriculum makes no sense
        help_text=_("All the course programmes included in this curriculum."),
        )
    approved = models.NullBooleanField(
        default=None,
        help_text=_("Indicates if this curriculum has been approved. If true, "
                    "that means the responsible committee has reviewed and "
                    "approved the student for this curriculum. False otherwise. "
                    "If review is still pending, the value is NULL. Modifying "
                    "the curriculum implies this setting is set to NULL again."),
        )
    note = models.TextField(
        blank=True,
        help_text=_("Additional notes regarding this curriculum. This has "
                    "multiple uses. For the student, it is used to clarify "
                    "any questions, or to motivate why (s)he wants to take a "
                    "course for which the requirements were not met. "
                    "The reviewing committee can use this field to argument "
                    "their decision, especially for when the curriculum is "
                    "denied."),
        )

    def course_programmes_results(self):
        """ Returns a dictionary, where the keys are the course_programmes
        in this curriculum, and the values are the course_results associated
        with them."""
        join_dict = dict()
        for course_program in self.course_programmes.all():
            result = CourseResult.objects.filter(
                student=self.student).filter(
                    course_programme=course_program).filter(
                        year=self.year)
            if len(result) == 0:
                join_dict[course_program] = None
            else:
                join_dict[course_program] = result[0]
        return join_dict

    def courses(self):
        """ Returns a set of all the courses that are in this curriculum.
        This is not the same as CourseProgrammes, as these can differ depending
        on which study one follows. """
        course_set = set()
        for course_programme in self.course_programmes.all():
            course_set.add(course_programme.course)
        return course_set

    def curriculum_type(self):
        """ Returns the type of this curriculum. At the moment, this is
        either a standard programme, or an individualized programme. """
        # Currently: A standard programme means: All courses are from the
        # same study, ánd from the same year. Additionally, all courses
        # from that year must've been taken.
        # FIXME: Need a way to determine what is the standard programme.
        # If not possible, make this a charfield with options or something
        pass

    def __str__(self):
        return str(self.student) +" | "+ str(self.year) +"-"+ str(self.year+1)


        """ NOTE: The clean method of Curriculum is rather special, in that it
        creates new model instances based on its current state. Also, it
        prohibits changing the curriculum if the academic year has passed (as if
        the instance has gone in an "archive" state). """
        if self.year != current_academic_year():
            raise ValidationError(
                _('This curriculum is from the academic year %(year)s - %(new_year)s,'
                  ' and can no longer be changed.'),
                params={'year': self.year, 'new_year': self.year + 1})
        if self.approved is True:
            # When approved, add necessary course results and remove scrapped courses
            student_course_results = CourseResult.objects.filter(student=self.student).filter(year=self.year)





class CourseResult(models.Model):
    """ A student has to obtain a certain course result. These are stored here,
    together with all the appropriate information. """
    # TODO: Validate that a course programme for a student can only be made once per year for each course, if possible.
    CRED = _("Credit acquired")
    FAIL = _("Credit not acquired")
    TLRD = _("Tolerated")
    ITLR = _("Tolerance used")
    BDRG = _("Fraud committed")
    VRST = _("Exemption")
    STOP = _("Course cancelled")
    GEEN = _("No result available")
    # Possible to add more in the future

    student = models.ForeignKey(
        "User",
        on_delete=models.CASCADE,
        #limit_choices_to={'is_student': True},
        null=False,
        db_index=True,
        )
    course_programme = models.ForeignKey(
        "courses.CourseProgramme",
        on_delete=models.PROTECT,
        null=False,
        )
    year = models.PositiveIntegerField(
        return self.course_programme.course

    year = models.PositiveIntegerField(
        null=False,
        default=datetime.date.today().year,
        help_text=_("The academic year this course took place in. If 2018 is entered, "
                    "then that means academic year '2018-2019'."),
        )
    released = models.DateField(
        auto_now=True,
        help_text=_("The date that this result was last updated."),
        )
    first_score = models.PositiveSmallIntegerField(
        null=True,  # It's possible a score does not exist.
        blank=True,
        validators=[MaxValueValidator(
            20,
            _("The score mustn't be higher than 20."),
            )],
        )
    second_score = models.PositiveSmallIntegerField(
        null=True,
        blank=True,
        validators=[MaxValueValidator(
            20,
            _("The score mustn't be higher than 20."),
            )],
        )
    result = models.CharField(
        max_length=10,
        choices = (
            ("CRED", CRED),
            ("FAIL", FAIL),
            ("TLRD", TLRD),
            ("ITLR", ITLR),
            ("BDRG", BDRG),
            ("VRST", VRST),
            ("STOP", STOP),
            ("GEEN", GEEN),
            ),
        blank=False,
        default = GEEN,
        help_text=_("The result this record constitutes."),
        )

    def __str__(self):
        stdnum = str(self.student.number)
        result = self.result
        if result == "CRED":
            if self.first_score < 10:
                result = "C" + str(self.first_score) + "1"
            else:
                result = "C" + str(self.second_score) + "2"
        course = str(self.course_programme.course)
        return stdnum +" ("+ result +") | "+ course

class PreRegistration(models.Model):
    """ At the beginning of the new academic year, students can register
    themselves at the university. Online, they can do a preregistration already.
    These records are stored here and can later be retrieved for the actual
    registration process.
    Note: The current system in use at Hasselt University provides a password system.
    That will be eliminated here. Just make sure that the entered details are correct.
    Should there be an error, and the same email address is used to update something,
    a mail will be sent to that address to verify this was a genuine update."""
    created = models.DateField(auto_now_add=True)
    first_name = models.CharField(max_length=64, blank=False, help_text=_("Your first name."))
    last_name = models.CharField(max_length=64, blank=False, help_text=_("Your last name."))
    additional_names = models.CharField(max_length=64, blank=True, help_text=_("Any additional names."))
    title = models.CharField(
        max_length=64,
        blank=True,
        help_text=_("Any additional titles, prefixes, ..."),
        )
    DOB = models.DateField(
        blank=False,
        #editable=False,
        help_text=_("Your date of birth."),
        )
    POB = models.CharField(
        max_length=64,
        blank=False,
        #editable=False,
        help_text=_("The place you were born."),
        )
    nationality = models.CharField(
        max_length=64,
        blank=False,
        help_text=_("Your current nationality."),
        )
    national_registry_number = models.BigIntegerField(
        null=True,
        help_text=_("If you have one, your national registry number."),
        )
    civil_status = models.CharField(
        max_length=32,
        choices = (
            ("Single", _("Single")),
            ("Married", _("Married")),
            ("Divorced", _("Divorced")),
            ("Widowed", _("Widowed")),
            ("Partnership", _("Partnership")),
            ),
        blank=False,
        # There may be more; consult http://www.aantrekkingskracht.com/trefwoord/burgerlijke-staat
        # for more information.
        help_text=_("Your civil/marital status."),
        )
    email = models.EmailField(
        blank=False,
        unique=True,
        help_text=_("The e-mail address we will use to communicate until your actual registration."),
        )
    study = models.ForeignKey(
        "courses.Study",
        on_delete=models.PROTECT,
        null=False,
        help_text=_("The study you wish to follow. Be sure to provide all legal"
                    "documents that are required for this study with this "
                    "application, or bring them with you to the final registration."),
        )
    study_type = models.CharField(
        max_length=32,
        choices = (
            ("Diplom contract", _("Diplom contract")),
            ("Exam contract", _("Exam contract")),
            ("Credit contract", _("Credit contract")),
            ),
        blank=False,
        help_text=_("The type of study contract you wish to follow."),
        )
    document = models.FileField(
        upload_to="pre-enrollment/%Y",
        help_text=_("Any legal documents regarding your enrollment."),
        )
    # XXX: If the database in production is PostgreSQL, comment document, and
    # uncomment the next column.
    """documents = models.ArrayField(
        models.FileField(upload_to="pre-enrollment/%Y"),
        help_text=_("Any legal documents regarding your enrollment."),
        )"""

    def __str__(self):
        name = self.last_name +" "+ self.first_name
        dob = self.DOB.strftime("%d/%m/%Y")
        return name +" | "+ dob


# Planning and organization related tables
class Room(models.Model):
    """ Represents a room in the university.
    Rooms can have a number of properties, which are stored in the database.
    """
    # Types of rooms
    LABORATORY = _("Laboratory")  # Chemistry/Physics equipped rooms
    CLASS_ROOM = _("Class room")  # Simple class rooms
    AUDITORIUM = _("Auditorium")  # Large rooms with ample seating and equipment for lectures
    PC_ROOM    = _("PC room"   )  # Rooms equipped for executing PC related tasks
    PUBLIC_ROOM= _("Public room") # Restaurants, restrooms, ... general public spaces
    OFFICE     = _("Office"    )  # Private offices for staff
    PRIVATE_ROOM = _("Private room")  # Rooms accessible for a limited public; cleaning cupboards, kitchens, ...
    WORKSHOP   = _("Workshop"  )  # Rooms with hardware equipment to build and work on materials
    OTHER      = _("Other"     )  # Rooms that do not fit in any other category


    name = models.CharField(
        max_length=20,
        primary_key=True,
        blank=False,
        help_text=_("The name of this room. If more appropriate, this can be the colloquial name."),
        )
    seats = models.PositiveSmallIntegerField(
        help_text=_("The amount of available seats in this room."),
        )
    wheelchair_accessible = models.BooleanField(default=True)
    exams_equipped = models.BooleanField(
        default=True,
        help_text=_("Indicates if exams can reasonably be held in this room."),
        )
    loose_tables = models.BooleanField(
        default=True,
        help_text=_("If true, the tables in this room can be moved freely. "
                    "If false, they're bolted down in their positions."),
        )
    electrical_plugs = models.PositiveSmallIntegerField(
        help_text=_("The amount of electrical plugs that are available to the "
                    "people for free use. Electrical plugs that are more or "
                    "less constantly occupied by permanent equipment (such as "
                    "computers, beamers, ...) are excluded from counting."),
        )
    exterior_window = models.BooleanField(
        default=True,
        help_text=_("Indicates if this room has a window to the outside."),
        )
    software_available = models.TextField(
        blank=True,
        help_text=_("Some software used at the university is proprietary, and "
                    "thus not available at every system. If certain "
                    "software is installed on the computers in this room that "
                    "cannot be found on other computers, list them here."),
        )
    computers_available = models.PositiveSmallIntegerField(
        default=0,
        help_text=_("Indicates how many computers are available in this room."),
        )
    projector_available = models.BooleanField(
        default=False,
        help_text=_("Indicates if a projector is available at this room."),
        )
    blackboards_available = models.PositiveSmallIntegerField(
        help_text=_("The amount of blackboards available in this room."),
        )
    whiteboards_available = models.PositiveSmallIntegerField(
        help_text=_("The amount of whiteboards available in this room."),
        )
    category = models.CharField(
        max_length=16,
        blank=False,
        choices = (
            ("LABORATORY", LABORATORY),
            ("CLASS_ROOM", CLASS_ROOM),
            ("AUDITORIUM", AUDITORIUM),
            ("PC_ROOM", PC_ROOM),
            ("PUBLIC_ROOM", PUBLIC_ROOM),
            ("OFFICE", OFFICE),
            ("PRIVATE_ROOM", PRIVATE_ROOM),
            ("WORKSHOP", WORKSHOP),
            ("OTHER", OTHER),
            ),
        help_text=_("The category that best suits the character of this room."),
        )
    reservable = models.BooleanField(
        default=True,
        help_text=_("Indicates if this room can be reserved for something."),
        )
    note = models.TextField(
        blank=True,
        help_text=_("If some additional info is required for this room, like a "
                    "characteristic property (e.g. 'Usually occupied by 2BACH "
                    "informatics'), state it here."),
        )
    # TODO: Add a campus/building field or not?

    def next_reservation(self, time):
        """ Returns the next reservation starting from the given time, or, if
        the next reservation starts on the given time, that reservation.
        Returns None if there is no reservation from this moment on."""
        reservations = RoomReservation.objects.filter(room=self).filter(begin_time__gte=time).order_by('begin_time')
        if len(reservations) == 0:
            return None
        else:
            return reservations[0]
    def next_event(self, time):
        """ Returns the next event starting from the given time, or, if
        the next event starts on the given time, that event.
        Returns None if there is no event from this moment on."""
        events = CourseEvent.objects.filter(room=self).filter(begin_time__gte=time).order_by('begin_time')
        if len(events) == 0:
            return None
        else:
            return events[0]


    def reservation_possible(self, begin, end, seats=None):
        # TODO: Include events in the check for possibilities!
        """ Returns a boolean indicating if reservating during the given time
        is possible. If the begin overlaps with a reservation's end or vice versa,
        this is regarded as possible.
        Takes seats as optional argument. If not specified, it is assumed the entire
        room has to be reserved. """
        if self.reservable is False:
            return False
        if seats is not None and seats < 0: raise ValueError(_("seats ∈ ℕ"))

        reservations = RoomReservation.objects.filter(room=self)
        for reservation in reservations:
            if reservation.end_time <= begin or reservation.begin_time >= end:
                continue  # Can be trivially skipped, no overlap here
            elif seats is None or reservation.seats is None:
                return False  # The whole room cannot be reserved -> False
            elif seats + reservation.seats > self.seats:
                    return False  # Total amount of seats exceeds the available amount -> False
        return True  # No overlappings found -> True

    def __str__(self):
        return self.name


# Validators that will be used for RoomReservations and Events
def validate_event_time(time):
    """Checks if the time is a quarter of an hour (0, 15, 30, or 45)."""
    if time.minute not in [0, 15, 30, 45] or time.second != 0:
        raise ValidationError(
            _('%(time)s is not in the quarter of an hour.'),
            params={'time': time.strftime("%H:%M")})
def validate_university_hours(value):
    """Checks if the datetime value given takes place during the opening hours
    of the university (08:00 - 20:00)."""
    if value.hour < 8 or (value.hour == 22 and value.minute != 0) or value.hour >= 23:
        raise ValidationError(
            _("All events and reservations must begin and end between 08:00 "
              "and 22:00."))
def overlaps(begin_a, end_a, begin_b, end_b):
    """Checks if timespan a and b overlap with each other. If one of them ends at
    the same time the other one begins, it does not count as an overlap.
    This function assumes the end takes place strictly /after/ the begin."""
    if end_a <= begin_b or end_b <= begin_a:
        return False
    if (
            begin_a < begin_b <= end_a or
            begin_b < begin_a <= end_b or
            begin_a <= end_b < end_a or
            begin_b <= end_a < end_b):
        return True
    else:
        return False


def general_reservation_validator(self):
    # Check for overlapping reservations
    # TODO: Try to make it possible to link to the reservator,
    # to display the reason, to show the available times that a
    # reservation can be made for that room, and so on... Make it
    # a bit more interactive.
    for reservation in RoomReservation.objects.filter(room=self.room):
        if overlaps(self.begin_time,
                    self.end_time,
                    reservation.begin_time,
                    reservation.end_time):
            if isinstance(self, RoomReservation):
                if self.room.reservation_possible(self.begin_time, self.end_time, self.seats):
                    continue  # Both reservations can take place in the same room
                raise ValidationError(
                _("It is not possible to plan this event/reservation in "
                "%(room)s from %(self_begin)s to %(end_begin)s on %(day)s. "
                "%(reservator)s has already "
                "reserved it from %(res_begin)s to %(res_end)s."),
                params={'room': str(self.room),
                        'self_begin': self.begin_time.strftime("%H:%M"),
                        'self_end': self.end_time.strftime("%H:%M"),
                        'day': self.begin_time.strftime("%A (%d/%m)"),
                        'reservator': str(reservation.reservator),
                        'res_begin': reservation.begin_time.strftime("%H:%M"),
                        'res_end': reservation.end_time.strftime("%H:%M"),
                        })
    for course_event in CourseEvent.objects.filter(room=self.room):
        if overlaps(self.begin_time,
                    self.end_time,
                    course_event.begin_time,
                    course_event.end_time):
            raise ValidationError(
                _("%(docent)s has organized a %(subject)s in %(room)s from "
                    "%(res_begin)s to %(res_end)s on %(day)s, so you cannot "
                    "place a reservation there from %(self_begin)s to "
                    "%(self_end)s."),
                params={'room': str(self.room),
                        'self_begin': self.begin_time.strftime("%H:%M"),
                        'self_end': self.end_time.strftime("%H:%M"),
                        'day': self.begin_time.strftime("%A (%d/%m)"),
                        'docent': str(course_event.docent),
                        'subject': course_event.subject,
                        'res_begin': course_event.begin_time.strftime("%H:%M"),
                        'res_end': course_event.end_time.strftime("%H:%M"),})

    # Checking for correct timings:
    if self.begin_time >= self.end_time:
        raise ValidationError(
            _("The begin time (%(begin)) must take place <em>before</em> "
                "the end time (%(end))."),
            params={'begin': self.begin_time.strftime("%H:%M"),
                    'end': self.end_time.strftime("%H:%M"),})
    """if not roster.same_day(self.begin_time, self.end_time):
        raise ValidationError(
            _("The event/reservation must begin and end on the same day."))"""


class RoomReservation(models.Model):
    """ Rooms are to be reserved from time to time. They can be reserved
    by externals, for something else, and whatnot. That is stored in this table.
    """
    room = models.ForeignKey(
        "Room",
        on_delete=models.CASCADE,
        null=False,
        #editable=False,
        db_index=True,
        limit_choices_to={"reservable": True},
        help_text=_("The room that is being reserved at this point."),
    )
    reservator = models.ForeignKey(
        "User",
        on_delete=models.CASCADE,
        null=False,
        #editable=False,
        help_text=_("The person that made the reservation (and thus responsible)."),
    )
    timestamp = models.DateTimeField(auto_now_add=True)
    begin_time = models.DateTimeField(
        null=False,
        help_text=_("The time that this reservation begin."),
        validators=[validate_event_time,validate_university_hours],
    )
    end_time = models.DateTimeField(
        null=False,
        help_text=_("The time that this reservation ends."),
        validators=[validate_event_time,validate_university_hours],
    )
    seats = models.PositiveSmallIntegerField(
        null=True,
        blank=True,
        help_text=_("Indicates how many seats are required. If this is left empty, "
                    "it is assumed the entire room has to be reserved."),
    )
    reason = models.CharField(
        max_length=64,
        blank=True,
        help_text=_("The reason for this reservation, if useful."),
    )
    note = models.TextField(
        blank=True,
        help_text=_("If some additional info is required for this reservation, "
                    "state it here."),
    )

    def __str__(self):
        start = self.start_time.strftime("%H:%M")
        end = self.end_time.strftime("%H:%M")
        return str(self.room) +" | "+ start +"-"+ end

    def clean(self):
        general_reservation_validator(self)

class Degree(models.Model):
    """ Contains all degrees that were achieved at this university.
    There are no foreign keys in this field. This allows system
    administrators to safely remove accounts from alumni, without
    the risk of breaking referential integrity or accidentally removing
    degrees.
    While keeping some fields editable that look like they shouldn't be
    (e.g. first_name), this makes it possible for alumni to have a name change
    later in their life, and still being able to get a copy of their degree. """
    """ Reason for an ID field for every degree:
    This system allows for employers to verify that a certain applicant has indeed,
    achieved the degrees (s)he proclaims to have. Because of privacy concerns,
    a university cannot disclose information about alumni.
    That's where the degree ID comes in. This ID can be printed on all future
    degrees. The employer can then visit the university's website, and simply
    enter the ID. The website will then simply print what study is attached to
    this degree, but not disclose names or anything identifiable. This strikes
    thé perfect balance between (easy and digital) degree verification for employers, and maintaining
    alumni privacy to the highest extent possible. """
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    first_name = models.CharField(
        max_length=64,
        blank=False,
        )
    last_name = models.CharField(
        max_length=64,
        blank=False,
        )
    additional_names = models.CharField(
        max_length=64,
        blank=True,
        )
    DOB = models.DateField(null=False)#editable=False, null=False)  # This can't be changed, of course
    POB = models.CharField(
        max_length=64,
        blank=False,
        #editable=False,
        )
    # The study also has to be a charfield, because if a study is removed,
    # The information will be lost.
    study = models.CharField(
        max_length=64,
        blank=False,
        #editable=False,
        )
    achieved = models.DateField(null=False)#editable=False, null=False)
    user = models.ForeignKey(
        "User",
        on_delete=models.SET_NULL,
        null=True,
        help_text=_("The person that achieved this degree, if (s)he still has "
                    "an account at this university. If the account is deleted "
                    "at a later date, this field will be set to NULL, but the "
                    "other fields will be retained."),
        )

    def __str__(self):
        return self.first_name +" "+ self.last_name +" | "+ self.study


# Classes regarding roster items


class Event(models.Model):
    """An event that will show up in the roster of accounts that need to be
    aware of this event. This can be a multitude of things, like colleges
    for certain courses, meetings like blood donations, and so on. There are
    specialized classes for certain types of events that take place."""
    begin_time = models.DateTimeField(
        null=False,
        help_text=_("The begin date and time that this event takes place. "
                    "This value must be a quarter of an hour (0, 15, 30, 45), "
                    "and take place <em>before</em> this event's end time."),
        verbose_name=_("begin time"),
        validators=[validate_event_time, validate_university_hours],
        )
    end_time = models.DateTimeField(
        null=False,
        help_text=_("The end date and time that this event takes place. "
                    "This value must be a quarter of an hour (0, 15, 30, 45), "
                    "and take place <em>after</em> this event's begin time, "
                    "but it must end on the same day as it begins!"),
        verbose_name=_("end time"),
        validators=[validate_event_time, validate_university_hours],
        )
    note = models.TextField(
        blank=True,
        help_text=_("Optional. If necessary, this field allows for additional "
                    "information that can be shown to the people for whom this "
                    "event is."),
        )
    created = models.DateTimeField(
        auto_now_add=True,
        )
    last_update = models.DateTimeField(
        auto_now=True,
        )

    def recently_created(self):
        """Indicates if this event was created in the last 5 days."""
        return (datetime.datetime.now(datetime.timezone.utc) - self.created).days <= 5
    def recently_updated(self):
        """Indicates if this event was updated in the last 5 days."""
        return (datetime.datetime.now(datetime.timezone.utc) - self.last_update).days <= 5

class CourseEvent(Event):
    """An event related to a particular course. This includes a location,
    a group (if applicable), and other data."""
    course = models.ForeignKey(
        "courses.CourseProgramme",
        on_delete=models.CASCADE,
        null=False,
        )
    docent = models.ForeignKey(
        "User",
        on_delete=models.PROTECT,
        null=False,
        limit_choices_to={'is_staff': True},
        help_text=_("The person who will be the main overseer of this event."),
        )
    room = models.ForeignKey(
        "Room",
        on_delete=models.PROTECT,
        limit_choices_to={'reservable': True},
        null=False,
        help_text=_("The room in which this event will be held."),
        )
    subject = models.CharField(
        max_length=32,
        blank=False,
        help_text=_("The subject of this event. Examples are 'Hoorcollege', "
                    "'Zelfstudie', ..."),
        )
    group = models.ForeignKey(
        "courses.CourseGroup",
        on_delete = models.CASCADE,
        null=True,
        blank=True,
        help_text=_("Some courses have multiple groups. If that's the case, "
                    "and this event is only for a specific group, then that "
                    "group must be referenced here."),
        )

    def clean(self):
        general_reservation_validator(self)


class UniversityEvent(Event):
    """University wide events. These include events like blood donations for the
    Red Cross, for example."""
    pass

class StudyEvent(Event):
    """An event that is linked to a particular study, like lectures from guest
    speakers about a certain subject, the Flemish Programming Contest, ..."""
    pass

class ExamCommissionDecision(models.Model):
    """The Exam commission can make certain decisions regarding individual
    students. Every decision on its own is stored in this table, and is linked
    to the recipient's account."""
    user = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        null=False,
        help_text=_("The recipient of this decision."),
        )
    date = models.DateField(auto_now_add=True)
    text = models.TextField(
        blank=False,
        help_text=_("The text describing the decision. Org syntax available.")
        )
    def __str__(self):
        return str(self.user) + " | " + str(self.date)

    class Meta:
        verbose_name = _("Decision of the exam commission")
        verbose_name_plural = _("Decisions of the exam commission")

class EducationDepartmentMessages(models.Model):
    """The department of education can issue messages that are to be shown to
    all students. Their contents are stored here."""
    date = models.DateField(auto_now_add=True)
    title = models.CharField(
        max_length=64,
        blank=False,
        help_text=_("A short, well-describing title for this message."),
        )
    text = models.TextField(
        blank=False,
        help_text=_("The message text. Org syntax available.")
        )
    def __str__(self):
        return str(self.date) + " | " + str(self.title)

    class Meta:
        verbose_name = _("Message of the education department")
        verbose_name_plural = _("Messages of the education department")


administration/templates/administration/roster.djhtml ¶

3 additions and 0 deletions.

View changes Hide changes

{% cycle "hour" "first quarter" "half" "last quarter" as hour silent %}
{# "silent" blocks the cycle operator from printing the cycler, and in subsequent calls #}
{% load i18n %}

{% block title %}
    {% trans "Roster" %} | {{ block.super }}
{% endblock %}

{% block main %}
    <h1>{% trans "Personal timetable" %}</h1>
    <h2>{% trans "Main hour roster" %}</h2>


    {% include "administration/roster_t.djhtml" %}


        <a class="btn" href="{% url "administration-roster" begin=prev_begin end=prev_end %}">
            {% trans "Previous week" %}
        </a>
        <a class="btn" href="{% url "administration-roster" %}">
            {% trans "Current week" %}
        </a>
        <a class="btn" href="{% url "administration-roster" begin=next_begin end=next_end %}">
            {% trans "Next week" %}
        </a>
        {# TODO: Add links to "previous week", "next week" and "current week" with large buttons #}
            {% trans "ICS file" %}
        </a>
        {# TODO: Add links to "previous week", "next week" and "current week" with large buttons #}

    <h2>{% trans "Explanation" %}</h2>
    <p>
        {% trans "Personal roster from" %} {{ begin|date }} {% trans "to" %} {{ end|date }}
    </p>
    <p>
        {% blocktrans %}
            Some fields may have additional information that might be of interest
            to you. This information is shown in different ways with colour codes.
        {% endblocktrans %}
    </p>

    <dl>
        <dt><span class="event-update">
            {% trans "Recent event update" %}
        </span></dt>
        <dd>
            {% blocktrans %}
                This event had one or more of its properties changed
                in the last five days. This can be the room, the hours, the subject, ...
                You're encouraged to take note of that.
            {% endblocktrans %}
        </dd>
        <dt><span class="event-new">
            {% trans "New event" %}
        </span></dt>
        <dd>
            {% blocktrans %}
                This is a new event, added in the last five days.
            {% endblocktrans %}
        </dd>
        <dt><span class="event-note">
            {% trans "Notification available" %}
        </span></dt>
        <dd>
            {% blocktrans %}
                This event has a note attached to it by the docent. Hover over
                the event to display the note.
            {% endblocktrans %}
        </dd>
    </dl>

{% endblock main %}


courses/models.py ¶

9 additions and 0 deletions.

View changes Hide changes

from joeni import constants
from django.utils.translation import ugettext_lazy as _

def validate_hex_color(value):
    pass  # TODO

class Course(models.Model):
    """ Represents a course that is taught at the university. """
    number = models.PositiveSmallIntegerField(
        primary_key=True,
        blank=False,
        help_text=_("The number associated with this course. A leading '0' will be added if the number is smaller than 1000."),
        )
    name = models.CharField(
        max_length=64,
        blank=False,
        help_text=_("The name of this course, in the language that it is taught. Translations are for the appropriate template."),
        )
    color = models.CharField(
        max_length=6,
        blank=False,
        default=constants.COLORS['UHasselt default'],
        help_text=_("The color for this course. Must be an hexadecimal code. "
                    "Some standard colors if you don't know what to pick: "
                    "<ul><li>0076BE: Faculty of Sciences / Blue</li>"
                    "<li>C0D633: Faculty of Transportation Sciences / Green</li>"
                    "<li>F4802D: Faculty of Architecture and Arts / Orange</li>"
                    "<li>00ACEE: Faculty of Business Economics / Turquoise</li>"
                    "<li>9C3591: Faculty of Medicine and Life Sciences / Purple</li>"
                    "<li>5BC4BA: Faculty of Engineering Technology / Light blue</li>"
                    "<li>E41F3A: Faculty of Law / Red</li></ul>"),
        #validators=['validate_hex_color'], # TODO
        )
    slug_name = models.SlugField(
        blank=False,
        allow_unicode=True,
        unique=True,
        help_text=_("A so-called 'slug name' for this course."),
        )
    # TODO: Add a potential thingy magicky to auto fill the slug name on the course name
    contact_person = models.ForeignKey(
        "administration.User",
        on_delete=models.PROTECT,  # A course must have a contact person
        limit_choices_to={'is_staff': True},
        null=False,
        help_text=_("The person to contact regarding this course."),
        related_name="contact_person",
        )
    coordinator = models.ForeignKey(
        "administration.User",
        on_delete=models.PROTECT,  # A course must have a coordinator
        limit_choices_to={'is_staff': True},
        null=False,
        help_text=_("The person whom's the coordinator of this course."),
        related_name="coordinator",
        )
    co_owners = models.ManyToManyField(
        "administration.User",
        limit_choices_to={'is_staff': True},
        blank=True,  # Allows empty in form validation, and M->M implies null=True
        help_text=_("If applicable: The co-owners of this course."),
        related_name="co_owners",
        )

    educating_team = models.ManyToManyField(
        "administration.User",
        # No on_delete, since M->M cannot be required at database level
        limit_choices_to={'is_staff': True},
        blank=True,
        help_text=_("The remaining team members of this course."),
        related_name="educating_team",
        )
    language = models.CharField(
        max_length=64,
        choices = (
            ('NL', _("Dutch")),
            ('EN', _("English")),
            ('FR', _("French")),
            ),
        null=False,
        help_text=_("The language in which this course is given."),
        )

    def course_team(self):
        """ Returns a set of all Users that are part of the team of this course. """
        return set().union(
            {self.contact_person,
             self.coordinator,},
            self.educating_team.iterator(),
            self.co_owners.iterator())

    def __str__(self):
        number = str(self.number)
        for i in [10,100,1000]:
            if self.number < i:
                number = "0" + number
        return "(" + number + ") " + self.name


        """Returns a list of all students that are following this course."""
        stud_in_course = list()
        for student in administration.models.User.objects.all():
            if self in student.current_courses:
                stud_in_course.append(student)
        return stud_in_course



class Prerequisite(models.Model):
    """ Represents a collection of prerequisites a student must have obtained
    before being allowed to partake in this course.
    It's possible that, if a student has obtained credits in a certain set of
    courses, a certain part of the prerequisites do not have to be obtained.
    Because of this, make a different record for each different set. In other
    words: If one set of prerequisites is obtained, and another one isn't, BUT
    they point to the same course, the student is allowed to partake. """
    course = models.ForeignKey(
        "Course",
        on_delete=models.CASCADE,
        null=False,
        help_text=_("The course that these prerequisites are for."),
        related_name="prerequisite_course",
        )
    name = models.CharField(
        max_length=64,
        blank=True,
        help_text=_("To specify a name for this set, if necessary."),
        )
    sequentialities = models.ManyToManyField(
        "Course",
        help_text=_("All courses for which a credit must've been received in order to follow the course."),
        blank=True,
        related_name="sequentialities",
        )
    in_curriculum = models.ManyToManyField(
        "Course",
        help_text=_("All courses that have to be in the curriculum to follow this. If a credit was achieved, that course can be omitted."),
        blank=True,
        related_name="in_curriculum",
        )
    required_study = models.ForeignKey(
        "Study",
        on_delete=models.CASCADE,
        blank=True,
        null=True,
        help_text=_("If one must have a certain amount of obtained ECTS points for a particular course, state that course here."),
        )
    ECTS_for_required_study = models.PositiveSmallIntegerField(
        blank=True,
        null=True,
        help_text=_("The amount of obtained ECTS points for the required course, if any."),
        )

    def __str__(self):
        if self.name == "":
            return _("Prerequisites for %(course)s") % {'course': str(self.course)}
        else:
            return self.name + " | " + str(self.course)


class CourseProgramme(models.Model):
    """ It's possible that a course is taught in multiple degree programmes; For
    example: Calculus can easily be taught to physics and mathematics students
    alike. In this table, these relations are set up, and the related properties
    are defined as well. """
    study = models.ForeignKey(
        "Study",
        on_delete=models.CASCADE,
        null=False,
        help_text=_("The study in which the course is taught."),
        )
    course = models.ForeignKey(
        "Course",
        on_delete=models.CASCADE,
        null=False,
        help_text=_("The course that this programme is for."),
        )
    study_programme = models.ForeignKey(
        "StudyProgramme",
        on_delete=models.CASCADE,
        null=False,
        help_text=_("The study programme that this course belongs to."),
        )
    programme_type = models.CharField(
        max_length=1,
        blank=False,
        choices = (
            ('C', _("Compulsory")),
            ('O', _("Optional")),
            ),
        help_text=_("Type of this course for this study."),
        )
    study_hours = models.PositiveSmallIntegerField(
        blank=False,
        help_text=_("The required amount of hours to study this course."),
        )
    ECTS = models.PositiveSmallIntegerField(
        blank=False,
        help_text=_("The amount of ECTS points attached to this course."),
        )
    semester = models.PositiveSmallIntegerField(
        blank=False,
        choices = (
            (1, _("First semester")),
            (2, _("Second semester")),
            (3, _("Full year course")),
            (4, _("Taught in first quarter")),
            (5, _("Taught in second quarter")),
            (6, _("Taught in third quarter")),
            (7, _("Taught in fourth quarter")),
            ),
        help_text=_("The period in which this course is being taught in this study."),
        )
    year = models.PositiveSmallIntegerField(
        blank=False,
        help_text=_("The year in which this course is taught for this study."),
        )
    second_chance = models.BooleanField(
        default=True,
        help_text=_("Defines if a second chance exam is planned for this course."),
        )
    tolerable = models.BooleanField(
        default=True,
        help_text=_("Defines if a failed result can be tolerated."),
        )
    scoring = models.CharField(
        max_length=2,
        choices = (
            ('N', _("Numerical")),
            ('FP', _("Fail/Pass")),
            ),
        default='N',
        blank=False,
        help_text=_("How the obtained score for this course is given."),
        )

    def __str__(self):
        return str(self.study) + " - " + str(self.course)

class Study(models.Model):
    """ Defines a certain study that can be followed at the university.
    This also includes abridged study programmes, like transition programmes.
    Other information, such as descriptions, are kept in the template file
    of this study, which can be manually edited. Joeni searches for a file
    with the exact name as the study + ".html". So if the study is called
    "Bachelor of Informatics", it will search for "Bachelor of Informatics.html".
    """
    # Degree types
    BSc = _("Bachelor of Science")
    MSc = _("Master of Science")
    LLB = _("Bachelor of Laws")
    LLM = _("Master of Laws")
    BA  = _("Bachelor of Arts")
    MA  = _("Master of Arts")
    ir  = _("Engineer")
    ing = _("Technical Engineer")
    # Faculties
    FoMaLS = _("Faculty of Medicine and Life Sciences")
    FoS    = _("Faculty of Sciences")
    FoTS   = _("Faculty of Transportation Sciences")
    FoAaA  = _("Faculty of Architecture and Arts")
    FoBE   = _("Faculty of Business Economics")
    FoET   = _("Faculty of Engineering Technology")
    FoL    = _("Faculty of Law")

    name = models.CharField(
        max_length=128,
        blank=False,
        unique=True,
        help_text=_("The full name of this study, in the language it's taught in."),
        )
    degree_type = models.CharField(
        max_length=64,
        choices = (
            ('BSc', BSc),
            ('MSc', MSc),
            ('LL.B', LLB),
            ('LL.M', LLM),
            ('ir.', ir ),
            ('ing.',ing),
            ('BA', BA),
            ('MA', MA),
            ),
        blank=False,
        help_text=_("The type of degree one obtains upon passing this study."),
        )
    language = models.CharField(
        max_length=64,
        choices = (
            ('NL', _("Dutch")),
            ('EN', _("English")),
            ('FR', _("French")),
            ),
        null=False,
        help_text=_("The language in which this study is given."),
        )
    # Information about exam committee
    chairman = models.ForeignKey(
        "administration.User",
        on_delete=models.PROTECT,
        null=False,
        limit_choices_to={'is_staff': True},
        help_text=_("The chairman of this study."),
        related_name="chairman",
        )
    vice_chairman = models.ForeignKey(
        "administration.User",
        on_delete=models.PROTECT,
        null=False,
        help_text=_("The vice-chairman of this study."),
        limit_choices_to={'is_staff': True},
        related_name="vice_chairman",
        )
    secretary = models.ForeignKey(
        "administration.User",
        on_delete=models.PROTECT,
        null=False,
        help_text=_("The secretary of this study."),
        limit_choices_to={'is_staff': True},
        related_name="secretary",
        )
    ombuds = models.ForeignKey(
        "administration.User",
        on_delete=models.PROTECT,
        null=False,
        help_text=_("The ombuds person of this study."),
        limit_choices_to={'is_staff': True},
        related_name="ombuds",
        )
    vice_ombuds = models.ForeignKey(
        "administration.User",
        on_delete=models.PROTECT,
        null=False,
        help_text=_("The (replacing) ombuds person of this study."),
        limit_choices_to={'is_staff': True},
        related_name="vice_ombuds",
        )
    additional_members = models.ManyToManyField(
        "administration.User",
        help_text=_("All the other members of the exam committee."),
        limit_choices_to={'is_staff': True},
        related_name="additional_members",
        )
    faculty = models.CharField(
        max_length=6,
        choices = (
            ('FoS', FoS),
            ('FoTS', FoTS),
            ('FoAaA', FoAaA),
            ('FoBE', FoBE),
            ('FoMaLS', FoMaLS),
            ('FoET', FoET),
            ('FoL', FoL),
            ),
        blank=False,
        help_text=_("The faculty where this study belongs to."),
        )

    #def study_points(self):
    """ Returns the amount of study points for this year.
        This value is inferred based on the study programme information
        records that lists this study as their foreign key. """
        #total_ECTS = 0
        #for course in CourseProgramme.objects.filter(study=self):
            #total_ECTS += course.ECTS
        #return total_ECTS
    # XXX: Commented because this is actually something for the StudyProgramme
    def years(self):
        """ Returns the amount of years this study takes.
        This value is inferred based on the study programme information
        records that lists this study as their foreign key. """
        highest_year = 0
        for course in CourseProgramme.objects.filter(study=self):
            highest_year = max(highest_year, course.year)
        return highest_year

    def students(self):
        """ Cross references the information stored in the database, and
        returns all the students that are following this study in this
        academic year. """
        return 0  # TODO


    def __str__(self):
        return self.name

class StudyProgramme(models.Model):
    """ Represents a programme within a certain study.
    A good example for this is the different specializations, minors, majors, ...
    one can follow within the same study. Nevertheless, they're all made of
    a certain set of courses. This table collects all these, and allows one to name
    them, so they're distinct from one another. """
    name = models.CharField(
            max_length=64,
            blank=False,
            help_text=_("The name of this programme."),
            )

    def courses(self):
        """ All courses that are part of this study programme. """
        programmes = CourseProgramme.objects.filter(study_programme=self)
        courses = {}
        for program in programmes:
            courses.add(program.course)
        return courses

    def study_points(self, year=None):
        """ Returns the amount of study points this programme contains.
        Accepts year as an optional argument. If not given, the study points
        of all years are returned. """
        programmes = CourseProgramme.objects.filter(study_programme=self)
        ECTS = 0
        for program in programmes:
            if year is None or program.year == year:
                # XXX: This only works if the used implementation does lazy
                # evaluation, otherwise this is a type error!
                ECTS += program.ECTS
        return ECTS

    def __str__(self):
        return self.name

# Tables about things related to the courses:

class Assignment(models.Model):
    """ For courses, it's possible to set up tasks. These tasks are recorded
    here. """
    # TODO: Require that only the course team can create assignments for a team.
    course = models.ForeignKey(
        "Course",
        on_delete=models.CASCADE,
        null=False,
        #editable=False,
        db_index=True,
        help_text=_("The course for which this task is assigned."),
        )
    title = models.CharField(
        max_length=32,
        blank=False,
        help_text=_("The title of this assignment."),
        )
    information = models.TextField(
        help_text=_("Any additional information regarding the assignment. Orgmode syntax available."),
        )
    deadline = models.DateTimeField(
        null=False,
        help_text=_("The date and time this task is due."),
        )
    posted = models.DateField(auto_now_add=True)
    digital_task = models.BooleanField(
        default=True,
        help_text=_("This determines whether this assignment requires handing "
                    "in a digital file."),
        )

    def __str__(self):
        return str(self.course) +" | "+ str(self.posted)

class Announcement(models.Model):
    """ Courses sometimes have to make announcements for the students. """
    course = models.ForeignKey(
        "Course",
        on_delete=models.CASCADE,
        null=False,
        #editable=False,
        db_index=True,
        help_text=_("The course for which this announcement is made."),
        )
    title = models.CharField(
        max_length=20,  # Keep It Short & Simple®
        help_text=_("A quick title for what this is about."),
        )
    text = models.TextField(
        blank=False,
        help_text=_("The announcement itself. Orgmode syntax available."),
        )
    posted = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return str(self.course) +" | "+ self.posted.strftime("%m/%d")

class Upload(models.Model):
    """ For certain assignments, digital hand-ins may be required. These hand
    ins are recorded per student in this table. """
    course = models.ForeignKey(
        "Course",
        on_delete=models.CASCADE,
        null=False,
        db_index=True,
        )
    assignment = models.ForeignKey(
        "Assignment",
        on_delete=models.CASCADE,
        null=False,
        #editable=False,
        db_index=True,
        limit_choices_to={"digital_task": True},
        help_text=_("For which assignment this upload is."),
        )
    # TODO: Try to find a way to require that, if the upload is made,
    # only students that have this course in their curriculum can upload.
    student = models.ForeignKey(
        "administration.User",
        on_delete=models.CASCADE,
        null=False,
        #editable=False,
        limit_choices_to={"is_student": True},
        help_text=_("The student who handed this in."),
        )
    upload_time = models.DateTimeField(auto_now_add=True)
    comment = models.TextField(
        blank=True,
        help_text=_("If you wish to add an additional comment, state it here."),
        )
    file = models.FileField(
        upload_to="assignments/uploads/%Y/%m/",
        null=False,
        #editable=False,
        help_text=_("The file you want to upload for this assignment."),
        )


    def __str__(self):
        deadline = self.assignment.deadline
        if deadline < self.upload_time:
            return str(self.assignment.course) +" | "+ str(self.student.number) + _("(OVERDUE)")
        else:
            return str(self.assignment.course) +" | "+ str(self.student.number)

def item_upload_directory(instance, filename):
    return "courses/" + instance.course.slug_name + "/"
class CourseItem(models.Model):
    """ Reprensents study material for a course that is being shared by the
    course's education team. """
    course = models.ForeignKey(
        Course,
        on_delete=models.CASCADE,
        null=False,
        #editable=False,
        )
    file = models.FileField(
        upload_to=item_upload_directory,
        null=False,
        #editable=False,
        help_text=_("The file you wish to upload."),
        )
    timestamp = models.DateTimeField(auto_now_add=True)
    note = models.TextField(
        blank=True,
        help_text=_("If you want to state some additional information about "
                    "this upload, state it here."),
        )

class StudyGroup(models.Model):
    """ It may be necessary to make study groups regarding a course. These
    are recorded here, and blend in seamlessly with the Groups from Agora.
    Groups that are recorded as a StudyGroup, are given official course status,
    and thus, cannot be removed until the status of StudyGroup is lifted. """
    course = models.ForeignKey(
        "Course",
        on_delete=models.CASCADE,
        null=False,
        #editable=False,
        db_index=True,
        help_text=_("The course for which this group is."),
        )
    group = models.ForeignKey(
        "agora.Group",
        on_delete=models.PROTECT,  # See class documentation
        null=False,
        #editable=False,  # Keep the same group
        help_text=_("The group that will be seen as the study group."),
        )

    def __str__(self):
        return str(self.course) +" | "+ str(self.group)

class CourseGroup(models.Model):
    """Because of size, some studies may use multiple groups for the different
    students, so it's possible to facilitate all of them. These groups must be
    registered here."""
    study = models.ForeignKey(
        "Study",
        on_delete=models.CASCADE,
        null=False,
        )
    # TODO: How to attach students to certain groups? The curriculum or what?


courses/templates/courses/course.djhtml ¶

39 additions and 3 deletions.

View changes Hide changes

{% load static %}
{% load i18n %}
{% load humanize %}
{% load joeni_org %}

{% block title %}
    {{ course.name }} | {{ block.super }}
{% endblock %}

{% block main %}
    <h1>{{ course.name }}</h1>

    <h2 id="{% trans "announcements" %}">{% trans "Announcements" %}</h2>
    <div class="flex-container">
    {% for announcement in announcements %}
        <div style="border-color: #{{ course.color }};" class="flex-item">
            <h3 id="{{ announcement.title|slugify }}">{{ announcement.title }}</h3>
            <time datetime="{{ announcement.posted|date:'c' }}">
                {% trans "Posted" %} {{ announcement.posted|naturaltime }}
            </time>
            <p>{{ announcement.text|org }}</p>
        </div>
    {% empty %}
        {% trans "No announcements have been made for this course." %}
    {% endfor %}
    </div>

    <h2 id="{% trans "assignments" %}">{% trans "Assignments" %}</h2>
    <div class="flex-container">
    {% for assignment in assignments %}
        <div style="border-color: #{{ course.color }};" class="flex-item">
            <h3 id="{{ assignment.title|slugify }}">{{ assignment.title }}</h3>
            <time datetime="{{ assignment.posted|date:'c' }}">
                {% trans "Posted" %} {{ assignment.posted|naturaltime }}
            </time>
            </time>
            {% if assignment.information %}
                <p>{{ assignment.information|org }}</p>
            {% endif %}
            {#{% trans "Posted" %}: {{ assignment.posted|naturaltime }}#}
            {% trans "Posted" %}: {{ assignment.posted|date:"DATE_FORMAT" }}
            {% if assignment.digital_task %}
            {% if assignment.digital_task %}
                <h4>{% trans "Your uploads" %}</h4>
                {% for upload in uploads %}
                    {% if upload.assignment ==  assignment %}
                        {% trans "Uploaded:"%} {{ upload.upload_time|date:"SHORT_DATETIME_FORMAT" }}<br />
                        {% if upload.comment %}
                            <p>{{ upload.comment }}</p>
                        {% endif %}
                        {% if upload.upload_time > assignment.deadline %}
                            <strong>{% trans "This upload is overdue." %}</strong>
                        {% endif %}
                    {% endif %}
                {% empty %}
                    {% with now as current_time %}
                    {% if current_time > assignment.deadline %}
                        <p>
                            <strong>
                                {% blocktrans %}
                                    You have failed to provide an upload for this
                                    assignment. Any future uploads will be automatically
                                    overdue.
                                {% endblocktrans %}
                            </strong>
                        </p>
                    {% else %}
                        <p>
                            {% blocktrans %}
                                You haven't uploaded anything for this assignment
                                yet.
                            {% endblocktrans %}
                        </p>
                    {% endif %}
                    {% endwith %}
                {% endfor %}
                <h5>{% trans "Upload a task" %}</h5>
                <form action="{% url "courses-course-index" course.slug_name %}" method="post">
                    {% csrf_token %} {# todo i don't think that's necessary here #}
                    {% include "joeni/form.djhtml" with form=upload_form %}
                    <input type="submit" value="{% trans "Submit" %}" />
                </form>
            {% endif %}
        </div>
    {% endfor %}
    </div>
{% endblock main %}
    <a class="btn" href="{% url "courses-eci" course_slug=course.slug_name %}">
        {% trans "Edit course page" %}
    </a>
    <a class="btn" href="{% url "courses-results" course_slug=course.slug_name %}">
        {% trans "Student results" %}
    </a>
    <h2 id="{% trans "students" %}">{% trans "Students" %}</h2>
    <table>
        <tr>
            <th>{% trans "Student name" %}</th>
            <th>{% trans "Student number" %}</th>
            <th>{% trans "First result" %}</th>
            <th>{% trans "Second result" %}</th>
            <th>{% trans "Decision" %}</th>
        </tr>
            {% for student in student_list %}
                <tr>
                <td>{{ student.student }}</td>
                <td>{{ student.student.number }}</td>
                <td>{{ course_result.first_score|default:"-" }}</td>
                <td>{{ course_result.second_score|default:"-" }}</td>
                <td>{% with result=course_result.result %}
                    {% if result == "CRED" or result == "VRST" or result == "TLRD" or result == "ITLR"%}
                        <span style="color:green;">
                    {% elif result == "FAIL" %}
                        <span style="color:red;">
                    {% elif result == "BDRG" %}
                        <span style="background-color:red; color:white;">
                    {% elif result == "STOP" %}
                        <span style="color:black;">
                    {% endif %}
                    {{ course_result.get_result_display }}</span>
                {% endwith %}</td>
        </tr>
        {% endfor %}
        </table>
{% endblock main %}


courses/templates/courses/course_results.djhtml ¶

33 additions and 0 deletions.

View changes Hide changes

+	1	{% load static %}
+	2	{% load i18n %}
+	3	{% load joeni_org %}
+	4
+	5	{% block title %}
+	6	{{ course.name }} \| {{ block.super }}
+	7	{% endblock %}
+	8
+	9	{% block main %}
+	10	<!--
+	11	<form action="" method="POST">
+	12	{% csrf_token %}
+	13	<h2 id="{% trans "announcements" %}">{% trans "Announcements" %}</h2>
+	14	<table>
+	15	{{ announcements }}
+	16	</table>
+	17	<h2 id="{% trans "assignments" %}">{% trans "Assignments" %}</h2>
+	18	<table>
+	19	{{ assignments }}
+	20	</table>
+	21	<h2 id="{% trans "course-items" %}">{% trans "Course items" %}</h2>
+	22	<table>
+	23	{{ course_items }}
+	24	</table>
+	25	<h2 id="{% trans "students" %}">{% trans "Students" %}</h2>
+	26	<table>
+	27	{{ course_results }}
+	28	</table>
+	29	<hr />
+	30	<input type="submit" value="{% trans "Save everything" %}" />
+	31	</form>-->
+	32	{% endblock main %}
+	33

courses/templates/courses/edit_course_items.djhtml ¶

2 additions and 0 deletions.

View changes Hide changes

{% load static %}
{% load i18n %}
{% load joeni_org %}

{% block title %}
    {{ course.name }} | {{ block.super }}
{% endblock %}

{% block main %}
    <p>
        {% blocktrans %}You can edit announcements, assignments, and course
            items on this page, mark them for deletion, and add new ones.
            When all changes are saved successfully, you will be redirected to
            the course's main page. When errors occur, you will stay on this page,
            and receive error notifications where necessary.{% endblocktrans %}
    </p>

    <form action="" method="POST">
        {% csrf_token %}
        <h2 id="{% trans "announcements" %}">{% trans "Announcements" %}</h2>
            <table>
                {{ announcements }}
            </table>
        <h2 id="{% trans "assignments" %}">{% trans "Assignments" %}</h2>
            <table>
            {{ assignments }}
            </table>
        <h2 id="{% trans "course-items" %}">{% trans "Course items" %}</h2>
            <table>
                {{ course_items }}
            </table>
        <h2 id="{% trans "students" %}">{% trans "Students" %}</h2>
        <h2 id="{% trans "students" %}">{% trans "Students" %}</h2>
            <table>
                {{ course_results }}
            </table>
        <hr />
        <hr />
        <input type="submit" value="{% trans "Save everything" %}" />
    </form>
{% endblock main %}


courses/urls.py ¶

1 addition and 0 deletions.

View changes Hide changes

from . import views
from django.utils.translation import ugettext_lazy as _

urlpatterns = [
    path('', views.index, name='courses-index'),
    path('<slug:course_slug>', views.course, name='courses-course-index'),
    path(_('<slug:course_slug>/<int:assignment_id>/upload'), views.upload, name='courses-upload'),
    path(_('<slug:course_slug>/new-item'), views.new_item, name='courses-new-item'),
    path(_('<slug:course_slug>/groups'), views.groups, name='courses-groups'),
    path(_('<slug:course_slug>/edit-course-items'), views.edit_course_items, name='courses-eci'),
    ]
    ]


courses/views.py ¶

25 additions and 11 deletions.

View changes Hide changes

import datetime
from django.urls import reverse # Why?
from django.utils.translation import gettext as _
from .models import *
from .forms import *
import administration
from django.contrib.auth.decorators import login_required
from joeni.constants import current_academic_year

@login_required
def index(request):
    """ Starting page regarding the courses. This serves two specific groups:
    - Students: Displays all courses that this student has in his/her curriculum
                for this academic year. Requires the curriculum to be accepted.
    - Staff: Displays all courses in which the staff member is part of the
             educating team, or is otherwise related to the course.
    Users who are not logged in will be sent to the login page.
    """
    template = "courses/index.djhtml"
    courses = request.user.user_data.current_courses()

    context = {
        'courses': courses,
        }

    return render(request, template, context)

@login_required
def course(request, course_slug):
    template = "courses/course.djhtml"
    course = Course.objects.get(slug_name=course_slug)

    # Check if user can see this page
    if request.user.user_data.is_student:
        if course not in request.user.user_data.current_courses():
            """ I'm currently just redirecting to the index page, but maybe it's
            just as good to make an announcement that this course cannot be
            used by this user. """
            return index(request)

    context = {
        'course': course,
        'main_color': course.color,
        'announcements': Announcement.objects.filter(course=course),
        'assignments': Assignment.objects.filter(course=course),
        'course-items': CourseItem.objects.filter(course=course),
        'study-groups': StudyGroup.objects.filter(course=course),
        'uploads': Upload.objects.filter(course=course).filter(student=request.user)
        }
    if request.user.user_data.is_student:
        context['upload_form'] = UploadForm()

        #context['student_list'] = administration.models.CourseResult.objects.filter(course_programme__course=course).filter(year=current_academic_year()),
        context['student_list'] = administration.models.CourseResult.objects.all()

    return render(request, template, context)

# TODO: Find a way to see if it's possible to require some permissions and to
# put them in a decorator
#@permission_required
@login_required
def new_item(request, course_slug):
    template = "courses/new_item.djhtml"
    course = Course.objects.get(slug_name=course_slug)

    if request.user.user_data.is_student or request.user not in course.course_team:
        # Students can't add new items. Redirect to index
        # Also redirect people who are not part of the course team
        redirect('courses-index')
    # Now able to assume user is allowed to add items to this course

    context = {
        'course': course,
        'announcements': Announcement.objects.filter(course=course),
        'assignments': Assignment.objects.filter(course=course),
        'course-items': CourseItem.objects.filter(course=course),
        'study-groups': StudyGroup.objects.filter(course=course),
        'uploads': Upload.objects.filter(course=course)
        }


    return render(request, template, context)
    return render(request, template, context)

#@create_context  # TODO
@login_required
def course_results(request, course_slug):
    template = "courses/course_results.djhtml"
    context = dict()
    course_ = Course.objects.get(slug_name=course_slug)
    return render(request, template, context)

@login_required
def edit_course_items(request, course_slug):
    # TODO Only allow people on the course team to this page!
    template = "courses/edit_course_items.djhtml"
    context = dict()
    course_ = Course.objects.get(slug_name=course_slug)
    if request.method == 'POST':
        assignments = AssignmentFormSet(request.POST, prefix='assignments')
        announcements = AnnouncementFormSet(request.POST, prefix='announcements')
        course_items = CourseItemFormSet(request.POST, request.FILES, prefix='course_items')
        course_results = CourseResultsFormSet(request.POST, prefix='course_results')
        if assignments.is_valid() and announcements.is_valid() and course_items.is_valid() and course_results.is_valid():
            assignments.save(commit=False)
        if assignments.is_valid() and announcements.is_valid() and course_items.is_valid(): #and course_results.is_valid():
            assignments.save(commit=False)
            announcements.save(commit=False)
            course_items.save(commit=False)
            course_results.save(commit=False)
            for new_assignment in assignments.new_objects:
            for new_assignment in assignments.new_objects:
                new_assignment.course = course_
            for new_announcement in announcements.new_objects:
                new_announcement.course = course_
            for new_course_item in course_items.new_objects:
                new_coutse_item.course = course_
            for new_course_result in course_results.new_objects:
                new_coutse_result.course = course_
            assignments.save()
                #new_coutse_result.course = course_
            assignments.save()
            announcements.save()
            course_items.save()
            course_results.save()
            return course(request, course_slug)
            return course(request, course_slug)
    else:
        assignments = AssignmentFormSet(
            queryset=Assignment.objects.filter(course=course_),
            prefix="assignments",
            )
        announcements = AnnouncementFormSet(
            queryset=Announcement.objects.filter(course=course_),
            prefix="announcements",
            )
        course_items = CourseItemFormSet(
            queryset=CourseItem.objects.filter(course=course_),
            prefix="course_items",
            )
        course_results = CourseResultFormSet(
            queryset=CourseResult.objects.filter(course=course_).filter(year=current_academic_year()),
            prefix="course_results",
            )
    context['assignments'] = assignments
            #queryset=administration.models.CourseResult.objects.filter(course_programme__course=course_).filter(year=current_academic_year()),
            #prefix="course_results",
            #)

    context['course'] = course_
    context['assignments'] = assignments
    context['announcements'] = announcements
    context['course_items'] = course_items
    context['course_results'] = course_results
    return render(request, template, context)
    return render(request, template, context)



@login_required
def groups(request):
    pass

def fiche(request, course_slug):
    """Displays the fiche for the given course. Includes information about all
    course programs."""
    template = "courses/fiche.djhtml"
    context = dict()
    course = Course.objects.get(slug_name=course_slug)


1	1	{% cycle "hour" "first quarter" "half" "last quarter" as hour silent %}
2	2	{# "silent" blocks the cycle operator from printing the cycler, and in subsequent calls #}
3	3	{% load i18n %}
4	4
5	5	{% block title %}
6	6	{% trans "Roster" %} \| {{ block.super }}
7	7	{% endblock %}
8	8
9	9	{% block main %}
10	10	<h1>{% trans "Personal timetable" %}</h1>
11	11	<h2>{% trans "Main hour roster" %}</h2>
12	12
13	13
14	14	{% include "administration/roster_t.djhtml" %}
15	15
16	16
17	17	<a class="btn" href="{% url "administration-roster" begin=prev_begin end=prev_end %}">
18	18	{% trans "Previous week" %}
19	19	</a>
20	20	<a class="btn" href="{% url "administration-roster" %}">
21	21	{% trans "Current week" %}
22	22	</a>
23	23	<a class="btn" href="{% url "administration-roster" begin=next_begin end=next_end %}">
24	24	{% trans "Next week" %}
25	25	</a>
26	26	{# TODO: Add links to "previous week", "next week" and "current week" with large buttons #}
+	27	{% trans "ICS file" %}
+	28	</a>
+	29	{# TODO: Add links to "previous week", "next week" and "current week" with large buttons #}
27	30
28	31	<h2>{% trans "Explanation" %}</h2>
29	32	<p>
30	33	{% trans "Personal roster from" %} {{ begin\|date }} {% trans "to" %} {{ end\|date }}
31	34	</p>
32	35	<p>
33	36	{% blocktrans %}
34	37	Some fields may have additional information that might be of interest
35	38	to you. This information is shown in different ways with colour codes.
36	39	{% endblocktrans %}
37	40	</p>
38	41
39	42	<dl>
40	43	<dt><span class="event-update">
41	44	{% trans "Recent event update" %}
42	45	</span></dt>
43	46	<dd>
44	47	{% blocktrans %}
45	48	This event had one or more of its properties changed
46	49	in the last five days. This can be the room, the hours, the subject, ...
47	50	You're encouraged to take note of that.
48	51	{% endblocktrans %}
49	52	</dd>
50	53	<dt><span class="event-new">
51	54	{% trans "New event" %}
52	55	</span></dt>
53	56	<dd>
54	57	{% blocktrans %}
55	58	This is a new event, added in the last five days.
56	59	{% endblocktrans %}
57	60	</dd>
58	61	<dt><span class="event-note">
59	62	{% trans "Notification available" %}
60	63	</span></dt>
61	64	<dd>
62	65	{% blocktrans %}
63	66	This event has a note attached to it by the docent. Hover over
64	67	the event to display the note.
65	68	{% endblocktrans %}
66	69	</dd>
67	70	</dl>
68	71
69	72	{% endblock main %}
70	73

1	1	{% load static %}
2	2	{% load i18n %}
3	3	{% load humanize %}
4	4	{% load joeni_org %}
5	5
6	6	{% block title %}
7	7	{{ course.name }} \| {{ block.super }}
8	8	{% endblock %}
9	9
10	10	{% block main %}
11	11	<h1>{{ course.name }}</h1>
12	12
13	13	<h2 id="{% trans "announcements" %}">{% trans "Announcements" %}</h2>
14	14	<div class="flex-container">
15	15	{% for announcement in announcements %}
16	16	<div style="border-color: #{{ course.color }};" class="flex-item">
17	17	<h3 id="{{ announcement.title\|slugify }}">{{ announcement.title }}</h3>
18	18	<time datetime="{{ announcement.posted\|date:'c' }}">
19	19	{% trans "Posted" %} {{ announcement.posted\|naturaltime }}
20	20	</time>
21	21	<p>{{ announcement.text\|org }}</p>
22	22	</div>
23	23	{% empty %}
24	24	{% trans "No announcements have been made for this course." %}
25	25	{% endfor %}
26	26	</div>
27	27
28	28	<h2 id="{% trans "assignments" %}">{% trans "Assignments" %}</h2>
29	29	<div class="flex-container">
30	30	{% for assignment in assignments %}
31	31	<div style="border-color: #{{ course.color }};" class="flex-item">
32	32	<h3 id="{{ assignment.title\|slugify }}">{{ assignment.title }}</h3>
33	33	<time datetime="{{ assignment.posted\|date:'c' }}">
34	34	{% trans "Posted" %} {{ assignment.posted\|naturaltime }}
35	-	</time>
+	35	</time>
36	36	{% if assignment.information %}
37	37	<p>{{ assignment.information\|org }}</p>
38	38	{% endif %}
39	39	{#{% trans "Posted" %}: {{ assignment.posted\|naturaltime }}#}
40	-	{% trans "Posted" %}: {{ assignment.posted\|date:"DATE_FORMAT" }}
41	-	{% if assignment.digital_task %}
+	40	{% if assignment.digital_task %}
42	41	<h4>{% trans "Your uploads" %}</h4>
43	42	{% for upload in uploads %}
44	43	{% if upload.assignment == assignment %}
45	44	{% trans "Uploaded:"%} {{ upload.upload_time\|date:"SHORT_DATETIME_FORMAT" }}<br />
46	45	{% if upload.comment %}
47	46	<p>{{ upload.comment }}</p>
48	47	{% endif %}
49	48	{% if upload.upload_time > assignment.deadline %}
50	49	<strong>{% trans "This upload is overdue." %}</strong>
51	50	{% endif %}
52	51	{% endif %}
53	52	{% empty %}
54	53	{% with now as current_time %}
55	54	{% if current_time > assignment.deadline %}
56	55	<p>
57	56	<strong>
58	57	{% blocktrans %}
59	58	You have failed to provide an upload for this
60	59	assignment. Any future uploads will be automatically
61	60	overdue.
62	61	{% endblocktrans %}
63	62	</strong>
64	63	</p>
65	64	{% else %}
66	65	<p>
67	66	{% blocktrans %}
68	67	You haven't uploaded anything for this assignment
69	68	yet.
70	69	{% endblocktrans %}
71	70	</p>
72	71	{% endif %}
73	72	{% endwith %}
74	73	{% endfor %}
75	74	<h5>{% trans "Upload a task" %}</h5>
76	75	<form action="{% url "courses-course-index" course.slug_name %}" method="post">
77	76	{% csrf_token %} {# todo i don't think that's necessary here #}
78	77	{% include "joeni/form.djhtml" with form=upload_form %}
79	78	<input type="submit" value="{% trans "Submit" %}" />
80	79	</form>
81	80	{% endif %}
82	81	</div>
83	82	{% endfor %}
84	83	</div>
85	84	{% endblock main %}
+	85	<a class="btn" href="{% url "courses-eci" course_slug=course.slug_name %}">
+	86	{% trans "Edit course page" %}
+	87	</a>
+	88	<a class="btn" href="{% url "courses-results" course_slug=course.slug_name %}">
+	89	{% trans "Student results" %}
+	90	</a>
+	91	<h2 id="{% trans "students" %}">{% trans "Students" %}</h2>
+	92	<table>
+	93	<tr>
+	94	<th>{% trans "Student name" %}</th>
+	95	<th>{% trans "Student number" %}</th>
+	96	<th>{% trans "First result" %}</th>
+	97	<th>{% trans "Second result" %}</th>
+	98	<th>{% trans "Decision" %}</th>
+	99	</tr>
+	100	{% for student in student_list %}
+	101	<tr>
+	102	<td>{{ student.student }}</td>
+	103	<td>{{ student.student.number }}</td>
+	104	<td>{{ course_result.first_score\|default:"-" }}</td>
+	105	<td>{{ course_result.second_score\|default:"-" }}</td>
+	106	<td>{% with result=course_result.result %}
+	107	{% if result == "CRED" or result == "VRST" or result == "TLRD" or result == "ITLR"%}
+	108	<span style="color:green;">
+	109	{% elif result == "FAIL" %}
+	110	<span style="color:red;">
+	111	{% elif result == "BDRG" %}
+	112	<span style="background-color:red; color:white;">
+	113	{% elif result == "STOP" %}
+	114	<span style="color:black;">
+	115	{% endif %}
+	116	{{ course_result.get_result_display }}</span>
+	117	{% endwith %}</td>
+	118	</tr>
+	119	{% endfor %}
+	120	</table>
+	121	{% endblock main %}
86	122

1	1	from . import views
2	2	from django.utils.translation import ugettext_lazy as _
3	3
4	4	urlpatterns = [
5	5	path('', views.index, name='courses-index'),
6	6	path('<slug:course_slug>', views.course, name='courses-course-index'),
7	7	path(_('<slug:course_slug>/<int:assignment_id>/upload'), views.upload, name='courses-upload'),
8	8	path(_('<slug:course_slug>/new-item'), views.new_item, name='courses-new-item'),
9	9	path(_('<slug:course_slug>/groups'), views.groups, name='courses-groups'),
10	10	path(_('<slug:course_slug>/edit-course-items'), views.edit_course_items, name='courses-eci'),
11	11	]
+	12	]
12	13

1	1	import datetime
2	2	from django.urls import reverse # Why?
3	3	from django.utils.translation import gettext as _
4	4	from .models import *
5	5	from .forms import *
6	6	import administration
7	7	from django.contrib.auth.decorators import login_required
8	8	from joeni.constants import current_academic_year
9	9
10	10	@login_required
11	11	def index(request):
12	12	""" Starting page regarding the courses. This serves two specific groups:
13	13	- Students: Displays all courses that this student has in his/her curriculum
14	14	for this academic year. Requires the curriculum to be accepted.
15	15	- Staff: Displays all courses in which the staff member is part of the
16	16	educating team, or is otherwise related to the course.
17	17	Users who are not logged in will be sent to the login page.
18	18	"""
19	19	template = "courses/index.djhtml"
20	20	courses = request.user.user_data.current_courses()
21	21
22	22	context = {
23	23	'courses': courses,
24	24	}
25	25
26	26	return render(request, template, context)
27	27
28	28	@login_required
29	29	def course(request, course_slug):
30	30	template = "courses/course.djhtml"
31	31	course = Course.objects.get(slug_name=course_slug)
32	32
33	33	# Check if user can see this page
34	34	if request.user.user_data.is_student:
35	35	if course not in request.user.user_data.current_courses():
36	36	""" I'm currently just redirecting to the index page, but maybe it's
37	37	just as good to make an announcement that this course cannot be
38	38	used by this user. """
39	39	return index(request)
40	40
41	41	context = {
42	42	'course': course,
43	43	'main_color': course.color,
44	44	'announcements': Announcement.objects.filter(course=course),
45	45	'assignments': Assignment.objects.filter(course=course),
46	46	'course-items': CourseItem.objects.filter(course=course),
47	47	'study-groups': StudyGroup.objects.filter(course=course),
48	48	'uploads': Upload.objects.filter(course=course).filter(student=request.user)
49	49	}
50	50	if request.user.user_data.is_student:
51	51	context['upload_form'] = UploadForm()
52	52
+	53	#context['student_list'] = administration.models.CourseResult.objects.filter(course_programme__course=course).filter(year=current_academic_year()),
+	54	context['student_list'] = administration.models.CourseResult.objects.all()
+	55
53	56	return render(request, template, context)
54	57
55	58	# TODO: Find a way to see if it's possible to require some permissions and to
56	59	# put them in a decorator
57	60	#@permission_required
58	61	@login_required
59	62	def new_item(request, course_slug):
60	63	template = "courses/new_item.djhtml"
61	64	course = Course.objects.get(slug_name=course_slug)
62	65
63	66	if request.user.user_data.is_student or request.user not in course.course_team:
64	67	# Students can't add new items. Redirect to index
65	68	# Also redirect people who are not part of the course team
66	69	redirect('courses-index')
67	70	# Now able to assume user is allowed to add items to this course
68	71
69	72	context = {
70	73	'course': course,
71	74	'announcements': Announcement.objects.filter(course=course),
72	75	'assignments': Assignment.objects.filter(course=course),
73	76	'course-items': CourseItem.objects.filter(course=course),
74	77	'study-groups': StudyGroup.objects.filter(course=course),
75	78	'uploads': Upload.objects.filter(course=course)
76	79	}
77	80
+	81
78	82	return render(request, template, context)
+	83	return render(request, template, context)
79	84
80	85	#@create_context # TODO
81	86	@login_required
+	87	def course_results(request, course_slug):
+	88	template = "courses/course_results.djhtml"
+	89	context = dict()
+	90	course_ = Course.objects.get(slug_name=course_slug)
+	91	return render(request, template, context)
+	92
+	93	@login_required
82	94	def edit_course_items(request, course_slug):
83	95	# TODO Only allow people on the course team to this page!
84	96	template = "courses/edit_course_items.djhtml"
85	97	context = dict()
86	98	course_ = Course.objects.get(slug_name=course_slug)
87	99	if request.method == 'POST':
88	100	assignments = AssignmentFormSet(request.POST, prefix='assignments')
89	101	announcements = AnnouncementFormSet(request.POST, prefix='announcements')
90	102	course_items = CourseItemFormSet(request.POST, request.FILES, prefix='course_items')
91	103	course_results = CourseResultsFormSet(request.POST, prefix='course_results')
92	-	if assignments.is_valid() and announcements.is_valid() and course_items.is_valid() and course_results.is_valid():
93	-	assignments.save(commit=False)
+	104	if assignments.is_valid() and announcements.is_valid() and course_items.is_valid(): #and course_results.is_valid():
+	105	assignments.save(commit=False)
94	106	announcements.save(commit=False)
95	107	course_items.save(commit=False)
96	108	course_results.save(commit=False)
97	-	for new_assignment in assignments.new_objects:
+	109	for new_assignment in assignments.new_objects:
98	110	new_assignment.course = course_
99	111	for new_announcement in announcements.new_objects:
100	112	new_announcement.course = course_
101	113	for new_course_item in course_items.new_objects:
102	114	new_coutse_item.course = course_
103	115	for new_course_result in course_results.new_objects:
104	-	new_coutse_result.course = course_
105	-	assignments.save()
+	116	#new_coutse_result.course = course_
+	117	assignments.save()
106	118	announcements.save()
107	119	course_items.save()
108	120	course_results.save()
109	-	return course(request, course_slug)
+	121	return course(request, course_slug)
110	122	else:
111	123	assignments = AssignmentFormSet(
112	124	queryset=Assignment.objects.filter(course=course_),
113	125	prefix="assignments",
114	126	)
115	127	announcements = AnnouncementFormSet(
116	128	queryset=Announcement.objects.filter(course=course_),
117	129	prefix="announcements",
118	130	)
119	131	course_items = CourseItemFormSet(
120	132	queryset=CourseItem.objects.filter(course=course_),
121	133	prefix="course_items",
122	134	)
123	135	course_results = CourseResultFormSet(
124	-	queryset=CourseResult.objects.filter(course=course_).filter(year=current_academic_year()),
125	-	prefix="course_results",
126	-	)
127	-	context['assignments'] = assignments
+	136	#queryset=administration.models.CourseResult.objects.filter(course_programme__course=course_).filter(year=current_academic_year()),
+	137	#prefix="course_results",
+	138	#)
+	139
+	140	context['course'] = course_
+	141	context['assignments'] = assignments
128	142	context['announcements'] = announcements
129	143	context['course_items'] = course_items
130	144	context['course_results'] = course_results
131	-	return render(request, template, context)
+	145	return render(request, template, context)
132	146
133	147
134	148
135	149	@login_required
136	150	def groups(request):
137	151	pass
138	152
139	153	def fiche(request, course_slug):
140	154	"""Displays the fiche for the given course. Includes information about all
141	155	course programs."""
142	156	template = "courses/fiche.djhtml"
143	157	context = dict()
144	158	course = Course.objects.get(slug_name=course_slug)
145	159