joeni | Gitar

Further bug fixes on roster and model validation

The roster code is a bit shitty at the moment, but it gets the job done properly and that's the most important thing.
I've added extensive model validation to both RoomReservation and CourseEvent, so that it's impossible to reservate a room that would cause an overlap of reservations.
Style for event with notification has been changed to double purple border for visibility purposes.

Author: Maarten 'Vngngdn' Vangeneugden
Date: Feb. 4, 2018, 10:15 p.m.
Hash: ac4bd94c88e9964d2df6e82c0832d7a22821639a
Parent: 838a4c30e3ac78883df4d4a301ef8929e5be6ffe
Modified files: administration/migrations/0014_auto_20180204_2007.py; administration/migrations/0015_auto_20180204_2009.py; administration/migrations/0016_auto_20180204_2014.py; administration/models.py; administration/roster.py; administration/templates/administration/roster.djhtml; administration/views.py; static/css/base.css

administration/migrations/0014_auto_20180204_2007.py ¶

50 additions and 0 deletions.

View changes Hide changes

+	1
+	2	import administration.models
+	3	import datetime
+	4	from django.db import migrations, models
+	5
+	6
+	7	class Migration(migrations.Migration):
+	8
+	9	dependencies = [
+	10	('administration', '0013_auto_20180204_1444'),
+	11	]
+	12
+	13	operations = [
+	14	migrations.RenameField(
+	15	model_name='userdata',
+	16	old_name='user',
+	17	new_name='user_data',
+	18	),
+	19	migrations.RemoveField(
+	20	model_name='roomreservation',
+	21	name='start_time',
+	22	),
+	23	migrations.AddField(
+	24	model_name='roomreservation',
+	25	name='begin_time',
+	26	field=models.DateTimeField(default=datetime.datetime(2018, 2, 4, 20, 7, 35, 650784), help_text='The time that this reservation begin.', validators=[administration.models.validate_event_time, administration.models.validate_university_hours]),
+	27	preserve_default=False,
+	28	),
+	29	migrations.AlterField(
+	30	model_name='event',
+	31	name='begin_time',
+	32	field=models.DateTimeField(help_text="The begin date and time that this event takes place. This value must be a quarter of an hour (0, 15, 30, 45), and take place <em>before</em> this event's end time.", validators=[administration.models.validate_event_time, administration.models.validate_university_hours], verbose_name='begin time'),
+	33	),
+	34	migrations.AlterField(
+	35	model_name='event',
+	36	name='end_time',
+	37	field=models.DateTimeField(help_text="The end date and time that this event takes place. This value must be a quarter of an hour (0, 15, 30, 45), and take place <em>after</em> this event's begin time, but it must end on the same day as it begins!", validators=[administration.models.validate_event_time, administration.models.validate_university_hours], verbose_name='end time'),
+	38	),
+	39	migrations.AlterField(
+	40	model_name='roomreservation',
+	41	name='end_time',
+	42	field=models.DateTimeField(help_text='The time that this reservation ends.', validators=[administration.models.validate_event_time, administration.models.validate_university_hours]),
+	43	),
+	44	migrations.AlterField(
+	45	model_name='roomreservation',
+	46	name='seats',
+	47	field=models.PositiveSmallIntegerField(blank=True, help_text='Indicates how many seats are required. If this is left empty, it is assumed the entire room has to be reserved.', null=True),
+	48	),
+	49	]
+	50

administration/migrations/0015_auto_20180204_2009.py ¶

18 additions and 0 deletions.

View changes Hide changes

+	1
+	2	from django.db import migrations
+	3
+	4
+	5	class Migration(migrations.Migration):
+	6
+	7	dependencies = [
+	8	('administration', '0014_auto_20180204_2007'),
+	9	]
+	10
+	11	operations = [
+	12	migrations.RenameField(
+	13	model_name='userdata',
+	14	old_name='user_data',
+	15	new_name='user',
+	16	),
+	17	]
+	18

administration/migrations/0016_auto_20180204_2014.py ¶

48 additions and 0 deletions.

View changes Hide changes

