joeni

__pycache__/

# Compiled translation files

*.mo

# Other types of compiled Python files

*.py[cod]

*$py.class

# Django specific files

*.log

If there is a discrepancy about a certain constant, this file is the definite

point of reference.

"""

from django.utils.translation import ugettext_lazy as _

COLORS = {

    _("UHasselt default"): "E73B2B",

    _("Faculty of Sciences"): "0076BE",

    _("Faculty of Transportation Sciences"): "C0D633",

    _("Faculty of Architecture and Arts"): "F4802D",

    _("Faculty of Business Economics"): "00ACEE",

    _("Faculty of Medicine and Life Sciences"): "9C3591",

    _("Faculty of Engineering Technology"): "5BC4BA",

    _("Faculty of Law"): "E41F3A",

    }

from django.core.exceptions import ValidationError  # For validating IBAN input

from django.utils.translation import ugettext_lazy as _

from django.db import models

import datetime

import os

class room(models.Model):

    """ Represents a room in the university.

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

    """

    name = models.TextField()

    seats = models.IntegerField()

    wheelchair_accessible = models.BooleanField(default=True,blank=False)

    exams_equipped = models.BooleanField(blank=False)

class User(models.Model):

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

    number = models.PositiveIntegerField(

        primary_key=True,

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

        )

    created = models.DateField(auto_now_add=True)

    passphrase = models.CharField(

        max_length=512,

        blank=False,

        help_text=_("The passphrase used for this account. This field must only contain hashed information."),

        )

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

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

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

        )

    national_registry_number = models.BigIntegerField(

        unique=True,

        editable=False,

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

        )

    civil_status = models.CharField(

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

        )

    # Home address

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

    home_number = models.PositiveSmallIntegerField(blank=False)

    home_bus = models.PositiveSmallIntegerField()

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

    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)

    titularis_number = models.PositiveSmallIntegerField()

    titularis_bus = models.PositiveSmallIntegerField()

    titularis_postal_code = models.PositiveSmallIntegerField()

    titularis_country = models.CharField(max_length=64)

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

        )

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

        )

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

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

def post_title_directory(instance, filename):

    """ Files will be uploaded to MEDIA_ROOT/blog/<year of publishing>/<blog

    title>

    The blog title is determined by the text before the first period (".") in

    the filename. So if the file has the name "Trains are bæ.en.md", the file

    will be stored in "blog/<this year>/Trains are bæ". Name your files

    properly!

    It should also be noted that all files are stored in the same folder if they

    belong to the same blogpost, regardless of language. The titles that are

    displayed to the user however, should be the titles of the files themselves,

    which should be in the native language. So if a blog post is titled

    "Universities of Belgium", its Dutch counterpart should be titled

    "Universiteiten van België", so the correct title can be derived from the

    filename.

    Recommended way to name the uploaded file: "<name of blog post in language

    it's written>.md". This removes the maximum amount of redundancy (e.g. the

    language of the file can be derived from the title, no ".fr.md" or something

    like that necessary), and can directly be used for the end user (the title

    is what should be displayed).

    """

    english_file_name = os.path.basename(instance.english_file.name) # TODO: Test if this returns the file name!

    english_title = english_file_name.rpartition(".")[0] 

    year = datetime.date.today().year

    return "blog/{0}/{1}/{2}".format(year, english_title, filename)

class Post(models.Model):

    """ Represents a blog post. The title of the blog post is determnined by the name

    of the files.

    A blog post can be in 5 different languages: German, Spanish, English, French,

    and Dutch. For all these languages, a seperate field exists. Thus, a

    translated blog post has a seperate file for each translation, and is

    seperated from Django's internationalization/localization system.

    Only the English field is mandatory. The others may contain a value if a

    translated version exists, which will be displayed accordingly.

    """

    published = models.DateTimeField(auto_now_add=True)

    english_file = models.FileField(upload_to=post_title_directory, unique=True, blank=False)

    dutch_file = models.FileField(upload_to=post_title_directory, blank=True)

    french_file = models.FileField(upload_to=post_title_directory, blank=True)

    german_file = models.FileField(upload_to=post_title_directory, blank=True)

    spanish_file = models.FileField(upload_to=post_title_directory, blank=True)

    # Only the English file can be unique, because apparantly, there can't be

    # two blank fields in a unique column. Okay then.

    def __str__(self):

        return os.path.basename(self.english_file.name).rpartition(".")[0]

#class Comment(models.model):

    """ Represents a comment on a blog post.

    Comments are not linked to an account or anything, I'm trusting the

    commenter that he is honest with his credentials. That being said:

    XXX: Remember to put up a notification that comments are not checked for

    identity, and, unless verified by a trustworthy source, cannot be seen as

    being an actual statement from the commenter.

    Comments are linked to a blogpost, and are not filtered by language. (So a

    comment made by someone reading the article in Dutch, that's written in

    Dutch, will show up (unedited) for somebody whom's reading the Spanish

    version.

    XXX: Remember to notify (tiny footnote or something) that comments showing

    up in a foreign language is by design, and not a bug.

    """

#    date = models.DateTimeField(auto_now_add=True)

    #name = models.TextField()

    #mail = models.EmailField()

    #post = models.ForeignKey(Post) # TODO: Finish this class and the shit...

<footer>

</footer>