joeni

from django.db import models

from django import forms

from django.core.exceptions import ValidationError

from django.core.validators import MaxValueValidator

from django.utils.translation import ugettext_lazy as _

from django.utils.text import slugify

from django.contrib.auth.models import AbstractUser

from joeni.constants import current_academic_year

import datetime

import os

import uuid

import courses

#from . import roster

def validate_IBAN(value):

    """ Validates if the given value qualifies as a valid IBAN number.

    This validator checks if the structure is valid, and calculates the control

    number if the structure is correct. If the control number fails, or the

    structure is invalid, a ValidationError will be raised. In that case,

    the Error will specify whether the structure is incorrect, or the control

    number is not valid.

    """

    # FIXME: This function is not complete. When there's time, implement

    # as specified at https://nl.wikipedia.org/wiki/International_Bank_Account_Number#Structuur

    if False:

        raise ValidationError(

            _('%(value)s is not a valid IBAN number.'),

            params={'value': value},)

def validate_BIC(value):

    """ Same functionality as validate_IBAN, but for BIC-codes. """

    # FIXME: This function is not complete. When there's time, implement

    # as specified at https://nl.wikipedia.org/wiki/Business_Identifier_Code

    pass

class User(AbstractUser):

    """ Replacement for the standard Django User model. """

    number = models.AutoField(

        primary_key=True,

        help_text=_("The number assigned to this user."),

        )

    created = models.DateField(auto_now_add=True)

    def __str__(self):

        user_data = UserData.objects.filter(user=self)

        if len(user_data) == 0:

            return self.username

        else:

            user_data = user_data[0]

            name = user_data.first_name +" "+ user_data.last_name

            titles = user_data.title.split()

            if len(titles) == 0:

                return name

            else:

                prefix_titles = ""

                suffix_titles = ""

                for title in titles:

                    if title in ["lic.", "prof.", "dr.", "drs.", "bc.", "bacc.", "ing.", "ir." "cand.", "mr.", "dr.h.c.mult.", "dr.h.c.", "dr.mult.", "em. prof.", "prof. em.", "lec."]:

                        prefix_titles += title + " "

                    elif title in ["MSc", "BSc", "MA", "BA", "LLM", "LLB", "PhD", "MD"]:

                        suffix_titles += title + " "

            return prefix_titles + name + " " + suffix_titles.strip()

