joeni | Gitar

Big update to roster functionality

Today's been almost solely dedicated to roster updates. I've added a lot of functionality to make it possible to display events in the roster. I've also done some small updates to some of the models, because while some models allowed null values, it wasn't possible to /add/ null values, that required a blank. I've also added a validator for the events, so that they all take place in a quarter. I might lift this restriction in the future if I find a good and reliable way to make it work properly with HTML5 tables, but for now, this is pretty enough.

Author: Maarten 'Vngngdn' Vangeneugden
Date: Feb. 2, 2018, 11:16 p.m.
Hash: db2baced09f3dd36acf8ca5ebb352e88c7b30ed1
Parent: 09579b7d3616c73134d6fe268f106bb32513d21b
Modified files: administration/models.py; administration/templates/administration/roster.djhtml; administration/views.py; courses/models.py

administration/models.py ¶

16 additions and 2 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.contrib.auth.models import AbstractUser
import datetime
import os
import uuid

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)

class UserData(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    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,
        help_text=_("The date of birth of this user."),
        )
    POB = models.CharField(
        max_length=64,
        blank=False,
        #editable=False,
        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."),
        )

    # 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)
    study_number = models.PositiveSmallIntegerField(blank=True)
    study_bus = models.CharField(max_length=10, null=True, blank=True)
    study_postal_code = models.PositiveSmallIntegerField(blank=True)
    study_country = models.CharField(max_length=64, blank=True)
    study_telephone = models.CharField(
        blank=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,
        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)
    titularis_bus = models.CharField(max_length=10, null=True, blank=True)
    titularis_postal_code = models.PositiveSmallIntegerField(null=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,
        )

    # 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={'is_student': True},
        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. "
                    "If this field is equal to 2008, then that means "
                    "this curriculum is for the academic year "
                    "2008-2009."),
        )
    last_modified = models.DateTimeField(
        auto_now=True,
        help_text=_("The last timestamp that this was updated."),
        )
    course_programmes = models.ManyToManyField(
        "courses.CourseProgramme",
        null=False,
        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 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:
            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")
    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,
        )
    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(
            20,
            _("The score mustn't be higher than 20."),
            )],
        )
    second_score = models.PositiveSmallIntegerField(
        null=True,
        validators=[MaxValueValidator(
            20,
            _("The score mustn't be higher than 20."),
            )],
        )
    result = models.CharField(
        max_length=10,
        choices = (
            ("CRED", CRED),
            ("FAIL", FAIL),
            ("TLRD", TLRD),
            ("ITLD", ITLD),
            ),
        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:
                result = "C" + self.second_score + "2"
        course = str(self.course_programme.course)
        return stdnum +" ("+ result +") | "+ course

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

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


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


    name = models.CharField(
        max_length=20,
        primary_key=True,
        blank=False,
        help_text=_("The name of this room. If more appropriate, this can be the colloquial name."),
        )
    seats = models.PositiveSmallIntegerField(
        help_text=_("The amount of available seats in this room. This can be handy for exams for example."),
        )
    wheelchair_accessible = models.BooleanField(default=True)
    exams_equipped = models.BooleanField(
        default=True,
        help_text=_("Indicates if exams can reasonably be held in this room."),
        )
    computers_available = models.PositiveSmallIntegerField(
        default=False,
        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 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 <= begin or reservation.begin >= 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

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)
    start_time = models.DateTimeField(
        null=False,
        help_text=_("The time that this reservation starts."),
        )
    end_time = models.DateTimeField(
        null=False,
        help_text=_("The time that this reservation ends."),
        )
    seats = models.PositiveSmallIntegerField(
        null=True,
        help_text=_("Indicates how many seats are required. If this is left null, "
                    "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

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):
    """Checks if the time is a quarter of an hour (0, 15, 30, or 45)."""
    if time.minute not in [0, 15, 30, 45]:
        raise ValidationError(
            _('%(time)s is not in the quarter of an hour.'),
            params={'time': time},
        )

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."),
        verbose_name=_("begin time"),
                    "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"),
        )
        )
    end_time = models.DateTimeField(
        null=False,
        help_text=_("The end date and time that this event takes place."),
        verbose_name=_("end time"),
                    "This value must be a quarter of an hour (0, 15, 30, 45), "
                    "and take place <em>after</em> this event's begin time."),
        verbose_name=_("end time"),
        )
        )
    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,
        )

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,
        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.Group",
        on_delete = models.CASCADE,
        null=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."),
        )

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."""
    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 = _("Decision of the exam commission")
        verbose_name_plural = _("Decisions of the exam commission")


administration/templates/administration/roster.djhtml ¶

39 additions and 0 deletions.

View changes Hide changes

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

{% block title %}
    {% trans "Roster | ◀ Joeni /▶" %}
{% endblock %}

{% block main %}
    {% include "administration/nav.djhtml" %}
    <h1>{% trans "Personal timetable" %}</h1>
    <p>
    <p>
        {% trans "Personal roster from" %} {{ begin|date }} {% trans "to" %} {{ end|date }}
    </p>
    <table>
        {% blocktrans %}
            Some fields may have additional information that might be of interest
            to you. This information is shown in different ways with colour codes.
        {% endblocktrans %}
    </p>
    <p>
        {% blocktrans %}
            Most fields have a single colour, determined by the course. This makes
            it easier to differentiate on a glance what hours are for what courses.
        {% endblocktrans %}
    </p>
    <p>
        {% blocktrans %}
            Some fields have a
            <span style="background-color:yellow; color: red; border: medium dotted red;">
                bright yellow background, with red text and a red dotted border.</span>
            This indicates this event had one or more of its properties changed
            in the last five days. This can be the room, the hours, the subject, ...
            You're encouraged to take note of that.
        {% endblocktrans %}
    </p>
    <p>
        {% blocktrans %}
            Some fields are <span style="border: medium dashed black; background-color: white; color: black;">
            white with a dashed black border.</span> This indicates this event
            is new, and was added in the last five days.
        {% endblocktrans %}
    </p>
    <p>
        {% blocktrans %}
            Fields that flash <span style="color:orange; border: medium solid orange;">
            orange with the same coloured border</span> have a note attached to
            them by the docent/speaker. Hover over the event to display the note.
        {% endblocktrans %}
    </p>

    <h2>{% trans "Main hour roster" %}
    <table>
        <th>
            <td></td> {# Empty row for hours #}
            {% for day in days %}
                <td>{{ day|date:"l (d/m)" }}</td>
            {% endfor %}
        </th>
        {% for time, events in time_blocks %}
            <tr>
                {% if hour == "hour" %}
                    <td>{{ time }}</td>
                {% else %}
                    <td></td>
                {% endif %}
                {% cycle hour %}
                <td>{{ time }}</td>
                <!--<td rowspan="5">AI</td>
                <td>Dinsdag</td>
                <td>Dinsdag</td>
                <td>Woensdag</td>
                <td>Dondeddag</td>
                <td>Vdijdag</td>
                <td>Zaterdag</td>-->
            </tr>
        {% endfor %}
    </table>
{% endblock main %}


administration/views.py ¶

99 additions and 19 deletions.

View changes Hide changes

from django.http import HttpResponseRedirect
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
import administration
from django.contrib.auth.decorators import login_required
from django.contrib.auth import authenticate

@login_required
def make_day_buckets(events):
    """Returns a dict with all days that the given events take place.
    Every day between the first and last event will get a bucket in the dict,
    with the keys in format "dd-mm-yyyy". Also days without events will be
    included, but will simply have empty buckets."""
    first_event = events[0]
    last_event = events[0]
    days = OrderedDict()  # This is the first time I ever use an OrderedDict and I intend it to be my last one as well.
    for event in events:
        if event < first_event:
            first_event = event
        if event > last_event:
            last_event = event
    days_count = (last_event - first_event).days
    event_counter = first_event
    for i in range(days_count):
        days[event_counter.strftime("%d-%m-%Y")] = list()
        event_counter += datetime.timedelta(days=1)
    for event in events:
        days[event.strftime("%d-%m-%Y")].append(event)

    return days  # Yay! ^.^


def create_roster_rows(events):
    """Creates the rows for use in the roster table.
    None of the times in the given events may overlap, and all must start and
    end at a quarter of the hour (so :00, :15, :30, or :45). If you think you're above this,
    I'll raise you a ValueError, kind sir.
    Events must be of administration.models.Event type."""
    for event in events:
        for other_event in events:
            if (
                    (event.begin_time > other_event.begin_time and event.begin_time > other_event.end_time)
                    or (event.end_time > other_event.begin_time and event.end_time > other_event.end_time)
                    ):
                raise ValueError("One of the events overlaps with another event.")
        if event.begin_time.minute not in [0, 15, 30, 45] or event.end_time.minute not in [0, 15, 30, 45]:
            raise ValueError("One of the events did not begin or end on a quarter.")

    # All events validated
    days = make_day_buckets(events)

    table_code = list()
    for hour in range(8, 20):
        for quarter in [0, 15, 30, 45]:
            quarter_line = "<tr><td>"
            if hour < 10:
                quarter_line += "0"
            quarter_line += str(hour) + ":"
            if quarter == 0:
                quarter_line += "0"
            quarter_line += str(quarter) + "</td>"

            for day in days:
                for event in day:
                    if event.begin_time.hour == hour and event.begin_time.minute == quarter:
                        quarters = (event.end_time - event.begin_time).minutes // 15
                        event_line = "<td "
                        if isinstance(event, administration.CourseEvent) and (datetime.datetime.today() - event.last_update).days > 5:
                            event_line += "style='backgrond-color: #"+event.course.color+"; color: white;' "
                        elif (datetime.datetime.today() - event.last_update).days <= 5:
                            event_line += "style='backgrond-color: yellow; color: red;' "
                        if event.note:
                            event_line +="title='" +event.note+ "' "

                        # FIXME: From here, I just assume the events are all CourseEvents, because
                        # that is the most important one to implement for the prototype.
                        if quarters > 1:
                            event_line += "rowspan='"+str(quarters)+"' "

                        event_line +=">"
                        event_line += str(
                            + "<a href=" + reverse("courses-course-index", args="")+"> "  # FIXME so that this links to the course's index page
                            + str(event.course)
                            + "<br />"
                            + str(event.docent)
                            + "<br />"
                            + str(event.room) + " (" + str(event.subject) + ")</a></td>")
                        quarter_line += event_line
                    else:
                        quarter_line += "<td></td>"

            quarter_line += "</tr>"
            code += quarter_line
    return code







@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()
    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())
    context['begin'] = begin
    context['end'] = end

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

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

    # Producing time blocks for display in the table
    time_blocks = []
    for i in range(8, 20):
        time_block = str(i)
        for j in range(0, 60, 15):
            if j == 0:
                time_blocks.append([time_block + ":00",""])
                continue
            time_blocks.append([time_block + ":" + str(j), ""])
    context['time_blocks'] = time_blocks

    # Preparing events for the template
    c_es = []
    for course_event in course_events:
        duration = course_event.end - course_event.begin
        quarters = duration.minutes // 15
        course_item = str(
              "<td style='background-color:'"+course_event.course.course.color+";' rowspan='"
            + str(quarters) + "'>"
            + "<a href=" + reverse("courses-course-index", args="")+"> "  # FIXME so that this links to the course's index page
            + str(course_event.course)
            + "<br />"
            + str(course_event.docent)
            + "<br />"
            + str(course_event.room) + " (" + str(course_event.subject) + ")</a></td>")





    return render(request, template, context)
    # TODO Finish!

def index(request):
    template = "administration/index.djhtml"
    context = {}
    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)

    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 = dict()

    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['exam_commission_decisions'] = ExamCommissionDecision.objects.filter(user=request.user)
    context['education_department_messages'] = ExamCommissionDecision.objects.filter(user=request.user)
    template = "administration/bulletin_board.djhtml"
    return render(request, template, context)

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


def curriculum(request):
    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):
    return render(request, template, context)

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

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

def login(request):
    context = dict()
    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 ¶

24 additions and 4 deletions.

View changes Hide changes

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

def validate_hex_color(value):
    pass


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."),
        #validators=['validate_hex_color'],
        )
                    "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",
        )
    educating_team = 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},
        #null=False,  # Useless on a M->M
        help_text=_("The remaining team members of this course."),
        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."),
        related_name="sequentialities",
        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."),
        related_name="in_curriculum",
        related_name="in_curriculum",
        )
    required_study = models.ForeignKey(
        "Study",
        on_delete=models.CASCADE,
        null=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(
        null=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
    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. """
    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 Group(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?


1	1	{% cycle "hour" "first quarter" "half" "last quarter" as hour silent %}
2	2	{# "silent" blocks the cycle operator from printing the cycler, and in subsequent calls #}
3	3	{% load i18n %}
4	4
5	5	{% block title %}
6	6	{% trans "Roster \| ◀ Joeni /▶" %}
7	7	{% endblock %}
8	8
9	9	{% block main %}
10	10	{% include "administration/nav.djhtml" %}
11	11	<h1>{% trans "Personal timetable" %}</h1>
12	12	<p>
+	13	<p>
13	14	{% trans "Personal roster from" %} {{ begin\|date }} {% trans "to" %} {{ end\|date }}
14	15	</p>
15	16	<table>
+	17	{% blocktrans %}
+	18	Some fields may have additional information that might be of interest
+	19	to you. This information is shown in different ways with colour codes.
+	20	{% endblocktrans %}
+	21	</p>
+	22	<p>
+	23	{% blocktrans %}
+	24	Most fields have a single colour, determined by the course. This makes
+	25	it easier to differentiate on a glance what hours are for what courses.
+	26	{% endblocktrans %}
+	27	</p>
+	28	<p>
+	29	{% blocktrans %}
+	30	Some fields have a
+	31	<span style="background-color:yellow; color: red; border: medium dotted red;">
+	32	bright yellow background, with red text and a red dotted border.</span>
+	33	This indicates this event had one or more of its properties changed
+	34	in the last five days. This can be the room, the hours, the subject, ...
+	35	You're encouraged to take note of that.
+	36	{% endblocktrans %}
+	37	</p>
+	38	<p>
+	39	{% blocktrans %}
+	40	Some fields are <span style="border: medium dashed black; background-color: white; color: black;">
+	41	white with a dashed black border.</span> This indicates this event
+	42	is new, and was added in the last five days.
+	43	{% endblocktrans %}
+	44	</p>
+	45	<p>
+	46	{% blocktrans %}
+	47	Fields that flash <span style="color:orange; border: medium solid orange;">
+	48	orange with the same coloured border</span> have a note attached to
+	49	them by the docent/speaker. Hover over the event to display the note.
+	50	{% endblocktrans %}
+	51	</p>
+	52
+	53	<h2>{% trans "Main hour roster" %}
+	54	<table>
16	55	<th>
17	56	<td></td> {# Empty row for hours #}
18	57	{% for day in days %}
19	58	<td>{{ day\|date:"l (d/m)" }}</td>
20	59	{% endfor %}
21	60	</th>
22	61	{% for time, events in time_blocks %}
23	62	<tr>
24	63	{% if hour == "hour" %}
25	64	<td>{{ time }}</td>
26	65	{% else %}
27	66	<td></td>
28	67	{% endif %}
29	68	{% cycle hour %}
30	69	<td>{{ time }}</td>
31	70	<!--<td rowspan="5">AI</td>
32	71	<td>Dinsdag</td>
33	72	<td>Dinsdag</td>
34	73	<td>Woensdag</td>
35	74	<td>Dondeddag</td>
36	75	<td>Vdijdag</td>
37	76	<td>Zaterdag</td>-->
38	77	</tr>
39	78	{% endfor %}
40	79	</table>
41	80	{% endblock main %}
42	81

1	1	from django.http import HttpResponseRedirect
+	2	from django.http import HttpResponseRedirect
2	3	import datetime
3	4	from django.urls import reverse # Why?
4	5	from django.utils.translation import gettext as _
5	6	from .models import *
6	7	from .forms import UserDataForm
7	8	import administration
8	9	from django.contrib.auth.decorators import login_required
9	10	from django.contrib.auth import authenticate
10	11
11	12	@login_required
+	13	def make_day_buckets(events):
+	14	"""Returns a dict with all days that the given events take place.
+	15	Every day between the first and last event will get a bucket in the dict,
+	16	with the keys in format "dd-mm-yyyy". Also days without events will be
+	17	included, but will simply have empty buckets."""
+	18	first_event = events[0]
+	19	last_event = events[0]
+	20	days = OrderedDict() # This is the first time I ever use an OrderedDict and I intend it to be my last one as well.
+	21	for event in events:
+	22	if event < first_event:
+	23	first_event = event
+	24	if event > last_event:
+	25	last_event = event
+	26	days_count = (last_event - first_event).days
+	27	event_counter = first_event
+	28	for i in range(days_count):
+	29	days[event_counter.strftime("%d-%m-%Y")] = list()
+	30	event_counter += datetime.timedelta(days=1)
+	31	for event in events:
+	32	days[event.strftime("%d-%m-%Y")].append(event)
+	33
+	34	return days # Yay! ^.^
+	35
+	36
+	37	def create_roster_rows(events):
+	38	"""Creates the rows for use in the roster table.
+	39	None of the times in the given events may overlap, and all must start and
+	40	end at a quarter of the hour (so :00, :15, :30, or :45). If you think you're above this,
+	41	I'll raise you a ValueError, kind sir.
+	42	Events must be of administration.models.Event type."""
+	43	for event in events:
+	44	for other_event in events:
+	45	if (
+	46	(event.begin_time > other_event.begin_time and event.begin_time > other_event.end_time)
+	47	or (event.end_time > other_event.begin_time and event.end_time > other_event.end_time)
+	48	):
+	49	raise ValueError("One of the events overlaps with another event.")
+	50	if event.begin_time.minute not in [0, 15, 30, 45] or event.end_time.minute not in [0, 15, 30, 45]:
+	51	raise ValueError("One of the events did not begin or end on a quarter.")
+	52
+	53	# All events validated
+	54	days = make_day_buckets(events)
+	55
+	56	table_code = list()
+	57	for hour in range(8, 20):
+	58	for quarter in [0, 15, 30, 45]:
+	59	quarter_line = "<tr><td>"
+	60	if hour < 10:
+	61	quarter_line += "0"
+	62	quarter_line += str(hour) + ":"
+	63	if quarter == 0:
+	64	quarter_line += "0"
+	65	quarter_line += str(quarter) + "</td>"
+	66
+	67	for day in days:
+	68	for event in day:
+	69	if event.begin_time.hour == hour and event.begin_time.minute == quarter:
+	70	quarters = (event.end_time - event.begin_time).minutes // 15
+	71	event_line = "<td "
+	72	if isinstance(event, administration.CourseEvent) and (datetime.datetime.today() - event.last_update).days > 5:
+	73	event_line += "style='backgrond-color: #"+event.course.color+"; color: white;' "
+	74	elif (datetime.datetime.today() - event.last_update).days <= 5:
+	75	event_line += "style='backgrond-color: yellow; color: red;' "
+	76	if event.note:
+	77	event_line +="title='" +event.note+ "' "
+	78
+	79	# FIXME: From here, I just assume the events are all CourseEvents, because
+	80	# that is the most important one to implement for the prototype.
+	81	if quarters > 1:
+	82	event_line += "rowspan='"+str(quarters)+"' "
+	83
+	84	event_line +=">"
+	85	event_line += str(
+	86	+ "<a href=" + reverse("courses-course-index", args="")+"> " # FIXME so that this links to the course's index page
+	87	+ str(event.course)
+	88	+ "<br />"
+	89	+ str(event.docent)
+	90	+ "<br />"
+	91	+ str(event.room) + " (" + str(event.subject) + ")</a></td>")
+	92	quarter_line += event_line
+	93	else:
+	94	quarter_line += "<td></td>"
+	95
+	96	quarter_line += "</tr>"
+	97	code += quarter_line
+	98	return code
+	99
+	100
+	101
+	102
+	103
+	104
+	105
+	106	@login_required
12	107	def roster(request, begin=None, end=None):
13	108	"""Collects and renders the data that has to be displayed in the roster.
14	109
15	110	The begin and end date can be specified. Only roster points in that range
16	111	will be included in the response. If no begin and end are specified, it will
17	112	take the current week as begin and end point. If it's
18	113	weekend, it will take next week."""
19	114
20	115	# TODO Handle given begin and end
21	116	context = dict()
22	117	template = "administration/roster.djhtml"
23	118
24	119	if begin is None or end is None:
25	120	today = datetime.date.today()
26	121	if today.isoweekday() in {6,7}: # Weekend
27	122	begin = today + datetime.timedelta(days=8-today.isoweekday())
28	123	end = today + datetime.timedelta(days=13-today.isoweekday())
29	124	else: # Same week
30	125	begin = today - datetime.timedelta(days=today.weekday())
31	126	end = today + datetime.timedelta(days=5-today.isoweekday())
32	127	context['begin'] = begin
33	128	context['end'] = end
34	129
35	130	days = [begin]
36	131	while (end-days[-1]).days != 0:
37	132	# Human translation: Keep adding days until the last day in the array of
38	133	# days is the same day as the last day the user wants to see the roster for.
39	134	days.append(days[-1] + datetime.timedelta(days=1))
40	135	context['days'] = days
41	136
42	137	# Collecting events
43	138	course_events = CourseEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
44	139	university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
45	-	study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
46	-	events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
47	-
+	140	#study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
+	141	#events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
+	142
48	143	# Producing time blocks for display in the table
49	144	time_blocks = []
50	145	for i in range(8, 20):
51	146	time_block = str(i)
52	147	for j in range(0, 60, 15):
53	148	if j == 0:
54	149	time_blocks.append([time_block + ":00",""])
55	150	continue
56	151	time_blocks.append([time_block + ":" + str(j), ""])
57	152	context['time_blocks'] = time_blocks
58	153
59	-	# Preparing events for the template
60	-	c_es = []
61	-	for course_event in course_events:
62	-	duration = course_event.end - course_event.begin
63	-	quarters = duration.minutes // 15
64	-	course_item = str(
65	-	"<td style='background-color:'"+course_event.course.course.color+";' rowspan='"
66	-	+ str(quarters) + "'>"
67	-	+ "<a href=" + reverse("courses-course-index", args="")+"> " # FIXME so that this links to the course's index page
68	-	+ str(course_event.course)
69	-	+ "<br />"
70	-	+ str(course_event.docent)
71	-	+ "<br />"
72	-	+ str(course_event.room) + " (" + str(course_event.subject) + ")</a></td>")
73	-
74	-
+	154
75	155
76	156
77	157	return render(request, template, context)
78	158	# TODO Finish!
79	159
80	160	def index(request):
81	161	template = "administration/index.djhtml"
82	162	context = {}
83	163	return render(request, template, context)
84	164
85	165	pass
86	166
87	167	def pre_registration(request):
88	168	user_data_form = UserDataForm()
89	169	template = "administration/pre_registration.djhtml"
90	170	context = dict()
91	171
92	172	if request.method == 'POST':
93	173	user_data_form = UserDataForm(request.POST)
94	174	context['user_data_form'] = user_data_form
95	175	if user_data_form.is_valid():
96	176	user_data_form.save()
97	177	context['messsage'] = _("Your registration has been completed. You will receive an e-mail shortly.")
98	178	else:
99	179	context['messsage'] = _("The data you supplied had errors. Please review your submission.")
100	180	else:
101	181	context['user_data_form'] = UserDataForm(instance = user_data)
102	182
103	183	return render(request, template, context)
104	184	pass
105	185
106	186	@login_required
107	187	def settings(request):
108	188	user_data = UserData.objects.get(user=request.user)
109	189	user_data_form = UserDataForm(instance = user_data)
110	190	template = "administration/settings.djhtml"
111	191	context = dict()
112	192
113	193	if request.method == 'POST':
114	194	user_data_form = UserDataForm(request.POST, instance = user_data)
115	195	context['user_data_form'] = user_data_form
116	196	if user_data_form.is_valid():
117	197	user_data_form.save()
118	198	context['messsage'] = _("Your settings were successfully updated.")
119	199	else:
120	200	context['messsage'] = _("The data you supplied had errors. Please review your submission.")
121	201	else:
122	202	context['user_data_form'] = UserDataForm(instance = user_data)
123	203
124	204	return render(request, template, context)
125	205
126	206	@login_required
127	207	def bulletin_board(request):
128	208	context = dict()
129	209	context['exam_commission_decisions'] = ExamCommissionDecision.objects.filter(user=request.user)
130	210	context['education_department_messages'] = ExamCommissionDecision.objects.filter(user=request.user)
131	211	template = "administration/bulletin_board.djhtml"
132	212	return render(request, template, context)
133	213
134	214	def jobs(request):
135	215	context = dict()
136	216	template = "administration/jobs.djhtml"
137	217	#@context['decisions'] = ExamCommissionDecision.objects.filter(user=request.user)
138	218	return render(request, template, context)
139	219
140	220
141	221	def curriculum(request):
142	222	return render(request, template, context)
143	223
144	224	def result(request):
145	225	return render(request, template, context)
146	226
147	227	@login_required
148	228	def results(request):
149	229	results = CourseResult.objects.filter(student=request.user)
150	230	template = "administration/results.djhtml"
151	231	# TODO
152	232	return render(request, template, context)
153	233
154	234	def forms(request):
155	235	return render(request, template, context)
156	236
157	237	def rooms(request):
158	238	template = "administration/rooms.djhtml"
159	239	return render(request, template, context)
160	240
161	241	def room_reservate(request):
162	242	return render(request, template, context)
163	243
164	244	def login(request):
165	245	context = dict()
166	246	if request.method == "POST":
167	247	name = request.POST['name']
168	248	passphrase = request.POST['pass']
169	249	user = authenticate(username=name, password=passphrase)
170	250	if user is not None: # The user was successfully authenticated
171	251	print("YA")
172	252	return HttpResponseRedirect(request.POST['next'])
173	253	else: # User credentials were wrong
174	254	context['next'] = request.POST['next']
175	255	context['message'] = _("The given credentials were not correct.")
176	256	else:
177	257	context['next'] = request.GET.get('next', None)
178	258	if context['next'] is None:
179	259	context['next'] = reverse('administration-index')
180	260
181	261	template = 'administration/login.djhtml'
182	262
183	263	return render(request, template, context)
184	264

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