joeni

Adding changes to roster branch

Author: Maarten 'Vngngdn' Vangeneugden
Date: April 11, 2018, 6:07 p.m.
Hash: 975dae00e067e87580e76f559ddc403b45c1d8f4
Parent: a2bf82891efae1e751a01e38860f8a1a11646db7
Modified files: administration/models.py; administration/templates/administration/nav.djhtml; administration/urls.py; administration/views.py; courses/models.py; courses/urls.py; courses/views.py; joeni/templates/joeni/header.djhtml; static/css/header.css

administration/models.py ¶

49 additions and 14 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
import datetime
import os
import uuid
#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 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
        )
        )
    year = models.DateField(
        auto_now_add=True,
        db_index=True,
        help_text=_("The academic year for which this curriculum is. "
        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 courses(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)[0]
            join_dict[course_program] = result
        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):
        year = self.year.year
        if self.year.month < 7:
            return str(self.student) +" | "+ str(year-1) +"-"+ str(year)
        else:
            return str(self.student) +" | "+ str(year) +"-"+ str(year+1)



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")
    ITLD = _("Tolerance used")
    BDRG = _("Fraud committed")
    BDRG = _("Fraud committed")
    VRST = _("Exemption")
    STOP = _("Course cancelled")
    # Possible to add more in the future

    student = models.ForeignKey(
        "User",
        on_delete=models.CASCADE,
        limit_choices_to={'is_student': True},
        null=False,
        null=False,
        db_index=True,
        )
    course_programme = models.ForeignKey(
        "courses.CourseProgramme",
        on_delete=models.PROTECT,
        null=False,
        )
    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.
        validators=[MaxValueValidator(
        validators=[MaxValueValidator(
            20,
            _("The score mustn't be higher than 20."),
            )],
        )
    second_score = models.PositiveSmallIntegerField(
        null=True,
        validators=[MaxValueValidator(
        validators=[MaxValueValidator(
            20,
            _("The score mustn't be higher than 20."),
            )],
        )
    result = models.CharField(
        max_length=10,
        choices = (
            ("CRED", CRED),
            ("FAIL", FAIL),
            ("TLRD", TLRD),
            ("ITLD", ITLD),
            ),
            ("BDRG", BDRG),
            ("VRST", VRST),
            ("STOP", STOP),
            ),
        blank=False,
        help_text=_("The final 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" + self.first_score + "1"
            else:
            else:
                result = "C" + self.second_score + "2"
        course = str(self.course_programme.course)
        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 reservation_possible(self, begin, end, seats=None):
        """ 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):
        """ Returns a boolean indicating if reservating during the given time
        """ 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/nav.djhtml ¶

1 addition and 1 deletion.

View changes Hide changes

{% load i18n %}
<nav>
    <a href="{% url 'administration-settings' %}">{% trans "Personal settings" %}</a>
    <!--<a href="{% url 'administration-curriculum' %}">{% trans "Curricula" %}</a>-->
    <a href="{% url 'administration-forms' %}">{% trans "Forms" %}</a>
    <a href="{% url 'administration-forms' %}">{% trans "Forms" %}</a>
    <a href="{% url 'administration-rooms' %}">{% trans "Rooms" %}</a>
    <a href="{% url 'administration-jobs' %}">{% trans "Jobs" %}</a>
    <a href="{% url 'administration-roster' %}">{% trans "Personal Roster" %}</a>
    <a href="{% url 'administration-bulletin-board' %}">{% trans "Bulletin board" %}</a>
    PingPing: €{{ money }}
</nav>


administration/urls.py ¶

13 additions and 13 deletions.

View changes Hide changes

from django.contrib.auth import views as auth_views
from . import views
from django.utils.translation import gettext_lazy as _

urlpatterns = ([
    path('', views.index, name='administration-index'),
    path(_('pre-registration'), views.pre_registration, name='administration-pre-registration'),
    path(_('settings'), views.settings, name='administration-settings'),
    path(_('settings'), views.settings, name='administration-settings'),
    path(_('curriculum'), views.curriculum, name='administration-curriculum'),
    # Commented because they might very well be merged with curriculum
    # Commented because they might very well be merged with curriculum
    #path(_('results'), views.results, name='administration-results'),
    #path(_('results/<slug:course>'), views.result, name='administration-results'),
    #path(_('results/<int:student_id>'), views.result, name='administration-results'),
    path(_('forms'), views.forms, name='administration-forms'),  # In Dutch: "Attesten"
    path(_('forms/<str:form>'), views.forms, name='administration-forms'),
    path(_('rooms'), views.rooms, name='administration-rooms'),
    path(_('rooms/<str:room>'), views.room_detail, name='administration-room-detail'),
    #path(_('rooms/reservate'), views.room_reservate, name='administration-room-reservate'),
    path(_('forms/<str:form>'), views.forms, name='administration-forms'),  # HOLD
    path(_('rooms'), views.rooms, name='administration-rooms'),  # TODO
    path(_('rooms/<str:room>'), views.room_detail, name='administration-room-detail'),  # TODO
    #path(_('rooms/reservate'), views.room_reservate, name='administration-room-reservate'),
    path(_('roster'), views.roster, name='administration-roster'),
    re_path(_('roster/(?P<begin>[0-9]{2}-[0-9]{2}-[0-9]{4})/(?P<end>[0-9]{2}-[0-9]{2}-[0-9]{4})'), views.roster, name='administration-roster'),
    path(_('jobs'), views.jobs, name='administration-jobs'),
    path(_('bulletin-board'), views.bulletin_board, name='administration-bulletin-board'),
    path(_('user/<slug:slug_name>'), views.user, name='administration-user'),
    path(_('roster/<slug:user_slug>.ics'), views.roster_ics, name='administration-roster-ics'),

    re_path(_('roster/(?P<begin>[0-9]{2}-[0-9]{2}-[0-9]{4})/(?P<end>[0-9]{2}-[0-9]{2}-[0-9]{4})'), views.roster, name='administration-roster'),  # TODO
    path(_('jobs'), views.jobs, name='administration-jobs'),  # HOLD
    path(_('bulletin-board'), views.bulletin_board, name='administration-bulletin-board'),  # TODO
    path(_('user/<slug:slug_name>'), views.user, name='administration-user'),  # TODO
    path(_('roster/<slug:user_slug>.ics'), views.roster_ics, name='administration-roster-ics'),  # TODO

    path('login', views.login, name='administration-login'),
    ])
    ])


administration/views.py ¶

23 additions and 2 deletions.

View changes Hide changes

from collections import OrderedDict
from django.http import HttpResponseRedirect
import datetime
from django.urls import reverse # Why?
from django.utils.translation import gettext as _
from .models import *
from .forms import UserDataForm
from .new_roster import create_roster_rows
import administration
from django.contrib.auth.decorators import login_required
from django.contrib.auth import authenticate

@login_required
def roster(request, begin=None, end=None):
    """Collects and renders the data that has to be displayed in the roster.

    The begin and end date can be specified. Only roster points in that range
    will be included in the response. If no begin and end are specified, it will
    take the current week as begin and end point. If it's
    weekend, it will take next week."""

    # TODO Handle given begin and end
    context = dict()
    #context = {'money' : update_balance(None)}
    template = "administration/roster.djhtml"

    if begin is None or end is None:
        today = datetime.date.today()
        if today.isoweekday() in {6,7}:  # Weekend
            begin = today + datetime.timedelta(days=8-today.isoweekday())
            end = today + datetime.timedelta(days=13-today.isoweekday())
        else:  # Same week
            begin = today - datetime.timedelta(days=today.weekday())
            end = today + datetime.timedelta(days=5-today.isoweekday())
    else:  # Changing regexes to date objects
        b = begin.split("-")
        e = end.split("-")
        begin = datetime.datetime(int(b[2]),int(b[1]),int(b[0]))
        end = datetime.datetime(int(e[2]),int(e[1]),int(e[0]))

    context['begin'] = begin
    context['end'] = end

    context['prev_begin'] = (begin - datetime.timedelta(days=7)).strftime("%d-%m-%Y")
    context['prev_end'] = (begin - datetime.timedelta(days=2)).strftime("%d-%m-%Y")
    context['next_begin'] = (end + datetime.timedelta(days=2)).strftime("%d-%m-%Y")
    context['next_end'] = (end + datetime.timedelta(days=7)).strftime("%d-%m-%Y")

    days = [begin]
    while (end-days[-1]).days != 0:
        # Human translation: Keep adding days until the last day in the array of
        # days is the same day as the last day the user wants to see the roster for.
        days.append(days[-1] + datetime.timedelta(days=1))
    context['days'] = days

    # Collecting events
    course_events = CourseEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end).order_by("begin_time")
    #university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
    #study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
    #events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
    conflicts, table_code = create_roster_rows(course_events)

    context['time_blocks'] = table_code
    context['conflicts'] = conflicts
    #print(time_blocks)
    return render(request, template, context)
    # TODO Finish!

def roster_ics(request, user_slug):
    template = "administration/roster.ics"
    context = dict()
    context['events'] = CourseEvent.objects.all()  # FIXME: Filter to personal calendar items!
    return render(request, template, context)

def index(request):
    template = "administration/index.djhtml"
    #context = {'money': update_balance(None)}
    return render(request, template, context)

    pass

def pre_registration(request):
    user_data_form = UserDataForm()
    template = "administration/pre_registration.djhtml"
    context = dict()

    if request.method == 'POST':
        user_data_form = UserDataForm(request.POST)
        context['user_data_form'] = user_data_form
        if user_data_form.is_valid():
            user_data_form.save()
            context['messsage'] = _("Your registration has been completed. You will receive an e-mail shortly.")
        else:
            context['messsage'] = _("The data you supplied had errors. Please review your submission.")
    else:
        context['user_data_form'] = UserDataForm(instance = user_data_form)

    return render(request, template, context)
    pass

@login_required
def settings(request):
    user_data = UserData.objects.get(user=request.user)
    user_data_form = UserDataForm(instance = user_data)
    template = "administration/settings.djhtml"
    #context = {'money' : update_balance(None)}
    #context = {'money' : update_balance(None)}

    if request.method == 'POST':
        user_data_form = UserDataForm(request.POST, instance = user_data)
        context['user_data_form'] = user_data_form
        if user_data_form.is_valid():
            user_data_form.save()
            context['messsage'] = _("Your settings were successfully updated.")
        else:
            context['messsage'] = _("The data you supplied had errors. Please review your submission.")
    else:
        context['user_data_form'] = UserDataForm(instance = user_data)

    return render(request, template, context)

@login_required
def bulletin_board(request):
    context = dict()
    #context = {'money' : update_balance(None)}
    context['exam_commission_decisions'] = ExamCommissionDecision.objects.filter(user=request.user)
    context['education_department_messages'] = EducationDepartmentMessages.objects.all()
    for item in context['education_department_messages']:
        print(item.text)
    template = "administration/bulletin_board.djhtml"
    return render(request, template, context)

def jobs(request):
    context = dict()
    #context = {'money' : update_balance(None)}
    template = "administration/jobs.djhtml"
    #@context['decisions'] = ExamCommissionDecision.objects.filter(user=request.user)
    return render(request, template, context)


@login_required
def curriculum(request):
    context = dict()
    #context = {'money' : update_balance(None)}
    template = "administration/curriculum.djhtml"
    context['curricula'] = Curriculum.objects.filter(student=request.user)
    context['cource_results'] = CourseResult.objects.filter(student=request.user)
    return render(request, template, context)
        for co in item.course_programmes_results():
            print(co)
    return render(request, template, context)

def result(request):
    return render(request, template, context)

@login_required
def results(request):
    results = CourseResult.objects.filter(student=request.user)
    template = "administration/results.djhtml"
    # TODO
    return render(request, template, context)

def forms(request):
    context = dict()
    #context = {'money' : update_balance(None)}
    template = "administration/forms.djhtml"
    return render(request, template, context)

def user(request, slug_name):
    pass

def rooms(request):
    context = dict()
    #context = {'money' : update_balance(None)}
    context['rooms'] = Room.objects.all()
    context['room_reservations'] = RoomReservation.objects.all()
    context['course_events'] = CourseEvent.objects.all()
    context['blocks'] = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']



    now = datetime.datetime.now(datetime.timezone.utc)
    end = now + datetime.timedelta(hours=2)
    free_rooms = dict()
    for room in context['rooms']:
        if room.reservation_possible(now, end):
            event = room.next_event(end)
            reservation = room.next_reservation(end)
            if event is None and reservation is None:
                free_rooms[room] = None
            elif reservation is not None:
                free_rooms[room] = event.begin_time
            elif event is not None:
                free_rooms[room] = reservation.begin_time
            elif event.begin_time < reservation.begin_time:
                free_rooms[room] = event.begin_time
            else:
                free_rooms[room] = reservation.begin_time
    context['free_rooms'] = free_rooms

    template = "administration/rooms.djhtml"
    return render(request, template, context)

def room_detail(request, room):
    template = "administration/room_detail.djhtml"
    context = dict()
    #context = {'money' : update_balance(None)}
    room = Room.objects.get(name=room)
    context['room'] = room
    context['reservations'] = RoomReservation.objects.filter(room=room).filter(begin_time__gte=datetime.datetime.now())
    context['course_events'] = CourseEvent.objects.filter(room=room).filter(begin_time__gte=datetime.datetime.now())
    # Building the room occupancy of today:
    today = datetime.date.today()
    if today.isoweekday() in {6,7}:  # Weekend
        today = today + datetime.timedelta(days=8-today.isoweekday())

    context['days'] = [today]

    # Collecting events
    course_events = CourseEvent.objects.filter(room=room).filter(begin_time__date=today)
    print(course_events)
    #university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
    #study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
    #events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    conflicts, table_code = create_roster_rows(course_events)
    context['time_blocks'] = table_code
    context['conflicts'] = conflicts
    print(context['time_blocks'])
    return render(request, template, context)

def login(request):
    context = dict()
    #context = {'money' : update_balance(None)}
    if request.method == "POST":
        name = request.POST['name']
        passphrase = request.POST['pass']
        user = authenticate(username=name, password=passphrase)
        if user is not None: # The user was successfully authenticated
            print("YA")
            return HttpResponseRedirect(request.POST['next'])
        else: # User credentials were wrong
            context['next'] = request.POST['next']
            context['message'] = _("The given credentials were not correct.")
    else:
        context['next'] = request.GET.get('next', None)
        if context['next'] is None:
            context['next'] = reverse('administration-index')

    template = 'administration/login.djhtml'

    return render(request, template, context)


courses/models.py ¶

1 addition and 1 deletion.

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(
            self.contact_person,
            self.coordinator,
            self.educating_team,
            )

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


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 = _("Technological Engineer")
    # Faculties
    # 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/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'),
    ]
    ]


courses/views.py ¶

52 additions and 0 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

def current_academic_year():
    """ Returns the current academic year. The year is determined as follows:
    - If today is before September 15 of the current year, the returned value
      is the current year - 1.
    - If today is after September 15 of the current year, but before January 1
      of the next year, it returns the current year as is.
    """
    today = datetime.datetime.now()
    switch = datetime.datetime(datetime.datetime.now().year, 9, 15)
    if today < switch:
        return today.year - 1
    else:
        return today.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 = set()
    if request.user.user_data.is_student:
        curricula = administration.models.Curriculum.objects.filter(student=request.user)
        #current_curriculum = curricula.filter(year__year=current_academic_year())
        #courses = current_curriculum.courses
        courses = curricula.first().courses
    elif request.user.user_data.is_staff:
        courses += adminstration.models.Course.filter(course_team__contains=request.user)
    else:
        raise django.exceptions.FieldError("User "+request.user.number+" is neither staff nor student")

    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:
        curricula = administration.models.Curriculum.objects.filter(student=request.user)
        #current_curriculum = curricula.filter(year__year=current_academic_year())
        current_curriculum = curricula.first()
        if course not in current_curriculum.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,
        '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()

    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)

@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')
        if assignments.is_valid() and announcements.is_valid() and course_items.is_valid():
            assignments.save(commit=False)
            announcements.save(commit=False)
            course_items.save(commit=False)
            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_
            assignments.save()
            announcements.save()
            course_items.save()
            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",
            )
    context['assignments'] = assignments
    context['announcements'] = announcements
    context['course_items'] = course_items
    return render(request, template, context)


@login_required
def remove(request, type, id):
    pass

@login_required
def upload(request):
    pass

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



26 additions and 11 deletions.

View changes Hide changes

{% load static %}
{% get_media_prefix as media %}
<img width="200px" src="{% static "logos/uhasselt/simple_white.svg" %}" alt="◀ Joeni /▶" />
<ul>
    <li>
        <a href="{% url 'agora-index' %}">Agora</a>
    </li>
    <li>
        <a href="{% url 'administration-index' %}">{% trans "Administration" %}</a>
    </li>
    <li>
        <a href="{% url 'courses-index' %}">{% trans "Courses" %}</a>
    </li>
</ul>

    <ul>
        <li><a href="{% url 'agora-index' %}">Agora</a>
            <ul>
            </ul>
        </li>

        <li><a href="{% url 'administration-index' %}">{% trans "Administration" %}</a>
            <ul>
                <li><a href="{% url 'administration-settings' %}">{% trans "Personal settings" %}</a></li>
                <li><a href="{% url 'administration-curriculum' %}">{% trans "Curricula" %}</a></li>
                <li><a href="{% url 'administration-forms' %}">{% trans "Forms" %}</a></li>
                <li><a href="{% url 'administration-rooms' %}">{% trans "Rooms" %}</a></li>
                <li><a href="{% url 'administration-jobs' %}">{% trans "Jobs" %}</a></li>
                <li><a href="{% url 'administration-roster' %}">{% trans "Personal Roster" %}</a></li>
                <li><a href="{% url 'administration-bulletin-board' %}">{% trans "Bulletin board" %}</a></li>
            </ul>
        </li>

        <li><a href="{% url 'courses-index' %}">{% trans "Courses" %}</a>
            <ul>
            </ul>
        </li>
    </ul>
</nav>
PingPing: €{{ money }}


0 additions and 12 deletions.

View changes Hide changes

    position: relative;
    top: 0;
    width: 100%;
    background-color: #E73B2B;
    margin-top: -8px;
    margin-left: -8px;
}
header ul {
    display: inline;
    float: right;
}


Adding changes to roster branch

administration/models.py ¶

administration/templates/administration/nav.djhtml ¶

administration/urls.py ¶

administration/views.py ¶

courses/models.py ¶

courses/urls.py ¶

courses/views.py ¶

joeni/templates/joeni/header.djhtml ¶

static/css/header.css ¶

1	1	{% load i18n %}
2	2	<nav>
3	3	<a href="{% url 'administration-settings' %}">{% trans "Personal settings" %}</a>
4	4	<!--<a href="{% url 'administration-curriculum' %}">{% trans "Curricula" %}</a>-->
5	-	<a href="{% url 'administration-forms' %}">{% trans "Forms" %}</a>
+	5	<a href="{% url 'administration-forms' %}">{% trans "Forms" %}</a>
6	6	<a href="{% url 'administration-rooms' %}">{% trans "Rooms" %}</a>
7	7	<a href="{% url 'administration-jobs' %}">{% trans "Jobs" %}</a>
8	8	<a href="{% url 'administration-roster' %}">{% trans "Personal Roster" %}</a>
9	9	<a href="{% url 'administration-bulletin-board' %}">{% trans "Bulletin board" %}</a>
10	10	PingPing: €{{ money }}
11	11	</nav>
12	12

1	1	from django.contrib.auth import views as auth_views
2	2	from . import views
3	3	from django.utils.translation import gettext_lazy as _
4	4
5	5	urlpatterns = ([
6	6	path('', views.index, name='administration-index'),
7	7	path(_('pre-registration'), views.pre_registration, name='administration-pre-registration'),
8	-	path(_('settings'), views.settings, name='administration-settings'),
+	8	path(_('settings'), views.settings, name='administration-settings'),
9	9	path(_('curriculum'), views.curriculum, name='administration-curriculum'),
10	-	# Commented because they might very well be merged with curriculum
+	10	# Commented because they might very well be merged with curriculum
11	11	#path(_('results'), views.results, name='administration-results'),
12	12	#path(_('results/<slug:course>'), views.result, name='administration-results'),
13	13	#path(_('results/<int:student_id>'), views.result, name='administration-results'),
14	14	path(_('forms'), views.forms, name='administration-forms'), # In Dutch: "Attesten"
15	-	path(_('forms/<str:form>'), views.forms, name='administration-forms'),
16	-	path(_('rooms'), views.rooms, name='administration-rooms'),
17	-	path(_('rooms/<str:room>'), views.room_detail, name='administration-room-detail'),
18	-	#path(_('rooms/reservate'), views.room_reservate, name='administration-room-reservate'),
+	15	path(_('forms/<str:form>'), views.forms, name='administration-forms'), # HOLD
+	16	path(_('rooms'), views.rooms, name='administration-rooms'), # TODO
+	17	path(_('rooms/<str:room>'), views.room_detail, name='administration-room-detail'), # TODO
+	18	#path(_('rooms/reservate'), views.room_reservate, name='administration-room-reservate'),
19	19	path(_('roster'), views.roster, name='administration-roster'),
20	-	re_path(_('roster/(?P<begin>[0-9]{2}-[0-9]{2}-[0-9]{4})/(?P<end>[0-9]{2}-[0-9]{2}-[0-9]{4})'), views.roster, name='administration-roster'),
21	-	path(_('jobs'), views.jobs, name='administration-jobs'),
22	-	path(_('bulletin-board'), views.bulletin_board, name='administration-bulletin-board'),
23	-	path(_('user/<slug:slug_name>'), views.user, name='administration-user'),
24	-	path(_('roster/<slug:user_slug>.ics'), views.roster_ics, name='administration-roster-ics'),
25	-
+	20	re_path(_('roster/(?P<begin>[0-9]{2}-[0-9]{2}-[0-9]{4})/(?P<end>[0-9]{2}-[0-9]{2}-[0-9]{4})'), views.roster, name='administration-roster'), # TODO
+	21	path(_('jobs'), views.jobs, name='administration-jobs'), # HOLD
+	22	path(_('bulletin-board'), views.bulletin_board, name='administration-bulletin-board'), # TODO
+	23	path(_('user/<slug:slug_name>'), views.user, name='administration-user'), # TODO
+	24	path(_('roster/<slug:user_slug>.ics'), views.roster_ics, name='administration-roster-ics'), # TODO
+	25
26	26	path('login', views.login, name='administration-login'),
27	-	])
+	27	])
28	28

1	1	from collections import OrderedDict
2	2	from django.http import HttpResponseRedirect
3	3	import datetime
4	4	from django.urls import reverse # Why?
5	5	from django.utils.translation import gettext as _
6	6	from .models import *
7	7	from .forms import UserDataForm
8	8	from .new_roster import create_roster_rows
9	9	import administration
10	10	from django.contrib.auth.decorators import login_required
11	11	from django.contrib.auth import authenticate
12	12
13	13	@login_required
14	14	def roster(request, begin=None, end=None):
15	15	"""Collects and renders the data that has to be displayed in the roster.
16	16
17	17	The begin and end date can be specified. Only roster points in that range
18	18	will be included in the response. If no begin and end are specified, it will
19	19	take the current week as begin and end point. If it's
20	20	weekend, it will take next week."""
21	21
22	22	# TODO Handle given begin and end
23	23	context = dict()
24	24	#context = {'money' : update_balance(None)}
25	25	template = "administration/roster.djhtml"
26	26
27	27	if begin is None or end is None:
28	28	today = datetime.date.today()
29	29	if today.isoweekday() in {6,7}: # Weekend
30	30	begin = today + datetime.timedelta(days=8-today.isoweekday())
31	31	end = today + datetime.timedelta(days=13-today.isoweekday())
32	32	else: # Same week
33	33	begin = today - datetime.timedelta(days=today.weekday())
34	34	end = today + datetime.timedelta(days=5-today.isoweekday())
35	35	else: # Changing regexes to date objects
36	36	b = begin.split("-")
37	37	e = end.split("-")
38	38	begin = datetime.datetime(int(b[2]),int(b[1]),int(b[0]))
39	39	end = datetime.datetime(int(e[2]),int(e[1]),int(e[0]))
40	40
41	41	context['begin'] = begin
42	42	context['end'] = end
43	43
44	44	context['prev_begin'] = (begin - datetime.timedelta(days=7)).strftime("%d-%m-%Y")
45	45	context['prev_end'] = (begin - datetime.timedelta(days=2)).strftime("%d-%m-%Y")
46	46	context['next_begin'] = (end + datetime.timedelta(days=2)).strftime("%d-%m-%Y")
47	47	context['next_end'] = (end + datetime.timedelta(days=7)).strftime("%d-%m-%Y")
48	48
49	49	days = [begin]
50	50	while (end-days[-1]).days != 0:
51	51	# Human translation: Keep adding days until the last day in the array of
52	52	# days is the same day as the last day the user wants to see the roster for.
53	53	days.append(days[-1] + datetime.timedelta(days=1))
54	54	context['days'] = days
55	55
56	56	# Collecting events
57	57	course_events = CourseEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end).order_by("begin_time")
58	58	#university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
59	59	#study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
60	60	#events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
61	61	conflicts, table_code = create_roster_rows(course_events)
62	62
63	63	context['time_blocks'] = table_code
64	64	context['conflicts'] = conflicts
65	65	#print(time_blocks)
66	66	return render(request, template, context)
67	67	# TODO Finish!
68	68
69	69	def roster_ics(request, user_slug):
70	70	template = "administration/roster.ics"
71	71	context = dict()
72	72	context['events'] = CourseEvent.objects.all() # FIXME: Filter to personal calendar items!
73	73	return render(request, template, context)
74	74
75	75	def index(request):
76	76	template = "administration/index.djhtml"
77	77	#context = {'money': update_balance(None)}
78	78	return render(request, template, context)
79	79
80	80	pass
81	81
82	82	def pre_registration(request):
83	83	user_data_form = UserDataForm()
84	84	template = "administration/pre_registration.djhtml"
85	85	context = dict()
86	86
87	87	if request.method == 'POST':
88	88	user_data_form = UserDataForm(request.POST)
89	89	context['user_data_form'] = user_data_form
90	90	if user_data_form.is_valid():
91	91	user_data_form.save()
92	92	context['messsage'] = _("Your registration has been completed. You will receive an e-mail shortly.")
93	93	else:
94	94	context['messsage'] = _("The data you supplied had errors. Please review your submission.")
95	95	else:
96	96	context['user_data_form'] = UserDataForm(instance = user_data_form)
97	97
98	98	return render(request, template, context)
99	99	pass
100	100
101	101	@login_required
102	102	def settings(request):
103	103	user_data = UserData.objects.get(user=request.user)
104	104	user_data_form = UserDataForm(instance = user_data)
105	105	template = "administration/settings.djhtml"
106	106	#context = {'money' : update_balance(None)}
+	107	#context = {'money' : update_balance(None)}
107	108
108	109	if request.method == 'POST':
109	110	user_data_form = UserDataForm(request.POST, instance = user_data)
110	111	context['user_data_form'] = user_data_form
111	112	if user_data_form.is_valid():
112	113	user_data_form.save()
113	114	context['messsage'] = _("Your settings were successfully updated.")
114	115	else:
115	116	context['messsage'] = _("The data you supplied had errors. Please review your submission.")
116	117	else:
117	118	context['user_data_form'] = UserDataForm(instance = user_data)
118	119
119	120	return render(request, template, context)
120	121
121	122	@login_required
122	123	def bulletin_board(request):
123	124	context = dict()
124	125	#context = {'money' : update_balance(None)}
125	126	context['exam_commission_decisions'] = ExamCommissionDecision.objects.filter(user=request.user)
126	127	context['education_department_messages'] = EducationDepartmentMessages.objects.all()
127	128	for item in context['education_department_messages']:
128	129	print(item.text)
129	130	template = "administration/bulletin_board.djhtml"
130	131	return render(request, template, context)
131	132
132	133	def jobs(request):
133	134	context = dict()
134	135	#context = {'money' : update_balance(None)}
135	136	template = "administration/jobs.djhtml"
136	137	#@context['decisions'] = ExamCommissionDecision.objects.filter(user=request.user)
137	138	return render(request, template, context)
138	139
139	140
140	141	@login_required
141	142	def curriculum(request):
142	143	context = dict()
143	144	#context = {'money' : update_balance(None)}
144	145	template = "administration/curriculum.djhtml"
145	146	context['curricula'] = Curriculum.objects.filter(student=request.user)
146	147	context['cource_results'] = CourseResult.objects.filter(student=request.user)
147	-	return render(request, template, context)
+	148	for co in item.course_programmes_results():
+	149	print(co)
+	150	return render(request, template, context)
148	151
149	152	def result(request):
150	153	return render(request, template, context)
151	154
152	155	@login_required
153	156	def results(request):
154	157	results = CourseResult.objects.filter(student=request.user)
155	158	template = "administration/results.djhtml"
156	159	# TODO
157	160	return render(request, template, context)
158	161
159	162	def forms(request):
160	163	context = dict()
161	164	#context = {'money' : update_balance(None)}
162	165	template = "administration/forms.djhtml"
163	166	return render(request, template, context)
164	167
165	168	def user(request, slug_name):
166	169	pass
167	170
168	171	def rooms(request):
169	172	context = dict()
170	173	#context = {'money' : update_balance(None)}
171	174	context['rooms'] = Room.objects.all()
172	175	context['room_reservations'] = RoomReservation.objects.all()
173	176	context['course_events'] = CourseEvent.objects.all()
174	177	context['blocks'] = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
175	178
176	179
177	-
+	180	now = datetime.datetime.now(datetime.timezone.utc)
+	181	end = now + datetime.timedelta(hours=2)
+	182	free_rooms = dict()
+	183	for room in context['rooms']:
+	184	if room.reservation_possible(now, end):
+	185	event = room.next_event(end)
+	186	reservation = room.next_reservation(end)
+	187	if event is None and reservation is None:
+	188	free_rooms[room] = None
+	189	elif reservation is not None:
+	190	free_rooms[room] = event.begin_time
+	191	elif event is not None:
+	192	free_rooms[room] = reservation.begin_time
+	193	elif event.begin_time < reservation.begin_time:
+	194	free_rooms[room] = event.begin_time
+	195	else:
+	196	free_rooms[room] = reservation.begin_time
+	197	context['free_rooms'] = free_rooms
+	198
178	199	template = "administration/rooms.djhtml"
179	200	return render(request, template, context)
180	201
181	202	def room_detail(request, room):
182	203	template = "administration/room_detail.djhtml"
183	204	context = dict()
184	205	#context = {'money' : update_balance(None)}
185	206	room = Room.objects.get(name=room)
186	207	context['room'] = room
187	208	context['reservations'] = RoomReservation.objects.filter(room=room).filter(begin_time__gte=datetime.datetime.now())
188	209	context['course_events'] = CourseEvent.objects.filter(room=room).filter(begin_time__gte=datetime.datetime.now())
189	210	# Building the room occupancy of today:
190	211	today = datetime.date.today()
191	212	if today.isoweekday() in {6,7}: # Weekend
192	213	today = today + datetime.timedelta(days=8-today.isoweekday())
193	214
194	215	context['days'] = [today]
195	216
196	217	# Collecting events
197	218	course_events = CourseEvent.objects.filter(room=room).filter(begin_time__date=today)
198	219	print(course_events)
199	220	#university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
200	221	#study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
201	222	#events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
202	223
203	224	conflicts, table_code = create_roster_rows(course_events)
204	225	context['time_blocks'] = table_code
205	226	context['conflicts'] = conflicts
206	227	print(context['time_blocks'])
207	228	return render(request, template, context)
208	229
209	230	def login(request):
210	231	context = dict()
211	232	#context = {'money' : update_balance(None)}
212	233	if request.method == "POST":
213	234	name = request.POST['name']
214	235	passphrase = request.POST['pass']
215	236	user = authenticate(username=name, password=passphrase)
216	237	if user is not None: # The user was successfully authenticated
217	238	print("YA")
218	239	return HttpResponseRedirect(request.POST['next'])
219	240	else: # User credentials were wrong
220	241	context['next'] = request.POST['next']
221	242	context['message'] = _("The given credentials were not correct.")
222	243	else:
223	244	context['next'] = request.GET.get('next', None)
224	245	if context['next'] is None:
225	246	context['next'] = reverse('administration-index')
226	247
227	248	template = 'administration/login.djhtml'
228	249
229	250	return render(request, template, context)
230	251

1	1	from joeni import constants
2	2	from django.utils.translation import ugettext_lazy as _
3	3
4	4	def validate_hex_color(value):
5	5	pass # TODO
6	6
7	7	class Course(models.Model):
8	8	""" Represents a course that is taught at the university. """
9	9	number = models.PositiveSmallIntegerField(
10	10	primary_key=True,
11	11	blank=False,
12	12	help_text=_("The number associated with this course. A leading '0' will be added if the number is smaller than 1000."),
13	13	)
14	14	name = models.CharField(
15	15	max_length=64,
16	16	blank=False,
17	17	help_text=_("The name of this course, in the language that it is taught. Translations are for the appropriate template."),
18	18	)
19	19	color = models.CharField(
20	20	max_length=6,
21	21	blank=False,
22	22	default=constants.COLORS['UHasselt default'],
23	23	help_text=_("The color for this course. Must be an hexadecimal code. "
24	24	"Some standard colors if you don't know what to pick: "
25	25	"<ul><li>0076BE: Faculty of Sciences / Blue</li>"
26	26	"<li>C0D633: Faculty of Transportation Sciences / Green</li>"
27	27	"<li>F4802D: Faculty of Architecture and Arts / Orange</li>"
28	28	"<li>00ACEE: Faculty of Business Economics / Turquoise</li>"
29	29	"<li>9C3591: Faculty of Medicine and Life Sciences / Purple</li>"
30	30	"<li>5BC4BA: Faculty of Engineering Technology / Light blue</li>"
31	31	"<li>E41F3A: Faculty of Law / Red</li></ul>"),
32	32	#validators=['validate_hex_color'], # TODO
33	33	)
34	34	slug_name = models.SlugField(
35	35	blank=False,
36	36	allow_unicode=True,
37	37	unique=True,
38	38	help_text=_("A so-called 'slug name' for this course."),
39	39	)
40	40	# TODO: Add a potential thingy magicky to auto fill the slug name on the course name
41	41	contact_person = models.ForeignKey(
42	42	"administration.User",
43	43	on_delete=models.PROTECT, # A course must have a contact person
44	44	limit_choices_to={'is_staff': True},
45	45	null=False,
46	46	help_text=_("The person to contact regarding this course."),
47	47	related_name="contact_person",
48	48	)
49	49	coordinator = models.ForeignKey(
50	50	"administration.User",
51	51	on_delete=models.PROTECT, # A course must have a coordinator
52	52	limit_choices_to={'is_staff': True},
53	53	null=False,
54	54	help_text=_("The person whom's the coordinator of this course."),
55	55	related_name="coordinator",
56	56	)
57	57	co_owners = models.ManyToManyField(
58	58	"administration.User",
59	59	limit_choices_to={'is_staff': True},
60	60	blank=True, # Allows empty in form validation, and M->M implies null=True
61	61	help_text=_("If applicable: The co-owners of this course."),
62	62	related_name="co_owners",
63	63	)
64	64
65	65	educating_team = models.ManyToManyField(
66	66	"administration.User",
67	67	# No on_delete, since M->M cannot be required at database level
68	68	limit_choices_to={'is_staff': True},
69	69	blank=True,
70	70	help_text=_("The remaining team members of this course."),
71	71	related_name="educating_team",
72	72	)
73	73	language = models.CharField(
74	74	max_length=64,
75	75	choices = (
76	76	('NL', _("Dutch")),
77	77	('EN', _("English")),
78	78	('FR', _("French")),
79	79	),
80	80	null=False,
81	81	help_text=_("The language in which this course is given."),
82	82	)
83	83
84	84	def course_team(self):
85	85	""" Returns a set of all Users that are part of the team of this course. """
86	86	return set(
87	87	self.contact_person,
88	88	self.coordinator,
89	89	self.educating_team,
90	90	)
91	91
92	92	def __str__(self):
93	93	number = str(self.number)
94	94	for i in [10,100,1000]:
95	95	if self.number < i:
96	96	number = "0" + number
97	97	return "(" + number + ") " + self.name
98	98
99	99
100	100	class Prerequisite(models.Model):
101	101	""" Represents a collection of prerequisites a student must have obtained
102	102	before being allowed to partake in this course.
103	103	It's possible that, if a student has obtained credits in a certain set of
104	104	courses, a certain part of the prerequisites do not have to be obtained.
105	105	Because of this, make a different record for each different set. In other
106	106	words: If one set of prerequisites is obtained, and another one isn't, BUT
107	107	they point to the same course, the student is allowed to partake. """
108	108	course = models.ForeignKey(
109	109	"Course",
110	110	on_delete=models.CASCADE,
111	111	null=False,
112	112	help_text=_("The course that these prerequisites are for."),
113	113	related_name="prerequisite_course",
114	114	)
115	115	name = models.CharField(
116	116	max_length=64,
117	117	blank=True,
118	118	help_text=_("To specify a name for this set, if necessary."),
119	119	)
120	120	sequentialities = models.ManyToManyField(
121	121	"Course",
122	122	help_text=_("All courses for which a credit must've been received in order to follow the course."),
123	123	blank=True,
124	124	related_name="sequentialities",
125	125	)
126	126	in_curriculum = models.ManyToManyField(
127	127	"Course",
128	128	help_text=_("All courses that have to be in the curriculum to follow this. If a credit was achieved, that course can be omitted."),
129	129	blank=True,
130	130	related_name="in_curriculum",
131	131	)
132	132	required_study = models.ForeignKey(
133	133	"Study",
134	134	on_delete=models.CASCADE,
135	135	blank=True,
136	136	null=True,
137	137	help_text=_("If one must have a certain amount of obtained ECTS points for a particular course, state that course here."),
138	138	)
139	139	ECTS_for_required_study = models.PositiveSmallIntegerField(
140	140	blank=True,
141	141	null=True,
142	142	help_text=_("The amount of obtained ECTS points for the required course, if any."),
143	143	)
144	144
145	145	def __str__(self):
146	146	if self.name == "":
147	147	return _("Prerequisites for %(course)s") % {'course': str(self.course)}
148	148	else:
149	149	return self.name + " \| " + str(self.course)
150	150
151	151
152	152	class CourseProgramme(models.Model):
153	153	""" It's possible that a course is taught in multiple degree programmes; For
154	154	example: Calculus can easily be taught to physics and mathematics students
155	155	alike. In this table, these relations are set up, and the related properties
156	156	are defined as well. """
157	157	study = models.ForeignKey(
158	158	"Study",
159	159	on_delete=models.CASCADE,
160	160	null=False,
161	161	help_text=_("The study in which the course is taught."),
162	162	)
163	163	course = models.ForeignKey(
164	164	"Course",
165	165	on_delete=models.CASCADE,
166	166	null=False,
167	167	help_text=_("The course that this programme is for."),
168	168	)
169	169	study_programme = models.ForeignKey(
170	170	"StudyProgramme",
171	171	on_delete=models.CASCADE,
172	172	null=False,
173	173	help_text=_("The study programme that this course belongs to."),
174	174	)
175	175	programme_type = models.CharField(
176	176	max_length=1,
177	177	blank=False,
178	178	choices = (
179	179	('C', _("Compulsory")),
180	180	('O', _("Optional")),
181	181	),
182	182	help_text=_("Type of this course for this study."),
183	183	)
184	184	study_hours = models.PositiveSmallIntegerField(
185	185	blank=False,
186	186	help_text=_("The required amount of hours to study this course."),
187	187	)
188	188	ECTS = models.PositiveSmallIntegerField(
189	189	blank=False,
190	190	help_text=_("The amount of ECTS points attached to this course."),
191	191	)
192	192	semester = models.PositiveSmallIntegerField(
193	193	blank=False,
194	194	choices = (
195	195	(1, _("First semester")),
196	196	(2, _("Second semester")),
197	197	(3, _("Full year course")),
198	198	(4, _("Taught in first quarter")),
199	199	(5, _("Taught in second quarter")),
200	200	(6, _("Taught in third quarter")),
201	201	(7, _("Taught in fourth quarter")),
202	202	),
203	203	help_text=_("The period in which this course is being taught in this study."),
204	204	)
205	205	year = models.PositiveSmallIntegerField(
206	206	blank=False,
207	207	help_text=_("The year in which this course is taught for this study."),
208	208	)
209	209	second_chance = models.BooleanField(
210	210	default=True,
211	211	help_text=_("Defines if a second chance exam is planned for this course."),
212	212	)
213	213	tolerable = models.BooleanField(
214	214	default=True,
215	215	help_text=_("Defines if a failed result can be tolerated."),
216	216	)
217	217	scoring = models.CharField(
218	218	max_length=2,
219	219	choices = (
220	220	('N', _("Numerical")),
221	221	('FP', _("Fail/Pass")),
222	222	),
223	223	default='N',
224	224	blank=False,
225	225	help_text=_("How the obtained score for this course is given."),
226	226	)
227	227
228	228	def __str__(self):
229	229	return str(self.study) + " - " + str(self.course)
230	230
231	231	class Study(models.Model):
232	232	""" Defines a certain study that can be followed at the university.
233	233	This also includes abridged study programmes, like transition programmes.
234	234	Other information, such as descriptions, are kept in the template file
235	235	of this study, which can be manually edited. Joeni searches for a file
236	236	with the exact name as the study + ".html". So if the study is called
237	237	"Bachelor of Informatics", it will search for "Bachelor of Informatics.html".
238	238	"""
239	239	# Degree types
240	240	BSc = _("Bachelor of Science")
241	241	MSc = _("Master of Science")
242	242	LLB = _("Bachelor of Laws")
243	243	LLM = _("Master of Laws")
244	244	BA = _("Bachelor of Arts")
245	245	MA = _("Master of Arts")
246	246	ir = _("Engineer")
247	247	ing = _("Technological Engineer")
248	-	# Faculties
+	248	# Faculties
249	249	FoMaLS = _("Faculty of Medicine and Life Sciences")
250	250	FoS = _("Faculty of Sciences")
251	251	FoTS = _("Faculty of Transportation Sciences")
252	252	FoAaA = _("Faculty of Architecture and Arts")
253	253	FoBE = _("Faculty of Business Economics")
254	254	FoET = _("Faculty of Engineering Technology")
255	255	FoL = _("Faculty of Law")
256	256
257	257	name = models.CharField(
258	258	max_length=128,
259	259	blank=False,
260	260	unique=True,
261	261	help_text=_("The full name of this study, in the language it's taught in."),
262	262	)
263	263	degree_type = models.CharField(
264	264	max_length=64,
265	265	choices = (
266	266	('BSc', BSc),
267	267	('MSc', MSc),
268	268	('LL.B', LLB),
269	269	('LL.M', LLM),
270	270	('ir.', ir ),
271	271	('ing.',ing),
272	272	('BA', BA),
273	273	('MA', MA),
274	274	),
275	275	blank=False,
276	276	help_text=_("The type of degree one obtains upon passing this study."),
277	277	)
278	278	language = models.CharField(
279	279	max_length=64,
280	280	choices = (
281	281	('NL', _("Dutch")),
282	282	('EN', _("English")),
283	283	('FR', _("French")),
284	284	),
285	285	null=False,
286	286	help_text=_("The language in which this study is given."),
287	287	)
288	288	# Information about exam committee
289	289	chairman = models.ForeignKey(
290	290	"administration.User",
291	291	on_delete=models.PROTECT,
292	292	null=False,
293	293	limit_choices_to={'is_staff': True},
294	294	help_text=_("The chairman of this study."),
295	295	related_name="chairman",
296	296	)
297	297	vice_chairman = models.ForeignKey(
298	298	"administration.User",
299	299	on_delete=models.PROTECT,
300	300	null=False,
301	301	help_text=_("The vice-chairman of this study."),
302	302	limit_choices_to={'is_staff': True},
303	303	related_name="vice_chairman",
304	304	)
305	305	secretary = models.ForeignKey(
306	306	"administration.User",
307	307	on_delete=models.PROTECT,
308	308	null=False,
309	309	help_text=_("The secretary of this study."),
310	310	limit_choices_to={'is_staff': True},
311	311	related_name="secretary",
312	312	)
313	313	ombuds = models.ForeignKey(
314	314	"administration.User",
315	315	on_delete=models.PROTECT,
316	316	null=False,
317	317	help_text=_("The ombuds person of this study."),
318	318	limit_choices_to={'is_staff': True},
319	319	related_name="ombuds",
320	320	)
321	321	vice_ombuds = models.ForeignKey(
322	322	"administration.User",
323	323	on_delete=models.PROTECT,
324	324	null=False,
325	325	help_text=_("The (replacing) ombuds person of this study."),
326	326	limit_choices_to={'is_staff': True},
327	327	related_name="vice_ombuds",
328	328	)
329	329	additional_members = models.ManyToManyField(
330	330	"administration.User",
331	331	help_text=_("All the other members of the exam committee."),
332	332	limit_choices_to={'is_staff': True},
333	333	related_name="additional_members",
334	334	)
335	335	faculty = models.CharField(
336	336	max_length=6,
337	337	choices = (
338	338	('FoS', FoS),
339	339	('FoTS', FoTS),
340	340	('FoAaA', FoAaA),
341	341	('FoBE', FoBE),
342	342	('FoMaLS', FoMaLS),
343	343	('FoET', FoET),
344	344	('FoL', FoL),
345	345	),
346	346	blank=False,
347	347	help_text=_("The faculty where this study belongs to."),
348	348	)
349	349
350	350	#def study_points(self):
351	351	""" Returns the amount of study points for this year.
352	352	This value is inferred based on the study programme information
353	353	records that lists this study as their foreign key. """
354	354	#total_ECTS = 0
355	355	#for course in CourseProgramme.objects.filter(study=self):
356	356	#total_ECTS += course.ECTS
357	357	#return total_ECTS
358	358	# XXX: Commented because this is actually something for the StudyProgramme
359	359	def years(self):
360	360	""" Returns the amount of years this study takes.
361	361	This value is inferred based on the study programme information
362	362	records that lists this study as their foreign key. """
363	363	highest_year = 0
364	364	for course in CourseProgramme.objects.filter(study=self):
365	365	highest_year = max(highest_year, course.year)
366	366	return highest_year
367	367
368	368	def students(self):
369	369	""" Cross references the information stored in the database, and
370	370	returns all the students that are following this study in this
371	371	academic year. """
372	372	return 0 # TODO
373	373
374	374
375	375	def __str__(self):
376	376	return self.name
377	377
378	378	class StudyProgramme(models.Model):
379	379	""" Represents a programme within a certain study.
380	380	A good example for this is the different specializations, minors, majors, ...
381	381	one can follow within the same study. Nevertheless, they're all made of
382	382	a certain set of courses. This table collects all these, and allows one to name
383	383	them, so they're distinct from one another. """
384	384	name = models.CharField(
385	385	max_length=64,
386	386	blank=False,
387	387	help_text=_("The name of this programme."),
388	388	)
389	389
390	390	def courses(self):
391	391	""" All courses that are part of this study programme. """
392	392	programmes = CourseProgramme.objects.filter(study_programme=self)
393	393	courses = {}
394	394	for program in programmes:
395	395	courses.add(program.course)
396	396	return courses
397	397
398	398	def study_points(self, year=None):
399	399	""" Returns the amount of study points this programme contains.
400	400	Accepts year as an optional argument. If not given, the study points
401	401	of all years are returned. """
402	402	programmes = CourseProgramme.objects.filter(study_programme=self)
403	403	ECTS = 0
404	404	for program in programmes:
405	405	if year is None or program.year == year:
406	406	# XXX: This only works if the used implementation does lazy
407	407	# evaluation, otherwise this is a type error!
408	408	ECTS += program.ECTS
409	409	return ECTS
410	410
411	411	def __str__(self):
412	412	return self.name
413	413
414	414	# Tables about things related to the courses:
415	415
416	416	class Assignment(models.Model):
417	417	""" For courses, it's possible to set up tasks. These tasks are recorded
418	418	here. """
419	419	# TODO: Require that only the course team can create assignments for a team.
420	420	course = models.ForeignKey(
421	421	"Course",
422	422	on_delete=models.CASCADE,
423	423	null=False,
424	424	#editable=False,
425	425	db_index=True,
426	426	help_text=_("The course for which this task is assigned."),
427	427	)
428	428	title = models.CharField(
429	429	max_length=32,
430	430	blank=False,
431	431	help_text=_("The title of this assignment."),
432	432	)
433	433	information = models.TextField(
434	434	help_text=_("Any additional information regarding the assignment. Orgmode syntax available."),
435	435	)
436	436	deadline = models.DateTimeField(
437	437	null=False,
438	438	help_text=_("The date and time this task is due."),
439	439	)
440	440	posted = models.DateField(auto_now_add=True)
441	441	digital_task = models.BooleanField(
442	442	default=True,
443	443	help_text=_("This determines whether this assignment requires handing "
444	444	"in a digital file."),
445	445	)
446	446
447	447	def __str__(self):
448	448	return str(self.course) +" \| "+ str(self.posted)
449	449
450	450	class Announcement(models.Model):
451	451	""" Courses sometimes have to make announcements for the students. """
452	452	course = models.ForeignKey(
453	453	"Course",
454	454	on_delete=models.CASCADE,
455	455	null=False,
456	456	#editable=False,
457	457	db_index=True,
458	458	help_text=_("The course for which this announcement is made."),
459	459	)
460	460	title = models.CharField(
461	461	max_length=20, # Keep It Short & Simple®
462	462	help_text=_("A quick title for what this is about."),
463	463	)
464	464	text = models.TextField(
465	465	blank=False,
466	466	help_text=_("The announcement itself. Orgmode syntax available."),
467	467	)
468	468	posted = models.DateTimeField(auto_now_add=True)
469	469
470	470	def __str__(self):
471	471	return str(self.course) +" \| "+ self.posted.strftime("%m/%d")
472	472
473	473	class Upload(models.Model):
474	474	""" For certain assignments, digital hand-ins may be required. These hand
475	475	ins are recorded per student in this table. """
476	476	course = models.ForeignKey(
477	477	"Course",
478	478	on_delete=models.CASCADE,
479	479	null=False,
480	480	db_index=True,
481	481	)
482	482	assignment = models.ForeignKey(
483	483	"Assignment",
484	484	on_delete=models.CASCADE,
485	485	null=False,
486	486	#editable=False,
487	487	db_index=True,
488	488	limit_choices_to={"digital_task": True},
489	489	help_text=_("For which assignment this upload is."),
490	490	)
491	491	# TODO: Try to find a way to require that, if the upload is made,
492	492	# only students that have this course in their curriculum can upload.
493	493	student = models.ForeignKey(
494	494	"administration.User",
495	495	on_delete=models.CASCADE,
496	496	null=False,
497	497	#editable=False,
498	498	limit_choices_to={"is_student": True},
499	499	help_text=_("The student who handed this in."),
500	500	)
501	501	upload_time = models.DateTimeField(auto_now_add=True)
502	502	comment = models.TextField(
503	503	blank=True,
504	504	help_text=_("If you wish to add an additional comment, state it here."),
505	505	)
506	506	file = models.FileField(
507	507	upload_to="assignments/uploads/%Y/%m/",
508	508	null=False,
509	509	#editable=False,
510	510	help_text=_("The file you want to upload for this assignment."),
511	511	)
512	512
513	513
514	514	def __str__(self):
515	515	deadline = self.assignment.deadline
516	516	if deadline < self.upload_time:
517	517	return str(self.assignment.course) +" \| "+ str(self.student.number) + _("(OVERDUE)")
518	518	else:
519	519	return str(self.assignment.course) +" \| "+ str(self.student.number)
520	520
521	521	def item_upload_directory(instance, filename):
522	522	return "courses/" + instance.course.slug_name + "/"
523	523	class CourseItem(models.Model):
524	524	""" Reprensents study material for a course that is being shared by the
525	525	course's education team. """
526	526	course = models.ForeignKey(
527	527	Course,
528	528	on_delete=models.CASCADE,
529	529	null=False,
530	530	#editable=False,
531	531	)
532	532	file = models.FileField(
533	533	upload_to=item_upload_directory,
534	534	null=False,
535	535	#editable=False,
536	536	help_text=_("The file you wish to upload."),
537	537	)
538	538	timestamp = models.DateTimeField(auto_now_add=True)
539	539	note = models.TextField(
540	540	blank=True,
541	541	help_text=_("If you want to state some additional information about "
542	542	"this upload, state it here."),
543	543	)
544	544
545	545	class StudyGroup(models.Model):
546	546	""" It may be necessary to make study groups regarding a course. These
547	547	are recorded here, and blend in seamlessly with the Groups from Agora.
548	548	Groups that are recorded as a StudyGroup, are given official course status,
549	549	and thus, cannot be removed until the status of StudyGroup is lifted. """
550	550	course = models.ForeignKey(
551	551	"Course",
552	552	on_delete=models.CASCADE,
553	553	null=False,
554	554	#editable=False,
555	555	db_index=True,
556	556	help_text=_("The course for which this group is."),
557	557	)
558	558	group = models.ForeignKey(
559	559	"agora.Group",
560	560	on_delete=models.PROTECT, # See class documentation
561	561	null=False,
562	562	#editable=False, # Keep the same group
563	563	help_text=_("The group that will be seen as the study group."),
564	564	)
565	565
566	566	def __str__(self):
567	567	return str(self.course) +" \| "+ str(self.group)
568	568
569	569	class CourseGroup(models.Model):
570	570	"""Because of size, some studies may use multiple groups for the different
571	571	students, so it's possible to facilitate all of them. These groups must be
572	572	registered here."""
573	573	study = models.ForeignKey(
574	574	"Study",
575	575	on_delete=models.CASCADE,
576	576	null=False,
577	577	)
578	578	# TODO: How to attach students to certain groups? The curriculum or what?
579	579

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	]
+	11	]
11	12

1	1	{% load static %}
2	2	{% get_media_prefix as media %}
3	3	<img width="200px" src="{% static "logos/uhasselt/simple_white.svg" %}" alt="◀ Joeni /▶" />
4	4	<ul>
5	-	<li>
6	-	<a href="{% url 'agora-index' %}">Agora</a>
7	-	</li>
8	-	<li>
9	-	<a href="{% url 'administration-index' %}">{% trans "Administration" %}</a>
10	-	</li>
11	-	<li>
12	-	<a href="{% url 'courses-index' %}">{% trans "Courses" %}</a>
13	-	</li>
14	-	</ul>
15	-
+	5	<ul>
+	6	<li><a href="{% url 'agora-index' %}">Agora</a>
+	7	<ul>
+	8	</ul>
+	9	</li>
+	10
+	11	<li><a href="{% url 'administration-index' %}">{% trans "Administration" %}</a>
+	12	<ul>
+	13	<li><a href="{% url 'administration-settings' %}">{% trans "Personal settings" %}</a></li>
+	14	<li><a href="{% url 'administration-curriculum' %}">{% trans "Curricula" %}</a></li>
+	15	<li><a href="{% url 'administration-forms' %}">{% trans "Forms" %}</a></li>
+	16	<li><a href="{% url 'administration-rooms' %}">{% trans "Rooms" %}</a></li>
+	17	<li><a href="{% url 'administration-jobs' %}">{% trans "Jobs" %}</a></li>
+	18	<li><a href="{% url 'administration-roster' %}">{% trans "Personal Roster" %}</a></li>
+	19	<li><a href="{% url 'administration-bulletin-board' %}">{% trans "Bulletin board" %}</a></li>
+	20	</ul>
+	21	</li>
+	22
+	23	<li><a href="{% url 'courses-index' %}">{% trans "Courses" %}</a>
+	24	<ul>
+	25	</ul>
+	26	</li>
+	27	</ul>
+	28	</nav>
+	29	PingPing: €{{ money }}
+	30

1	-	position: relative;
2	-	top: 0;
3	-	width: 100%;
4	-	background-color: #E73B2B;
5	-	margin-top: -8px;
6	-	margin-left: -8px;
7	-	}
8	-	header ul {
9	-	display: inline;
10	-	float: right;
11	-	}
12	-