class UserData(models.Model):

    user = models.OneToOneField("User", on_delete=models.CASCADE, related_name="user_data")

    first_name = models.CharField(max_length=64, blank=False)

    last_name = models.CharField(max_length=64, blank=False)

    title = models.CharField(

        max_length=64,

        blank=True,

        help_text=_("The academic title of this user, if applicable."),

        )

    DOB = models.DateField(

        blank=False,

        #editable=False,  # For testing purposes, decomment in deployment!

        help_text=_("The date of birth of this user."),

        )

    POB = models.CharField(

        max_length=64,

        blank=False,

        #editable=False,  # For testing purposes, decomment in deployment!

        help_text=_("The place of birth of this user."),

        )

    nationality = models.CharField(

        max_length=64,

        blank=False,

        help_text=_("The current nationality of this user."),

        default="Belg",

        )

    # XXX: What if this starts with zeros?

    national_registry_number = models.BigIntegerField(

        blank=True,  # Only possible if Belgian

        # TODO Validator!

        #editable=False,

        help_text=_("The assigned national registry number of this user."),

        )

    civil_status = models.CharField(

        max_length=32,

        choices = (

            ("Single", _("Single")),

            ("Married", _("Married")),

            ("Divorced", _("Divorced")),

            ("Widowed", _("Widowed")),

            ("Partnership", _("Partnership")),

            ),

        blank=False,

        # There may be more; consult http://www.aantrekkingskracht.com/trefwoord/burgerlijke-staat

        # for more information.

        help_text=_("The civil/marital status of the user."),

        )

    is_staff = models.BooleanField(

        default=False,

        help_text=_("Determines if this user is part of the university's staff."),

        )

    is_student = models.BooleanField(

        default=True,

        help_text=_("Indicates if this user is a student at the university."),

        )

    def current_courses(self):

        """Returns a set of all the courses this user has access to.

        For a student, the result is equal to the set of courses in his/her

        curriculum of the current year. For personnel, this equals the set of

        courses that they are connected to."""

        courses_set = set()

        if self.is_student:

            curriculum = Curriculum.objects.filter(student=self.user).get(year=current_academic_year())

            for course in curriculum.courses():

                courses_set.add(course)

        if self.is_staff:

            for course in courses.models.Course.objects.all():

                if self.user in course.course_team():

                    courses_set.add(course)

        return courses_set

    def slug_name(self):

        """Returns a slug name for this user which can be used to reference in

        URLs."""

        same_names = UserData.objects.filter(first_name=self.first_name).filter(last_name=self.last_name)

        if len(same_names) == 1 and same_names[0] == self:

            return slugify(self.first_name +"-"+ self.last_name, allow_unicode=True)

        else:

            number = self.user.number

            return slugify(self.first_name +"-"+ self.last_name +"-"+ str(number), allow_unicode=True)

    # Home address

    home_street = models.CharField(max_length=64, blank=False)

    home_number = models.PositiveSmallIntegerField(blank=False)

    home_bus = models.CharField(max_length=10, null=True, blank=True)

    home_postal_code = models.PositiveIntegerField(blank=False)

    home_city = models.CharField(max_length=64, blank=False)

    home_country = models.CharField(max_length=64, blank=False, default="België")

    home_telephone = models.CharField(

        max_length=64,

        help_text=_("The telephone number for the house address. Prefix 0 can be presented with the national call code in the system (\"32\" for Belgium)."),

        )

    # Study address

    study_street = models.CharField(max_length=64, blank=True, null=True)

    study_number = models.PositiveSmallIntegerField(blank=True, null=True)

    study_bus = models.CharField(max_length=10, null=True, blank=True)

    study_postal_code = models.PositiveSmallIntegerField(blank=True, null=True)

    study_country = models.CharField(max_length=64, blank=True, null=True)

    study_telephone = models.CharField(

        blank=True, null=True,

        max_length=64,

        help_text=_("The telephone number for the study address. Prefix 0 can be presented with the national call code in the system."),

        )

    study_cellphone = models.CharField(

        max_length=64, null=True, blank=True,

        help_text=_("The cellphone number of the person. Prefix 0 can be presented with then national call code in the system."),

        )

    # Titularis address

    # XXX: These fields are only required if this differs from the user itself.

    titularis_street = models.CharField(max_length=64, null=True, blank=True)

    titularis_number = models.PositiveSmallIntegerField(null=True, blank=True)

    titularis_bus = models.CharField(max_length=10, null=True, blank=True)

    titularis_postal_code = models.PositiveSmallIntegerField(null=True, blank=True)

    titularis_country = models.CharField(max_length=64, null=True, blank=True)

    titularis_telephone = models.CharField(

        max_length=64,

        help_text=_("The telephone number of the titularis. Prefix 0 can be presented with the national call code in the system."),

        null=True,

        blank=True,

        )

    # Financial details

    bank_account_number = models.CharField(

        max_length=34,  # Max length of all IBAN account numbers

        validators=[validate_IBAN],

        help_text=_("The IBAN of this user. No spaces!"),

        )

    BIC = models.CharField(

        max_length=11,

        validators=[validate_BIC],

        help_text=_("The BIC of this user's bank."),

        )

""" NOTE: What about all the other features that should be in the administration?

While there are a lot of things to cover, as of now, I have no way to know which

ones are still valid, which are deprecated, and so on...

Additionally, every feature may have a different set of requirements, data,

and it's very likely making an abstract class won't do any good. Thus I have

decided to postpone making additional tables and forms for these features until

I have clearance about certain aspects. """