+	1
+	2	from django.db import migrations, models
+	3
+	4
+	5	class Migration(migrations.Migration):
+	6
+	7	dependencies = [
+	8	('administration', '0015_auto_20180204_2009'),
+	9	]
+	10
+	11	operations = [
+	12	migrations.AlterField(
+	13	model_name='userdata',
+	14	name='study_cellphone',
+	15	field=models.CharField(help_text='The cellphone number of the person. Prefix 0 can be presented with then national call code in the system.', max_length=64, null=True),
+	16	),
+	17	migrations.AlterField(
+	18	model_name='userdata',
+	19	name='study_country',
+	20	field=models.CharField(blank=True, max_length=64, null=True),
+	21	),
+	22	migrations.AlterField(
+	23	model_name='userdata',
+	24	name='study_number',
+	25	field=models.PositiveSmallIntegerField(blank=True, null=True),
+	26	),
+	27	migrations.AlterField(
+	28	model_name='userdata',
+	29	name='study_postal_code',
+	30	field=models.PositiveSmallIntegerField(blank=True, null=True),
+	31	),
+	32	migrations.AlterField(
+	33	model_name='userdata',
+	34	name='study_street',
+	35	field=models.CharField(blank=True, max_length=64, null=True),
+	36	),
+	37	migrations.AlterField(
+	38	model_name='userdata',
+	39	name='study_telephone',
+	40	field=models.CharField(blank=True, help_text='The telephone number for the study address. Prefix 0 can be presented with the national call code in the system.', max_length=64, null=True),
+	41	),
+	42	migrations.AlterField(
+	43	model_name='userdata',
+	44	name='titularis_telephone',
+	45	field=models.CharField(blank=True, help_text='The telephone number of the titularis. Prefix 0 can be presented with the national call code in the system.', max_length=64, null=True),
+	46	),
+	47	]
+	48

administration/models.py ¶

143 additions and 33 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):
    """name = self.user_data.first_name +" "+ self.user_data.last_name
        titles = self.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)
    first_name = models.CharField(max_length=64, blank=False)
    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."),
        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."),
        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_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)
    study_country = models.CharField(max_length=64, blank=True)
    study_telephone = models.CharField(
    study_country = models.CharField(max_length=64, blank=True, null=True)
    study_telephone = models.CharField(
        blank=True,
        max_length=64,
        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."),
        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_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_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={'groups': 1},  # 1 = Students group ID
        null=False,
        #editable=False,
        unique_for_year="year",  # Only 1 curriculum per year
        )
    year = models.DateField(
        auto_now_add=True,
        db_index=True,
        help_text=_("The academic year for which this curriculum is. "
                    "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
                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):
# 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 == 20 and value.minute != 0) or value.hour >= 21:
        raise ValidationError(
            _("All events and reservations must begin and end between 08:00 "
              "and 20: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 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(
    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)
    timestamp = models.DateTimeField(auto_now_add=True)
    start_time = models.DateTimeField(
        null=False,
        null=False,
        help_text=_("The time that this reservation starts."),
        )
    end_time = models.DateTimeField(
        validators=[validate_event_time,validate_university_hours],
    )
    end_time = models.DateTimeField(
        null=False,
        help_text=_("The time that this reservation ends."),
        )
    seats = models.PositiveSmallIntegerField(
    )
    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."),
        help_text=_("Indicates how many seats are required. If this is left empty, "
                    "it is assumed the entire room has to be reserved."),
        )
    reason = models.CharField(
    reason = models.CharField(
        max_length=64,
        blank=True,
        help_text=_("The reason for this reservation, if useful."),
        )
    note = models.TextField(
    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):
        general_reservation_validator(self)

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

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


# Classes regarding roster items

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]:
        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. "
                    "This value must be a quarter of an hour (0, 15, 30, 45), "
                    "and take place <em>before</em> this event's end time."),
        verbose_name=_("begin time"),
        validators=[validate_event_time],
        )
        )
    end_time = models.DateTimeField(
        null=False,
        help_text=_("The end date and time that this event takes place. "
                    "This value must be a quarter of an hour (0, 15, 30, 45), "
                    "and take place <em>after</em> this event's begin time."),
        verbose_name=_("end time"),
                    "but it must end on the same day as it begins!"),
        verbose_name=_("end time"),
        validators=[validate_event_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,
        null=False,
        help_text=_("The room in which this event will be held."),
        validator=[room_reservation_possible],
        )
    subject = models.CharField(
        max_length=32,
        blank=False,
        help_text=_("The subject of this event. Examples are 'Hoorcollege', "
                    "'Zelfstudie', ..."),
        )
    group = models.ForeignKey(
        "courses.CourseGroup",
        on_delete = models.CASCADE,
        null=True,
        blank=True,
        help_text=_("Some courses have multiple groups. If that's the case, "
                    "and this event is only for a specific group, then that "
                    "group must be referenced here."),
        )

class UniversityEvent(Event):
        general_reservation_validator(self)


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

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

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

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

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

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


administration/roster.py ¶

8 additions and 4 deletions.

View changes Hide changes

building of the roster. """
from django.shortcuts import render
from collections import OrderedDict
import datetime
from django.urls import reverse # Why?
from django.utils.translation import gettext as _
from .models import *
import administration

