joeni | Gitar

Minor model changes and new templates

I've made some slight changes to the models, more specifically; a name change and a slight change in how the foreign keys work. Additionally, the first view has been made, and a couple of new templates have been added to the tracker. These are not complete yet, but they're already pretty functional for what they're supposed to do. The stylesheets are still in their infancy, because they're not very important. Currently, it's more important to make the templates convey a meaning on their own.

Author: Maarten 'Vngngdn' Vangeneugden
Date: Nov. 22, 2017, 9:45 p.m.
Hash: 4c969f3a0dea77b4409e9cf91891ddf1c75181db
Parent: c35535e1d10591e4d7f7ddd9102e58355df3ae81
Modified files: administration/models.py; courses/models.py; courses/templates/courses/index.djhtml; courses/views.py; joeni/templates/joeni/base.djhtml; joeni/templates/joeni/footer.djhtml

administration/models.py ¶

16 additions and 4 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)
    first_name = models.CharField(max_length=64, blank=False)
    last_name = models.CharField(max_length=64, blank=False)
    title = models.CharField(
        max_length=64,
        blank=True,
        help_text=_("The academic title of this user, if applicable."),
        )
    DOB = models.DateField(
        blank=False,
        #editable=False,
        help_text=_("The date of birth of this user."),
        )
    POB = models.CharField(
        max_length=64,
        blank=False,
        #editable=False,
        help_text=_("The place of birth of this user."),
        )
    nationality = models.CharField(
        max_length=64,
        blank=False,
        help_text=_("The current nationality of this user."),
        )
    # XXX: What if this starts with zeros?
    national_registry_number = models.BigIntegerField(
        unique=True,
        #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.PositiveSmallIntegerField(null=True)
    home_postal_code = models.PositiveSmallIntegerField(blank=False)
    home_country = models.CharField(max_length=64, blank=False)
    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."),
        )
    # Study address
    study_street = models.CharField(max_length=64, blank=False)
    study_number = models.PositiveSmallIntegerField(blank=False)
    study_bus = models.PositiveSmallIntegerField(null=True)
    study_postal_code = models.PositiveSmallIntegerField(blank=False)
    study_country = models.CharField(max_length=64, blank=False)
    study_telephone = models.CharField(
        max_length=64,
        help_text=_("The telephone number for the study address. Prefix 0 can be presented with the national call code in the system."),
        )
    study_cellphone = models.CharField(
        max_length=64,
        help_text=_("The cellphone number of the person. Prefix 0 can be presented with then national call code in the system."),
        )
    # Titularis address
    # XXX: These fields are only required if this differs from the user itself.
    titularis_street = models.CharField(max_length=64, null=True)
    titularis_number = models.PositiveSmallIntegerField(null=True)
    titularis_bus = models.PositiveSmallIntegerField(null=True)
    titularis_postal_code = models.PositiveSmallIntegerField(null=True)
    titularis_country = models.CharField(max_length=64, null=True)
    titularis_telephone = models.CharField(
        max_length=64,
        help_text=_("The telephone number of the titularis. Prefix 0 can be presented with the national call code in the system."),
        null=True,
        )

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

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