class Curriculum(models.Model):

    """ The curriculum of a particular student.

    Every academic year, a student has to hand in a curriculum (s)he wishes to

    follow. This is then reviewed by a committee. A curriculum exists of all the

    courses one wants to partake in in a certain year. """

    student = models.ForeignKey(

        "User",

        on_delete=models.CASCADE,

        limit_choices_to={'groups': 1},  # 1 = Students group ID

        null=False,

        #editable=False,

        #unique_for_year="year",  # Only 1 curriculum per year # FIXME to work with integer!

        )

    year = models.PositiveIntegerField(

        null=False,

        default=datetime.date.today().year,

        help_text=_("The academic year for which this curriculum is. "

                    "If this field is equal to 2008, then that means "

                    "this curriculum is for the academic year "

                    "2008-2009."),

        )

    # TODO: Validate changes: A curriculum cannot undergo another change if the

    # academic year it was made in is history.

    last_modified = models.DateTimeField(

        auto_now=True,

        help_text=_("The last timestamp that this was updated."),

        )

    course_programmes = models.ManyToManyField(

        "courses.CourseProgramme",

        blank=False,  # An empty curriculum makes no sense

        help_text=_("All the course programmes included in this curriculum."),

        )

    approved = models.NullBooleanField(

        default=None,

        help_text=_("Indicates if this curriculum has been approved. If true, "

                    "that means the responsible committee has reviewed and "

                    "approved the student for this curriculum. False otherwise. "

                    "If review is still pending, the value is NULL. Modifying "

                    "the curriculum implies this setting is set to NULL again."),

        )

    note = models.TextField(

        blank=True,

        help_text=_("Additional notes regarding this curriculum. This has "

                    "multiple uses. For the student, it is used to clarify "

                    "any questions, or to motivate why (s)he wants to take a "

                    "course for which the requirements were not met. "

                    "The reviewing committee can use this field to argument "

                    "their decision, especially for when the curriculum is "

                    "denied."),

        )

    def course_programmes_results(self):

        """ Returns a dictionary, where the keys are the course_programmes

        in this curriculum, and the values are the course_results associated

        with them."""

        join_dict = dict()

        for course_program in self.course_programmes.all():

            result = CourseResult.objects.filter(

                student=self.student).filter(

                    course_programme=course_program).filter(

                        year=self.year)

            if len(result) == 0:

                join_dict[course_program] = None

            else:

                join_dict[course_program] = result[0]

        return join_dict

    def courses(self):

        """ Returns a set of all the courses that are in this curriculum.

        This is not the same as CourseProgrammes, as these can differ depending

        on which study one follows. """

        course_set = set()

        for course_programme in self.course_programmes.all():

            course_set.add(course_programme.course)

        return course_set

    def curriculum_type(self):

        """ Returns the type of this curriculum. At the moment, this is

        either a standard programme, or an individualized programme. """

        # Currently: A standard programme means: All courses are from the

        # same study, ánd from the same year. Additionally, all courses

        # from that year must've been taken.

        # FIXME: Need a way to determine what is the standard programme.

        # If not possible, make this a charfield with options or something

        pass

    def __str__(self):

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

    def clean(self):

        """ NOTE: The clean method of Curriculum is rather special, in that it

        creates new model instances based on its current state. Also, it

        prohibits changing the curriculum if the academic year has passed (as if

        the instance has gone in an "archive" state). """

        if self.year != current_academic_year():

            raise ValidationError(

                _('This curriculum is from the academic year %(year)s - %(new_year)s,'

                  ' and can no longer be changed.'),

                params={'year': self.year, 'new_year': self.year + 1})

        if self.approved is True:

            # When approved, add necessary course results and remove scrapped courses

            student_course_results = CourseResult.objects.filter(student=self.student).filter(year=self.year)