def same_day(datetime_a, datetime_b):
    """True if both a and b are on the same day, false otherwise."""
    return (
        datetime_a.day == datetime_b.day and
        datetime_a.month == datetime_b.month and
        datetime_a.year == datetime_b.year)


def make_quarter_buckets(events):
    """Returns a dict with all days that the given events take place.
    Every quarter between the first and last event will get a bucket in the dict,
    with the keys in format "dd-mm-yyyy". Also quarters without events will be
    included, but will simply have empty buckets."""
    quarters = OrderedDict()  # This is the first time I ever use an OrderedDict and I intend it to be my last one as well.
    current_quarter = datetime.datetime.now().replace(hour=8, minute=0)
    while current_quarter.hour != 20 or current_quarter.minute != 00:
        quarters[current_quarter.strftime("%H:%M")] = list()
        current_quarter += datetime.timedelta(minutes=15)
    for event in events:
        quarters[event.begin_time.strftime("%H:%M")].append(event)

    return quarters  # 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 other_event is not event and (
                    (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.")

    # XXX: I assume here the given queryset is sorted:
    first_day = events[0].begin_time
    last_day = events.last().begin_time
    # All events validated
    quarter_buckets = make_quarter_buckets(events)
    skip_row = dict()
    table_code = list()

    for quarter_bucket in quarter_buckets.keys():
        # Preparing time column
        quarter_line = "<tr><td style='font-size: xx-small;'>"
        if quarter_bucket[3:] == "00":
            quarter_line += quarter_bucket
        quarter_line += "</td>"

        current_day = first_day
        while not same_day(current_day, last_day+datetime.timedelta(days=1)):
            for event in quarter_buckets[quarter_bucket]:
                if same_day(current_day, event.begin_time):
                    quarters = (event.end_time - event.begin_time).seconds // 60 // 15
                    skip_row[quarter_bucket] = quarters
                    event_line = "<td "
                    if isinstance(event, CourseEvent) and (datetime.datetime.now(datetime.timezone.utc) - event.last_update).days > 5:
                        event_line += "style='backgrond-color: #"+event.course.color+"; color: white;' "
                    elif (datetime.datetime.now(datetime.timezone.utc) - event.last_update).days <= 5:
                    elif (datetime.datetime.now(datetime.timezone.utc) - event.created).days <= 5 and (event.last_update - event.created).days < 1:
                        event_line += "class='event-new' "
                    elif (datetime.datetime.now(datetime.timezone.utc) - event.last_update).days <= 5:
                        event_line += "style='backgrond-color: yellow; color: red;' "
                    if event.note:
                    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
                        "<a href=""> "
                        + str(event.course)
                        + "<br />"
                        + "<br />"
                        + str(event.docent)
                        + "<br />"
                        + str(event.room) + " (" + str(event.subject) + ")</a></td>")
                        + "<br />"
                        + str(event.room) + " (" + str(event.subject) + ")</a></td>")
                    quarter_line += event_line
                else:
                    if quarter_bucket in skip_row:
                        skip_row[quarter_bucket] -= 1
                        if skip_row[quarter_bucket] == 0:
                            del skip_row[quarter_bucket]
                            quarter_line += "<td></td>"
                    else:
                        quarter_line += "<td></td>"
            current_day += datetime.timedelta(days=1)
        quarter_line += "</tr>"
        table_code.append(quarter_line)
    return table_code