class Curriculum(models.Model):
    """ The curriculum of a particular student.
    Every academic year, a student has to hand in a curriculum (s)he wishes to
    follow. This is then reviewed by a committee. A curriculum exists of all the
    courses one wants to partake in in a certain year. """
    student = models.ForeignKey(
        "User",
        on_delete=models.CASCADE,
        limit_choices_to={'is_student': True},
        null=False,
        #editable=False,
        unique_for_year="year",  # Only 1 curriculum per year
        )
    year = models.DateField(
        auto_now_add=True,
        db_index=True,
        help_text=_("The academic year for which this curriculum is."),
        )
                    "If this field is equal to 2008, then that means "
                    "this curriculum is for the academic year "
                    "2008-2009."),
        )
    last_modified = models.DateTimeField(
        auto_now=True,
        help_text=_("The last timestamp that this was updated."),
        )
    courses = models.ManyToManyField(
        "courses.Course",
        null=False,
        "courses.CourseProgramme",
        null=False,
        help_text=_("All the courses 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 curriculum_type(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")
    # 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.ProgrammeInformation",
        on_delete=models.PROTECT,
        null=False,
        )
    released = models.DateField(
        auto_now=True,
        help_text=_("The date that this result was last updated."),
        )
    first_score = models.PositiveSmallIntegerField(
        null=True,  # It's possible a score does not exist.
        validators=[MaxValueValidator(
            20,
            _("The score mustn't be higher than 20."),
            )],
        )
    second_score = models.PositiveSmallIntegerField(
        null=True,
        validators=[MaxValueValidator(
            20,
            _("The score mustn't be higher than 20."),
            )],
        )
    result = models.CharField(
        max_length=10,
        choices = (
            ("CRED", CRED),
            ("FAIL", FAIL),
            ("TLRD", TLRD),
            ("ITLD", ITLD),
            ),
        blank=False,
        help_text=_("The final result this record constitutes."),
        )

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

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

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


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


    name = models.CharField(
        max_length=20,
        primary_key=True,
        blank=False,
        help_text=_("The name of this room. If more appropriate, this can be the colloquial name."),
        )
    seats = models.PositiveSmallIntegerField(
        help_text=_("The amount of available seats in this room. This can be handy for exams for example."),
        )
    wheelchair_accessible = models.BooleanField(default=True)
    exams_equipped = models.BooleanField(
        default=True,
        help_text=_("Indicates if exams can reasonably be held in this room."),
        )
    computers_available = models.PositiveSmallIntegerField(
        default=False,
        help_text=_("Indicates how many computers are available in this room."),
        )
    projector_available = models.BooleanField(
        default=False,
        help_text=_("Indicates if a projector is available at this room."),
        )
    blackboards_available = models.PositiveSmallIntegerField(
        help_text=_("The amount of blackboards available in this room."),
        )
    whiteboards_available = models.PositiveSmallIntegerField(
        help_text=_("The amount of whiteboards available in this room."),
        )
    category = models.CharField(
        max_length=16,
        blank=False,
        choices = (
            ("LABORATORY", LABORATORY),
            ("CLASS_ROOM", CLASS_ROOM),
            ("AUDITORIUM", AUDITORIUM),
            ("PC_ROOM", PC_ROOM),
            ("PUBLIC_ROOM", PUBLIC_ROOM),
            ("OFFICE", OFFICE),
            ("PRIVATE_ROOM", PRIVATE_ROOM),
            ("WORKSHOP", WORKSHOP),
            ("OTHER", OTHER),
            ),
        help_text=_("The category that best suits the character of this room."),
        )
    reservable = models.BooleanField(
        default=True,
        help_text=_("Indicates if this room can be reserved for something."),
        )
    note = models.TextField(
        blank=True,
        help_text=_("If some additional info is required for this room, like a "
                    "characteristic property (e.g. 'Usually occupied by 2BACH "
                    "informatics'), state it here."),
        )
    # TODO: Add a campus/building field or not?

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

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

    def __str__(self):
        return self.name

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

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

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

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


courses/models.py ¶

14 additions and 6 deletions.

View changes Hide changes

from django.utils.translation import ugettext_lazy as _