class CourseResult(models.Model):

    """ A student has to obtain a certain course result. These are stored here,

    together with all the appropriate information. """

    # TODO: Validate that a course programme for a student can only be made once per year for each course, if possible.

    CRED = _("Credit acquired")

    FAIL = _("Credit not acquired")

    TLRD = _("Tolerated")

    ITLR = _("Tolerance used")

    BDRG = _("Fraud committed")

    VRST = _("Exemption")

    STOP = _("Course cancelled")

    GEEN = _("No result available")

    # Possible to add more in the future

    student = models.ForeignKey(

        "User",

        on_delete=models.CASCADE,

        #limit_choices_to={'is_student': True},

        null=False,

        db_index=True,

        )

    course_programme = models.ForeignKey(

        "courses.CourseProgramme",

        on_delete=models.PROTECT,

        null=False,

        )

    def course(self):

        return self.course_programme.course

    year = models.PositiveIntegerField(

        null=False,

        default=datetime.date.today().year,

        help_text=_("The academic year this course took place in. If 2018 is entered, "

                    "then that means academic year '2018-2019'."),

        )

    released = models.DateField(

        auto_now=True,

        help_text=_("The date that this result was last updated."),

        )

    first_score = models.PositiveSmallIntegerField(

        null=True,  # It's possible a score does not exist.

        blank=True,

        validators=[MaxValueValidator(

            20,

            _("The score mustn't be higher than 20."),

            )],

        )

    second_score = models.PositiveSmallIntegerField(

        null=True,

        blank=True,

        validators=[MaxValueValidator(

            20,

            _("The score mustn't be higher than 20."),

            )],

        )

    result = models.CharField(

        max_length=10,

        choices = (

            ("CRED", CRED),

            ("FAIL", FAIL),

            ("TLRD", TLRD),

            ("ITLR", ITLR),

            ("BDRG", BDRG),

            ("VRST", VRST),

            ("STOP", STOP),

            ("GEEN", GEEN),

            ),

        blank=False,

        default = GEEN,

        )

    def __str__(self):

        stdnum = str(self.student.number)

        result = self.result

        if result == "CRED":

            if self.first_score < 10:

                result = "C" + str(self.first_score) + "1"

            else:

                result = "C" + str(self.second_score) + "2"

        course = str(self.course_programme.course)

        return stdnum +" ("+ result +") | "+ course

class PreRegistration(models.Model):

    """ At the beginning of the new academic year, students can register

    themselves at the university. Online, they can do a preregistration already.

    These records are stored here and can later be retrieved for the actual

    registration process.

    Note: The current system in use at Hasselt University provides a password system.

    That will be eliminated here. Just make sure that the entered details are correct.

    Should there be an error, and the same email address is used to update something,

    a mail will be sent to that address to verify this was a genuine update."""

    created = models.DateField(auto_now_add=True)

    first_name = models.CharField(max_length=64, blank=False, help_text=_("Your first name."))

    last_name = models.CharField(max_length=64, blank=False, help_text=_("Your last name."))

    additional_names = models.CharField(max_length=64, blank=True, help_text=_("Any additional names."))

    title = models.CharField(

        max_length=64,

        blank=True,

        help_text=_("Any additional titles, prefixes, ..."),

        )

    DOB = models.DateField(

        blank=False,

        #editable=False,

        help_text=_("Your date of birth."),

        )

    POB = models.CharField(

        max_length=64,

        blank=False,

        #editable=False,

        help_text=_("The place you were born."),

        )

    nationality = models.CharField(

        max_length=64,

        blank=False,

        help_text=_("Your current nationality."),

        )

    national_registry_number = models.BigIntegerField(

        null=True,

        help_text=_("If you have one, your national registry number."),

        )

    civil_status = models.CharField(

        max_length=32,

        choices = (

            ("Single", _("Single")),

            ("Married", _("Married")),

            ("Divorced", _("Divorced")),

            ("Widowed", _("Widowed")),

            ("Partnership", _("Partnership")),

            ),

        blank=False,

        # There may be more; consult http://www.aantrekkingskracht.com/trefwoord/burgerlijke-staat

        # for more information.

        help_text=_("Your civil/marital status."),

        )

    email = models.EmailField(

        blank=False,

        unique=True,

        help_text=_("The e-mail address we will use to communicate until your actual registration."),

        )

    study = models.ForeignKey(

        "courses.Study",

        on_delete=models.PROTECT,

        null=False,

        help_text=_("The study you wish to follow. Be sure to provide all legal"

                    "documents that are required for this study with this "

                    "application, or bring them with you to the final registration."),

        )

    study_type = models.CharField(

        max_length=32,

        choices = (

            ("Diplom contract", _("Diplom contract")),

            ("Exam contract", _("Exam contract")),

            ("Credit contract", _("Credit contract")),

            ),

        blank=False,

        help_text=_("The type of study contract you wish to follow."),

        )

    document = models.FileField(

        upload_to="pre-enrollment/%Y",

        help_text=_("Any legal documents regarding your enrollment."),

        )

    # XXX: If the database in production is PostgreSQL, comment document, and

    # uncomment the next column.

    """documents = models.ArrayField(

        models.FileField(upload_to="pre-enrollment/%Y"),

        help_text=_("Any legal documents regarding your enrollment."),

        )"""

    def __str__(self):

        name = self.last_name +" "+ self.first_name

        dob = self.DOB.strftime("%d/%m/%Y")

        return name +" | "+ dob