administration/templates/administration/roster.djhtml ¶

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

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

    <h2>{% trans "Main hour roster" %}</h2>
    <style>
        table tr td {
        border: medium solid red;
        }
        table td {
            border-width: 0px 0px 1px 0px;
            border-bottom-style: solid;
            border-style: solid;
            border-color: red;
        }
    </style>
    <table>
    <table>
        <th>
            {#<td></td> {# Empty row for hours #} {# Apparantly this isn't necessary with <th /> #}
            {% for day in days %}
                <td>{{ day|date:"l (d/m)" }}</td>
            {% endfor %}
        </th>
        {% for element in time_blocks %}
            {{ element|safe }}
            <!--<tr>
                {% if hour == "hour" %}
                    <td>{{ time }}</td>
                {% else %}
                    <td></td>
                {% endif %}
                {% cycle hour %}
                <td>{{ time }}</td>
                <td>{{ event }}</td>
            </tr>-->
        {% endfor %}
    </table>
{% endblock main %}


administration/views.py ¶

0 additions and 15 deletions.

View changes Hide changes

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

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

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

    # TODO Handle given begin and end
    context = dict()
    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).order_by("begin_time")
    #university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
    #study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
    #events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
    table_code = create_roster_rows(course_events)

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

    time_blocks = list()
    for i in range(len(times)):
        time_blocks.append([times[i],table_code[i]])

    #context['time_blocks'] = time_blocks
    context['time_blocks'] = table_code
    #print(time_blocks)
    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)


static/css/base.css ¶

1 addition and 1 deletion.

View changes Hide changes

    font-family: Verdana, Futura, Arial, sans-serif;
    background-color: #dedede;
}

a.btn {
    border-style: solid;
    text-transform: uppercase;
    border-size: 3em;
    border-color: blue;
    padding: 0.5em;
    text-decoration: none;
    color: blue;
    font-weight: bold;
}
a.btn:hover {
    background-color: blue;
    color: white;
}

.event-update {
    background-color: yellow;
    color: red;
    border: medium dotted red;
}
.event-new {
    background-color: white;
    color: black;
    border: medium dashed black;
}
.event-note {
    color: purple;
    border: medium solid purple;
}
}