class Course(models.Model):
    """ Represents a course that is taught at the university. """
    number = models.PositiveSmallIntegerField(
        primary_key=True,
        blank=False,
        help_text=_("The number associated with this course. A leading '0' will be added if the number is smaller than 1000."),
        )
    name = models.CharField(
        max_length=64,
        blank=False,
        help_text=_("The name of this course, in the language that it is taught. Translations are for the appropriate template."),
        )
    slug_name = models.SlugField(
        max_length=6,
        blank=False,
        default=constants.COLORS['uhasselt-default'],
        help_text=_("The color for this course. Must be an hexadecimal code."),
        validators=['validate_hex_color'],
        )
    slug_name = models.SlugField(
        blank=False,
        allow_unicode=True,
        unique=True,
        help_text=_("A so-called 'slug name' for this course."),
        )
    contact_person = models.ForeignKey(
    contact_person = models.ForeignKey(
        "administration.User",
        on_delete=models.PROTECT,  # A course must have a contact person
        limit_choices_to={'is_staff': True},
        null=False,
        help_text=_("The person to contact regarding this course."),
        related_name="contact_person",
        )
    coordinator = models.ForeignKey(
        "administration.User",
        on_delete=models.PROTECT,  # A course must have a coordinator
        limit_choices_to={'is_staff': True},
        null=False,
        help_text=_("The person whom's the coordinator of this course."),
        related_name="coordinator",
        )
    educating_team = models.ManyToManyField(
        "administration.User",
        # No on_delete, since M->M cannot be required at database level
        limit_choices_to={'is_staff': True},
        #null=False,  # Useless on a M->M
        help_text=_("The team members of this course."),
        related_name="educating_team",
        )
    language = models.CharField(
        max_length=64,
        choices = (
            ('NL', _("Dutch")),
            ('EN', _("English")),
            ('FR', _("French")),
            ),
        null=False,
        help_text=_("The language in which this course is given."),
        )

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


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

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


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

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

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

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

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

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


    def __str__(self):
        return self.name

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

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

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

    def __str__(self):
        return self.name

# Tables about things related to the courses:

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

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

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

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

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


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

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

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

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


courses/templates/courses/index.djhtml ¶

24 additions and 0 deletions.

View changes Hide changes

+	1	{% load i18n %}
+	2
+	3	{% block title %}
+	4	{% trans "Joeni \| Courses" %}
+	5	{% endblock %}
+	6
+	7	{% block main %}
+	8	{% trans "Your courses" %}
+	9
+	10	{% for course in courses %}
+	11
+	12
+	13	{{ course.name\|lower\|capfirst }}
+	14	{% if course.number < 10 %}(000{{ course.number }})
+	15	{% elif course.number < 100 %}(00{{ course.number }})
+	16	{% elif course.number < 1000 %}(0{{ course.number }})
+	17	{% else %}({{ course.number }})
+	18
+	19
+	20	{% endfor %}
+	21
+	22	{% endblock main %}
+	23
+	24

courses/views.py ¶

47 additions and 0 deletions.

View changes Hide changes

1	1
+	2	from django.core.urlresolvers import reverse # Why?
+	3	from django.utils.translation import ugettext as _
+	4	from .models import *
+	5	import joeni.administration
+	6
+	7	def current_academic_year():
+	8	""" Returns the current academic year. The year is determined as follows:
+	9	- If today is before September 15 of the current year, the returned value
+	10	is the current year - 1.
+	11	- If today is after September 15 of the current year, but before January 1
+	12	of the next year, it returns the current year as is.
+	13	"""
+	14	today = datetime.datetime.now()
+	15	switch = datetime.datetime.date(datetime.datetime.year, 9, 15)
+	16	if today < switch:
+	17	return today.year - 1
+	18	else:
+	19	return today.year
+	20
+	21	@login_required
+	22	def index(request):
+	23	""" Starting page regarding the courses. This serves two specific groups:
+	24	- Students: Displays all courses that this student has in his/her curriculum
+	25	for this academic year. Requires the curriculum to be accepted.
+	26	- Staff: Displays all courses in which the staff member is part of the
+	27	educating team, or is otherwise related to the course.
+	28	Users who are not logged in will be sent to the login page.
+	29	"""
+	30	template = "courses/index.djhtml"
+	31	courses = set()
+	32	if request.user.is_student:
+	33	curricula = administration.models.Curriculum.objects.filter(student=request.user)
+	34	current_curriculum = curricula.filter(year__year=current_academic_year())
+	35	courses = current_curriculum.courses
+	36	elif request.user.is_staff:
+	37	courses += adminstration.models.Course.filter(contact_person=request.user)
+	38	courses += adminstration.models.Course.filter(coordinator=request.user)
+	39	courses += adminstration.models.Course.filter(educating_team__contains=request.user)
+	40	else:
+	41	raise django.exceptions.FieldError("User "+request.user.number+" is neither staff nor student")
+	42
+	43	context = {
+	44	'courses': courses,
+	45	}
+	46
+	47	return render(request, template, context)
+	48

joeni/templates/joeni/base.djhtml ¶

72 additions and 0 deletions.

View changes Hide changes

+	1	{% load i18n %}
+	2	{% get_current_language as LANGUAGE_CODE %}
+	3	{% get_language_info for LANGUAGE_CODE as lang %}
+	4	{% load static %}
+	5	{% get_media_prefix as media %}
+	6
+	7
+	8
+	9
+	10	</pre></td> </tr> <tr class="addition"> <td class="line-number symbol">+</td> <td id="joeni/templates/joeni/base.djhtml-B11" class="line-number"> <a href="#joeni/templates/joeni/base.djhtml-B11" class="accent-on-hover-only"><pre>11</pre> </a></td> <td style="padding-left: 1em;"><pre> {% block title %}</pre></td> </tr> <tr class="addition"> <td class="line-number symbol">+</td> <td id="joeni/templates/joeni/base.djhtml-B12" class="line-number"> <a href="#joeni/templates/joeni/base.djhtml-B12" class="accent-on-hover-only"><pre>12</pre> </a></td> <td style="padding-left: 1em;"><pre> ◀ Joeni /▶ \| ▶▶ UHasselt</pre></td> </tr> <tr class="addition"> <td class="line-number symbol">+</td> <td id="joeni/templates/joeni/base.djhtml-B13" class="line-number"> <a href="#joeni/templates/joeni/base.djhtml-B13" class="accent-on-hover-only"><pre>13</pre> </a></td> <td style="padding-left: 1em;"><pre> {% endblock title %}</pre></td> </tr> <tr class="addition"> <td class="line-number symbol">+</td> <td id="joeni/templates/joeni/base.djhtml-B14" class="line-number"> <a href="#joeni/templates/joeni/base.djhtml-B14" class="accent-on-hover-only"><pre>14</pre> </a></td> <td style="padding-left: 1em;"><pre>
+	15
+	16	{% block stylesheets %}
+	17
+	18
+	23	{% endblock stylesheets %}
+	24
+	25	{% block metaflags %}
+	26	{# This is standard for all web pages and doesn't require changing. #}
+	27	{# UTF-8, always #}
+	28
+	29	{##}
+	30	{# Indicates this page is suited for mobile devices #}
+	31
+	32
+	33	name="description"
+	34	content="{% block description %}
+	35	{% trans "The digital platform of Hasselt University" %}
+	36	{% endblock description %}" />
+	37	{% endblock metaflags %}
+	38
+	39
+	40
+	41
+	42	{% block header %}
+	43	{% include "joeni/navbar.djhtml" %}
+	44	{% endblock header %}
+	45
+	46
+	47
+	48	{% block main %}
+	49	{% endblock main %}
+	50
+	51
+	52
+	53	{% block footer %}
+	54	{% include "joeni/footer.djhtml" %}
+	55	{% endblock footer %}
+	56
+	57
+	58
+	59	{% block JavaScript %}
+	60	{% comment JavaScript %}
+	61	My website does not require JavaScript for basic actions. However, it may be
+	62	used to make certain things look better, or to spice up some actions for the
+	63	user. Should it be necessary, add the appropriate JavaScript code in this
+	64	block.
+	65	The reason this block is at the bottom?
+	66	Remember to always put JavaScript on the bottom to reduce load time.
+	67	Otherwise it just errors like a fucktard, which is really the only thing
+	68	you can always expect from JavaScript.
+	69	{% endcomment %}
+	70	{% endblock JavaScript %}
+	71
+	72

26 additions and 0 deletions.

View changes Hide changes

+	1	{% load static %}
+	2	{% get_media_prefix as media %}
+	3
+	4
+	5	{% blocktrans %}
+	6
+	7	Joeni is the digital platform of Hasselt University, designed with an
+	8	emphasis on the day to day needs of its students and staff.
+	9
+	10	{% endblocktrans %}
+	11
+	12
+	13
+	14	Agora
+	15
+	16
+	17	{% trans "Administration" %}
+	18
+	19
+	20	{% trans "Courses" %}
+	21
+	22
+	23
+	24
+	25
+	26

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

Minor model changes and new templates

administration/models.py ¶

courses/models.py ¶

courses/templates/courses/index.djhtml ¶

{% trans "Your courses" %}

courses/views.py ¶

joeni/templates/joeni/base.djhtml ¶

joeni/templates/joeni/footer.djhtml ¶