# Planning and organization related tables

class Room(models.Model):

    """ Represents a room in the university.

    Rooms can have a number of properties, which are stored in the database.

    """

    # Types of rooms

    LABORATORY = _("Laboratory")  # Chemistry/Physics equipped rooms

    CLASS_ROOM = _("Class room")  # Simple class rooms

    AUDITORIUM = _("Auditorium")  # Large rooms with ample seating and equipment for lectures

    PC_ROOM    = _("PC room"   )  # Rooms equipped for executing PC related tasks

    PUBLIC_ROOM= _("Public room") # Restaurants, restrooms, ... general public spaces

    OFFICE     = _("Office"    )  # Private offices for staff

    PRIVATE_ROOM = _("Private room")  # Rooms accessible for a limited public; cleaning cupboards, kitchens, ...

    WORKSHOP   = _("Workshop"  )  # Rooms with hardware equipment to build and work on materials

    OTHER      = _("Other"     )  # Rooms that do not fit in any other category

    name = models.CharField(

        max_length=20,

        primary_key=True,

        blank=False,

        help_text=_("The name of this room. If more appropriate, this can be the colloquial name."),

        )

    seats = models.PositiveSmallIntegerField(

        help_text=_("The amount of available seats in this room."),

        )

    wheelchair_accessible = models.BooleanField(default=True)

    exams_equipped = models.BooleanField(

        default=True,

        help_text=_("Indicates if exams can reasonably be held in this room."),

        )

    loose_tables = models.BooleanField(

        default=True,

        help_text=_("If true, the tables in this room can be moved freely. "

                    "If false, they're bolted down in their positions."),

        )

    electrical_plugs = models.PositiveSmallIntegerField(

        help_text=_("The amount of electrical plugs that are available to the "

                    "people for free use. Electrical plugs that are more or "

                    "less constantly occupied by permanent equipment (such as "

                    "computers, beamers, ...) are excluded from counting."),

        )

    exterior_window = models.BooleanField(

        default=True,

        help_text=_("Indicates if this room has a window to the outside."),

        )

    software_available = models.TextField(

        blank=True,

        help_text=_("Some software used at the university is proprietary, and "

                    "thus not available at every system. If certain "

                    "software is installed on the computers in this room that "

                    "cannot be found on other computers, list them here."),

        )

    computers_available = models.PositiveSmallIntegerField(

        default=0,

        help_text=_("Indicates how many computers are available in this room."),

        )

    projector_available = models.BooleanField(

        default=False,

        help_text=_("Indicates if a projector is available at this room."),

        )

    blackboards_available = models.PositiveSmallIntegerField(

        help_text=_("The amount of blackboards available in this room."),

        )

    whiteboards_available = models.PositiveSmallIntegerField(

        help_text=_("The amount of whiteboards available in this room."),

        )

    category = models.CharField(

        max_length=16,

        blank=False,

        choices = (

            ("LABORATORY", LABORATORY),

            ("CLASS_ROOM", CLASS_ROOM),

            ("AUDITORIUM", AUDITORIUM),

            ("PC_ROOM", PC_ROOM),

            ("PUBLIC_ROOM", PUBLIC_ROOM),

            ("OFFICE", OFFICE),

            ("PRIVATE_ROOM", PRIVATE_ROOM),

            ("WORKSHOP", WORKSHOP),

            ("OTHER", OTHER),

            ),

        help_text=_("The category that best suits the character of this room."),

        )

    reservable = models.BooleanField(

        default=True,

        help_text=_("Indicates if this room can be reserved for something."),

        )

    note = models.TextField(

        blank=True,

        help_text=_("If some additional info is required for this room, like a "

                    "characteristic property (e.g. 'Usually occupied by 2BACH "

                    "informatics'), state it here."),

        )

    # TODO: Add a campus/building field or not?

    def next_reservation(self, time):

        """ Returns the next reservation starting from the given time, or, if

        the next reservation starts on the given time, that reservation.

        Returns None if there is no reservation from this moment on."""

        reservations = RoomReservation.objects.filter(room=self).filter(begin_time__gte=time).order_by('begin_time')

        if len(reservations) == 0:

            return None

        else:

            return reservations[0]

    def next_event(self, time):

        """ Returns the next event starting from the given time, or, if

        the next event starts on the given time, that event.

        Returns None if there is no event from this moment on."""

        events = CourseEvent.objects.filter(room=self).filter(begin_time__gte=time).order_by('begin_time')

        if len(events) == 0:

            return None

        else:

            return events[0]

    def reservation_possible(self, begin, end, seats=None):

        # TODO: Include events in the check for possibilities!

        """ Returns a boolean indicating if reservating during the given time

        is possible. If the begin overlaps with a reservation's end or vice versa,

        this is regarded as possible.

        Takes seats as optional argument. If not specified, it is assumed the entire

        room has to be reserved. """

        if self.reservable is False:

            return False

        if seats is not None and seats < 0: raise ValueError(_("seats ∈ ℕ"))

        reservations = RoomReservation.objects.filter(room=self)

        for reservation in reservations:

            if reservation.end_time <= begin or reservation.begin_time >= end:

                continue  # Can be trivially skipped, no overlap here

            elif seats is None or reservation.seats is None:

                return False  # The whole room cannot be reserved -> False

            elif seats + reservation.seats > self.seats:

                    return False  # Total amount of seats exceeds the available amount -> False

        return True  # No overlappings found -> True

    def __str__(self):

        return self.name

