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."),

        )

    color = models.CharField(

        max_length=6,

        blank=False,

        default=constants.COLORS['uhasselt-default'],

        help_text=_("The color for this course. Must be an hexadecimal code."),

        validators=['validate_hex_color'],

        )

    slug_name = models.SlugField(

        blank=False,

        allow_unicode=True,

        unique=True,

        help_text=_("A so-called 'slug name' for this course."),

        )

    # TODO: Add a potential thingy magicky to auto fill the slug name on the course name

    contact_person = models.ForeignKey(

        "administration.User",

        on_delete=models.PROTECT,  # A course must have a contact person

        limit_choices_to={'is_staff': True},

        null=False,

        help_text=_("The person to contact regarding this course."),

        related_name="contact_person",

        )

    coordinator = models.ForeignKey(

        "administration.User",

        on_delete=models.PROTECT,  # A course must have a coordinator

        limit_choices_to={'is_staff': True},

        null=False,

        help_text=_("The person whom's the coordinator of this course."),

        related_name="coordinator",

        )

    educating_team = models.ManyToManyField(

        "administration.User",

        # 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 CourseProgramme(models.Model):

    """ It's possible that a course is taught in multiple degree programmes; For

    example: Calculus can easily be taught to physics and mathematics students

    alike. In this table, these relations are set up, and the related properties

    are defined as well. """

    study = models.ForeignKey(

        "Study",

        on_delete=models.CASCADE,

        null=False,

        help_text=_("The study in which the course is taught."),

        )

    course = models.ForeignKey(

        "Course",

        on_delete=models.CASCADE,

        null=False,

        help_text=_("The course that this programme is for."),

        )

    study_programme = models.ForeignKey(

        "StudyProgramme",

        on_delete=models.CASCADE,

        null=False,

        help_text=_("The study programme that this course belongs to."),

        )

    programme_type = models.CharField(

        max_length=1,

        blank=False,

        choices = (

            ('C', _("Compulsory")),

            ('O', _("Optional")),

            ),

        help_text=_("Type of this course for this study."),

        )

    study_hours = models.PositiveSmallIntegerField(

        blank=False,

        help_text=_("The required amount of hours to study this course."),

        )

    ECTS = models.PositiveSmallIntegerField(

        blank=False,

        help_text=_("The amount of ECTS points attached to this course."),

        )

    semester = models.PositiveSmallIntegerField(

        blank=False,

        choices = (

            (1, _("First semester")),

            (2, _("Second semester")),

            (3, _("Full year course")),

            (4, _("Taught in first quarter")),

            (5, _("Taught in second quarter")),

            (6, _("Taught in third quarter")),

            (7, _("Taught in fourth quarter")),

            ),

        help_text=_("The period in which this course is being taught in this study."),

        )

    year = models.PositiveSmallIntegerField(

        blank=False,

        help_text=_("The year in which this course is taught for this study."),

        )

    second_chance = models.BooleanField(

        default=True,

        help_text=_("Defines if a second chance exam is planned for this course."),

        )

    tolerable = models.BooleanField(

        default=True,

        help_text=_("Defines if a failed result can be tolerated."),

        )

    scoring = models.CharField(

        max_length=2,

        choices = (

            ('N', _("Numerical")),

            ('FP', _("Fail/Pass")),

            ),

        default='N',

        blank=False,

        help_text=_("How the obtained score for this course is given."),

        )

    def __str__(self):

        return str(self.study) + " - " + str(self.course)

class Study(models.Model):

    """ Defines a certain study that can be followed at the university.

    This also includes abridged study programmes, like transition programmes.

    Other information, such as descriptions, are kept in the template file

    of this study, which can be manually edited. Joeni searches for a file

    with the exact name as the study + ".html". So if the study is called

    "Bachelor of Informatics", it will search for "Bachelor of Informatics.html".

    """

    # Degree types

    BSc = _("Bachelor of Science")

    MSc = _("Master of Science")

    LLB = _("Bachelor of Laws")

    LLM = _("Master of Laws")

    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 CourseProgramme.objects.filter(study=self):

            #total_ECTS += course.ECTS

        #return total_ECTS

    # XXX: Commented because this is actually something for the StudyProgramme

    def years(self):

        """ Returns the amount of years this study takes.

        This value is inferred based on the study programme information

        records that lists this study as their foreign key. """

        highest_year = 0

        for course in CourseProgramme.objects.filter(study=self):

            highest_year = max(highest_year, course.year)

        return highest_year

    def students(self):

        """ Cross references the information stored in the database, and

        returns all the students that are following this study in this

        academic year. """

        return 0  # TODO

    def __str__(self):

        return self.name

class StudyProgramme(models.Model):

    """ Represents a programme within a certain study.

    A good example for this is the different specializations, minors, majors, ...

    one can follow within the same study. Nevertheless, they're all made of

    a certain set of courses. This table collects all these, and allows one to name

    them, so they're distinct from one another. """

    name = models.CharField(

            max_length=64,

            blank=False,

            help_text=_("The name of this programme."),

            )

    def courses(self):

        """ All courses that are part of this study programme. """

        programmes = CourseProgramme.objects.filter(study_programme=self)

        courses = {}

        for program in programmes:

            courses.add(program.course)

        return courses

    def study_points(self, year=None):

        """ Returns the amount of study points this programme contains.

        Accepts year as an optional argument. If not given, the study points

        of all years are returned. """

        programmes = CourseProgramme.objects.filter(study_programme=self)

        ECTS = 0

        for program in programmes:

            if year is None or program.year == year:

                # XXX: This only works if the used implementation does lazy

                # evaluation, otherwise this is a type error!

                ECTS += program.ECTS

        return ECTS

    def __str__(self):

        return self.name

# Tables about things related to the courses:

class Assignment(models.Model):

    """ For courses, it's possible to set up tasks. These tasks are recorded

    here. """

    # TODO: Require that only the course team can create assignments for a team.

    course = models.ForeignKey(

        "Course",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        db_index=True,

        help_text=_("The course for which this task is assigned."),

        )

    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)

{% load i18n %}

{% block title %}

    {% trans "Joeni | Courses" %}

{% block main %}

    
{% trans "Your courses" %}

        {% for course in courses %}

                    {{ course.name|lower|capfirst }}

                    {% if course.number < 10 %}(000{{ course.number }})

                    {% elif course.number < 100 %}(00{{ course.number }})

                    {% elif course.number < 1000 %}(0{{ course.number }})

                    {% else %}({{ course.number }})

        {% endfor %}

{% endblock main %}

import datetime

from django.core.urlresolvers import reverse # Why?

from django.utils.translation import ugettext as _

from .models import *

import joeni.administration

def current_academic_year():

    """ Returns the current academic year. The year is determined as follows:

    - If today is before September 15 of the current year, the returned value

      is the current year - 1.

    - If today is after September 15 of the current year, but before January 1

      of the next year, it returns the current year as is.

    """

    today = datetime.datetime.now()

    switch = datetime.datetime.date(datetime.datetime.year, 9, 15)

    if today < switch:

        return today.year - 1

    else:

        return today.year

@login_required