1	1	building of the roster. """
2	2	from django.shortcuts import render
3	3	from collections import OrderedDict
4	4	import datetime
5	5	from django.urls import reverse # Why?
6	6	from django.utils.translation import gettext as _
7	7	from .models import *
8	8	import administration
9	9
10	10	def same_day(datetime_a, datetime_b):
11	11	"""True if both a and b are on the same day, false otherwise."""
12	12	return (
13	13	datetime_a.day == datetime_b.day and
14	14	datetime_a.month == datetime_b.month and
15	15	datetime_a.year == datetime_b.year)
16	16
17	17
18	18	def make_quarter_buckets(events):
19	19	"""Returns a dict with all days that the given events take place.
20	20	Every quarter between the first and last event will get a bucket in the dict,
21	21	with the keys in format "dd-mm-yyyy". Also quarters without events will be
22	22	included, but will simply have empty buckets."""
23	23	quarters = OrderedDict() # This is the first time I ever use an OrderedDict and I intend it to be my last one as well.
24	24	current_quarter = datetime.datetime.now().replace(hour=8, minute=0)
25	25	while current_quarter.hour != 20 or current_quarter.minute != 00:
26	26	quarters[current_quarter.strftime("%H:%M")] = list()
27	27	current_quarter += datetime.timedelta(minutes=15)
28	28	for event in events:
29	29	quarters[event.begin_time.strftime("%H:%M")].append(event)
30	30
31	31	return quarters # Yay! ^.^
32	32
33	33
34	34	def create_roster_rows(events):
35	35	"""Creates the rows for use in the roster table.
36	36	None of the times in the given events may overlap, and all must start and
37	37	end at a quarter of the hour (so :00, :15, :30, or :45). If you think you're above this,
38	38	I'll raise you a ValueError, kind sir.
39	39	Events must be of administration.models.Event type."""
40	40	for event in events:
41	41	for other_event in events:
42	42	if other_event is not event and (
43	43	(event.begin_time >= other_event.begin_time and event.begin_time < other_event.end_time)
44	44	or (event.end_time > other_event.begin_time and event.end_time <= other_event.end_time)
45	45	):
46	46	raise ValueError("One of the events overlaps with another event.")
47	47	if event.begin_time.minute not in [0, 15, 30, 45] or event.end_time.minute not in [0, 15, 30, 45]:
48	48	raise ValueError("One of the events did not begin or end on a quarter.")
49	49
50	50	# XXX: I assume here the given queryset is sorted:
51	51	first_day = events[0].begin_time
52	52	last_day = events.last().begin_time
53	53	# All events validated
54	54	quarter_buckets = make_quarter_buckets(events)
55	55	skip_row = dict()
56	56	table_code = list()
57	57
58	58	for quarter_bucket in quarter_buckets.keys():
59	59	# Preparing time column
60	60	quarter_line = "<tr><td style='font-size: xx-small;'>"
61	61	if quarter_bucket[3:] == "00":
62	62	quarter_line += quarter_bucket
63	63	quarter_line += "</td>"
64	64
65	65	current_day = first_day
66	66	while not same_day(current_day, last_day+datetime.timedelta(days=1)):
67	67	for event in quarter_buckets[quarter_bucket]:
68	68	if same_day(current_day, event.begin_time):
69	69	quarters = (event.end_time - event.begin_time).seconds // 60 // 15
70	70	skip_row[quarter_bucket] = quarters
71	71	event_line = "<td "
72	72	if isinstance(event, CourseEvent) and (datetime.datetime.now(datetime.timezone.utc) - event.last_update).days > 5:
73	73	event_line += "style='backgrond-color: #"+event.course.color+"; color: white;' "
74	-	elif (datetime.datetime.now(datetime.timezone.utc) - event.last_update).days <= 5:
+	74	elif (datetime.datetime.now(datetime.timezone.utc) - event.created).days <= 5 and (event.last_update - event.created).days < 1:
+	75	event_line += "class='event-new' "
+	76	elif (datetime.datetime.now(datetime.timezone.utc) - event.last_update).days <= 5:
75	77	event_line += "style='backgrond-color: yellow; color: red;' "
76	-	if event.note:
+	78	if event.note:
77	79	event_line +="title='" +event.note+ "' "
78	-
+	80
79	81	# FIXME: From here, I just assume the events are all CourseEvents, because
80	82	# that is the most important one to implement for the prototype.
81	83	if quarters > 1:
82	84	event_line += "rowspan='"+str(quarters)+"' "
83	85
84	86	event_line +=">"
85	87	event_line += str(
86	88	#"<a href=" + reverse("courses-course-index", args="")+"> " # FIXME so that this links to the course's index page
87	89	"<a href=""> "
88	90	+ str(event.course)
89	-	+ "<br />"
+	91	+ "<br />"
90	92	+ str(event.docent)
91	93	+ "<br />"
92	94	+ str(event.room) + " (" + str(event.subject) + ")</a></td>")
+	95	+ "<br />"
+	96	+ str(event.room) + " (" + str(event.subject) + ")</a></td>")
93	97	quarter_line += event_line
94	98	else:
95	99	if quarter_bucket in skip_row:
96	100	skip_row[quarter_bucket] -= 1
97	101	if skip_row[quarter_bucket] == 0:
98	102	del skip_row[quarter_bucket]
99	103	quarter_line += "<td></td>"
100	104	else:
101	105	quarter_line += "<td></td>"
102	106	current_day += datetime.timedelta(days=1)
103	107	quarter_line += "</tr>"
104	108	table_code.append(quarter_line)
105	109	return table_code
106	110

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	<h2>{% trans "Explanation" %}</h2>
13	13	<p>
14	14	{% trans "Personal roster from" %} {{ begin\|date }} {% trans "to" %} {{ end\|date }}
15	15	</p>
16	16	<p>
17	17	{% blocktrans %}
18	18	Some fields may have additional information that might be of interest
19	19	to you. This information is shown in different ways with colour codes.
20	20	{% endblocktrans %}
21	21	</p>
22	22
23	23	<dl>
24	24	<dt><span class="event-update">
25	25	{% trans "Recent event update" %}
26	26	</span></dt>
27	27	<dd>
28	28	{% blocktrans %}
29	29	This event had one or more of its properties changed
30	30	in the last five days. This can be the room, the hours, the subject, ...
31	31	You're encouraged to take note of that.
32	32	{% endblocktrans %}
33	33	</dd>
34	34	<dt><span class="event-new">
35	35	{% trans "New event" %}
36	36	</span></dt>
37	37	<dd>
38	38	{% blocktrans %}
39	39	This is a new event, added in the last five days.
40	40	{% endblocktrans %}
41	41	</dd>
42	42	<dt><span class="event-note">
43	43	{% trans "Notification available" %}
44	44	</span></dt>
45	45	<dd>
46	46	{% blocktrans %}
47	47	This event has a note attached to it by the docent. Hover over
48	48	the event to display the note.
49	49	{% endblocktrans %}
50	50	</dd>
51	51	</dl>
52	52
53	53	<h2>{% trans "Main hour roster" %}</h2>
54	54	<style>
55	-	table tr td {
56	-	border: medium solid red;
57	-	}
+	55	table td {
+	56	border-width: 0px 0px 1px 0px;
+	57	border-bottom-style: solid;
+	58	border-style: solid;
+	59	border-color: red;
+	60	}
58	61	</style>
59	-	<table>
+	62	<table>
60	63	<th>
61	64	{#<td></td> {# Empty row for hours #} {# Apparantly this isn't necessary with <th /> #}
62	65	{% for day in days %}
63	66	<td>{{ day\|date:"l (d/m)" }}</td>
64	67	{% endfor %}
65	68	</th>
66	69	{% for element in time_blocks %}
67	70	{{ element\|safe }}
68	71	<!--<tr>
69	72	{% if hour == "hour" %}
70	73	<td>{{ time }}</td>
71	74	{% else %}
72	75	<td></td>
73	76	{% endif %}
74	77	{% cycle hour %}
75	78	<td>{{ time }}</td>
76	79	<td>{{ event }}</td>
77	80	</tr>-->
78	81	{% endfor %}
79	82	</table>
80	83	{% endblock main %}
81	84

1	1	from collections import OrderedDict
2	2	from django.http import HttpResponseRedirect
3	3	import datetime
4	4	from django.urls import reverse # Why?
5	5	from django.utils.translation import gettext as _
6	6	from .models import *
7	7	from .forms import UserDataForm
8	8	from .roster import create_roster_rows
9	9	import administration
10	10	from django.contrib.auth.decorators import login_required
11	11	from django.contrib.auth import authenticate
12	12
13	13	@login_required
14	14	def roster(request, begin=None, end=None):
15	15	"""Collects and renders the data that has to be displayed in the roster.
16	16
17	17	The begin and end date can be specified. Only roster points in that range
18	18	will be included in the response. If no begin and end are specified, it will
19	19	take the current week as begin and end point. If it's
20	20	weekend, it will take next week."""
21	21
22	22	# TODO Handle given begin and end
23	23	context = dict()
24	24	template = "administration/roster.djhtml"
25	25
26	26	if begin is None or end is None:
27	27	today = datetime.date.today()
28	28	if today.isoweekday() in {6,7}: # Weekend
29	29	begin = today + datetime.timedelta(days=8-today.isoweekday())
30	30	end = today + datetime.timedelta(days=13-today.isoweekday())
31	31	else: # Same week
32	32	begin = today - datetime.timedelta(days=today.weekday())
33	33	end = today + datetime.timedelta(days=5-today.isoweekday())
34	34	context['begin'] = begin
35	35	context['end'] = end
36	36
37	37	days = [begin]
38	38	while (end-days[-1]).days != 0:
39	39	# Human translation: Keep adding days until the last day in the array of
40	40	# days is the same day as the last day the user wants to see the roster for.
41	41	days.append(days[-1] + datetime.timedelta(days=1))
42	42	context['days'] = days
43	43
44	44	# Collecting events
45	45	course_events = CourseEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end).order_by("begin_time")
46	46	#university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
47	47	#study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
48	48	#events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)
49	49	table_code = create_roster_rows(course_events)
50	50
51	51	# Producing time blocks for display in the table
52	-	times = []
53	-	for i in range(8, 20):
54	-	time = str(i)
55	-	for j in range(0, 60, 15):
56	-	if j == 0:
57	-	times.append(time + ":00")
58	-	else:
59	-	times.append(time + ":" + str(j))
60	-
61	-	time_blocks = list()
62	-	for i in range(len(times)):
63	-	time_blocks.append([times[i],table_code[i]])
64	-
65	-	#context['time_blocks'] = time_blocks
66	-	context['time_blocks'] = table_code
67	52	#print(time_blocks)
68	53	return render(request, template, context)
69	54	# TODO Finish!
70	55
71	56	def index(request):
72	57	template = "administration/index.djhtml"
73	58	context = {}
74	59	return render(request, template, context)
75	60
76	61	pass
77	62
78	63	def pre_registration(request):
79	64	user_data_form = UserDataForm()
80	65	template = "administration/pre_registration.djhtml"
81	66	context = dict()
82	67
83	68	if request.method == 'POST':
84	69	user_data_form = UserDataForm(request.POST)
85	70	context['user_data_form'] = user_data_form
86	71	if user_data_form.is_valid():
87	72	user_data_form.save()
88	73	context['messsage'] = _("Your registration has been completed. You will receive an e-mail shortly.")
89	74	else:
90	75	context['messsage'] = _("The data you supplied had errors. Please review your submission.")
91	76	else:
92	77	context['user_data_form'] = UserDataForm(instance = user_data)
93	78
94	79	return render(request, template, context)
95	80	pass
96	81
97	82	@login_required
98	83	def settings(request):
99	84	user_data = UserData.objects.get(user=request.user)
100	85	user_data_form = UserDataForm(instance = user_data)
101	86	template = "administration/settings.djhtml"
102	87	context = dict()
103	88
104	89	if request.method == 'POST':
105	90	user_data_form = UserDataForm(request.POST, instance = user_data)
106	91	context['user_data_form'] = user_data_form
107	92	if user_data_form.is_valid():
108	93	user_data_form.save()
109	94	context['messsage'] = _("Your settings were successfully updated.")
110	95	else:
111	96	context['messsage'] = _("The data you supplied had errors. Please review your submission.")
112	97	else:
113	98	context['user_data_form'] = UserDataForm(instance = user_data)
114	99
115	100	return render(request, template, context)
116	101
117	102	@login_required
118	103	def bulletin_board(request):
119	104	context = dict()
120	105	context['exam_commission_decisions'] = ExamCommissionDecision.objects.filter(user=request.user)
121	106	context['education_department_messages'] = ExamCommissionDecision.objects.filter(user=request.user)
122	107	template = "administration/bulletin_board.djhtml"
123	108	return render(request, template, context)
124	109
125	110	def jobs(request):
126	111	context = dict()
127	112	template = "administration/jobs.djhtml"
128	113	#@context['decisions'] = ExamCommissionDecision.objects.filter(user=request.user)
129	114	return render(request, template, context)
130	115
131	116
132	117	def curriculum(request):
133	118	return render(request, template, context)
134	119
135	120	def result(request):
136	121	return render(request, template, context)
137	122
138	123	@login_required
139	124	def results(request):
140	125	results = CourseResult.objects.filter(student=request.user)
141	126	template = "administration/results.djhtml"
142	127	# TODO
143	128	return render(request, template, context)
144	129
145	130	def forms(request):
146	131	return render(request, template, context)
147	132
148	133	def rooms(request):
149	134	template = "administration/rooms.djhtml"
150	135	return render(request, template, context)
151	136
152	137	def room_reservate(request):
153	138	return render(request, template, context)
154	139
155	140	def login(request):
156	141	context = dict()
157	142	if request.method == "POST":
158	143	name = request.POST['name']
159	144	passphrase = request.POST['pass']
160	145	user = authenticate(username=name, password=passphrase)
161	146	if user is not None: # The user was successfully authenticated
162	147	print("YA")
163	148	return HttpResponseRedirect(request.POST['next'])
164	149	else: # User credentials were wrong
165	150	context['next'] = request.POST['next']
166	151	context['message'] = _("The given credentials were not correct.")
167	152	else:
168	153	context['next'] = request.GET.get('next', None)
169	154	if context['next'] is None:
170	155	context['next'] = reverse('administration-index')
171	156
172	157	template = 'administration/login.djhtml'
173	158
174	159	return render(request, template, context)
175	160

1	1	font-family: Verdana, Futura, Arial, sans-serif;
2	2	background-color: #dedede;
3	3	}
4	4
5	5	a.btn {
6	6	border-style: solid;
7	7	text-transform: uppercase;
8	8	border-size: 3em;
9	9	border-color: blue;
10	10	padding: 0.5em;
11	11	text-decoration: none;
12	12	color: blue;
13	13	font-weight: bold;
14	14	}
15	15	a.btn:hover {
16	16	background-color: blue;
17	17	color: white;
18	18	}
19	19
20	20	.event-update {
21	21	background-color: yellow;
22	22	color: red;
23	23	border: medium dotted red;
24	24	}
25	25	.event-new {
26	26	background-color: white;
27	27	color: black;
28	28	border: medium dashed black;
29	29	}
30	30	.event-note {
31	31	color: purple;
32	32	border: medium solid purple;
33	-	}
+	33	}
34	34