# Validators that will be used for RoomReservations and Events

def validate_event_time(time):

    """Checks if the time is a quarter of an hour (0, 15, 30, or 45)."""

    if time.minute not in [0, 15, 30, 45] or time.second != 0:

        raise ValidationError(

            _('%(time)s is not in the quarter of an hour.'),

            params={'time': time.strftime("%H:%M")})

def validate_university_hours(value):

    """Checks if the datetime value given takes place during the opening hours

    of the university (08:00 - 20:00)."""

    if value.hour < 8 or (value.hour == 22 and value.minute != 0) or value.hour >= 23:

        raise ValidationError(

            _("All events and reservations must begin and end between 08:00 "

              "and 22:00."))

def overlaps(begin_a, end_a, begin_b, end_b):

    """Checks if timespan a and b overlap with each other. If one of them ends at

    the same time the other one begins, it does not count as an overlap.

    This function assumes the end takes place strictly /after/ the begin."""

    if end_a <= begin_b or end_b <= begin_a:

        return False

    if (

            begin_a < begin_b <= end_a or

            begin_b < begin_a <= end_b or

            begin_a <= end_b < end_a or

            begin_b <= end_a < end_b):

        return True

    else:

        return False

def general_reservation_validator(self):

    # Check for overlapping reservations

    # TODO: Try to make it possible to link to the reservator,

    # to display the reason, to show the available times that a

    # reservation can be made for that room, and so on... Make it

    # a bit more interactive.

    for reservation in RoomReservation.objects.filter(room=self.room):

        if overlaps(self.begin_time,

                    self.end_time,

                    reservation.begin_time,

                    reservation.end_time):

            if isinstance(self, RoomReservation):

                if self.room.reservation_possible(self.begin_time, self.end_time, self.seats):

                    continue  # Both reservations can take place in the same room

                raise ValidationError(

                _("It is not possible to plan this event/reservation in "

                "%(room)s from %(self_begin)s to %(end_begin)s on %(day)s. "

                "%(reservator)s has already "

                "reserved it from %(res_begin)s to %(res_end)s."),

                params={'room': str(self.room),

                        'self_begin': self.begin_time.strftime("%H:%M"),

                        'self_end': self.end_time.strftime("%H:%M"),

                        'day': self.begin_time.strftime("%A (%d/%m)"),

                        'reservator': str(reservation.reservator),

                        'res_begin': reservation.begin_time.strftime("%H:%M"),

                        'res_end': reservation.end_time.strftime("%H:%M"),

                        })

    for course_event in CourseEvent.objects.filter(room=self.room):

        if overlaps(self.begin_time,

                    self.end_time,

                    course_event.begin_time,

                    course_event.end_time):

            raise ValidationError(

                _("%(docent)s has organized a %(subject)s in %(room)s from "

                    "%(res_begin)s to %(res_end)s on %(day)s, so you cannot "

                    "place a reservation there from %(self_begin)s to "

                    "%(self_end)s."),

                params={'room': str(self.room),

                        'self_begin': self.begin_time.strftime("%H:%M"),

                        'self_end': self.end_time.strftime("%H:%M"),

                        'day': self.begin_time.strftime("%A (%d/%m)"),

                        'docent': str(course_event.docent),

                        'subject': course_event.subject,

                        'res_begin': course_event.begin_time.strftime("%H:%M"),

                        'res_end': course_event.end_time.strftime("%H:%M"),})

    # Checking for correct timings:

    if self.begin_time >= self.end_time:

        raise ValidationError(

            _("The begin time (%(begin)) must take place <em>before</em> "

                "the end time (%(end))."),

            params={'begin': self.begin_time.strftime("%H:%M"),

                    'end': self.end_time.strftime("%H:%M"),})

    """if not roster.same_day(self.begin_time, self.end_time):

        raise ValidationError(

            _("The event/reservation must begin and end on the same day."))"""

class RoomReservation(models.Model):

    """ Rooms are to be reserved from time to time. They can be reserved

    by externals, for something else, and whatnot. That is stored in this table.

    """

    room = models.ForeignKey(

        "Room",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        db_index=True,

        limit_choices_to={"reservable": True},

        help_text=_("The room that is being reserved at this point."),

    )

    reservator = models.ForeignKey(

        "User",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        help_text=_("The person that made the reservation (and thus responsible)."),

    )

    timestamp = models.DateTimeField(auto_now_add=True)

    begin_time = models.DateTimeField(

        null=False,

        help_text=_("The time that this reservation begin."),

        validators=[validate_event_time,validate_university_hours],

    )

    end_time = models.DateTimeField(

        null=False,

        help_text=_("The time that this reservation ends."),

        validators=[validate_event_time,validate_university_hours],

    )

    seats = models.PositiveSmallIntegerField(

        null=True,

        blank=True,