joeni

from collections import OrderedDict

from django.http import HttpResponseRedirect

import datetime

from django.urls import reverse # Why?

from django.utils.translation import gettext as _

from .models import *

from .forms import UserDataForm

from .new_roster import create_roster_rows

import administration

from django.contrib.auth.decorators import login_required

from django.contrib.auth import authenticate

@login_required

def roster(request, begin=None, end=None):

    """Collects and renders the data that has to be displayed in the roster.

    The begin and end date can be specified. Only roster points in that range

    will be included in the response. If no begin and end are specified, it will

    take the current week as begin and end point. If it's

    weekend, it will take next week."""

    # TODO Handle given begin and end

    context = dict()

    #context = {'money' : update_balance(None)}

    template = "administration/roster.djhtml"

    if begin is None or end is None:

        today = datetime.date.today()

        if today.isoweekday() in {6,7}:  # Weekend

            begin = today + datetime.timedelta(days=8-today.isoweekday())

            end = today + datetime.timedelta(days=13-today.isoweekday())

        else:  # Same week

            begin = today - datetime.timedelta(days=today.weekday())

            end = today + datetime.timedelta(days=5-today.isoweekday())

    else:  # Changing regexes to date objects

        b = begin.split("-")

        e = end.split("-")

        begin = datetime.datetime(int(b[2]),int(b[1]),int(b[0]))

        end = datetime.datetime(int(e[2]),int(e[1]),int(e[0]))

    context['begin'] = begin

    context['end'] = end

    context['prev_begin'] = (begin - datetime.timedelta(days=7)).strftime("%d-%m-%Y")

    context['prev_end'] = (begin - datetime.timedelta(days=2)).strftime("%d-%m-%Y")

    context['next_begin'] = (end + datetime.timedelta(days=2)).strftime("%d-%m-%Y")

    context['next_end'] = (end + datetime.timedelta(days=7)).strftime("%d-%m-%Y")

    days = [begin]

    while (end-days[-1]).days != 0:

        # Human translation: Keep adding days until the last day in the array of

        # days is the same day as the last day the user wants to see the roster for.

        days.append(days[-1] + datetime.timedelta(days=1))

    context['days'] = days

    # Collecting events

    course_events = CourseEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end).order_by("begin_time")

    #university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    #study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    #events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    conflicts, table_code = create_roster_rows(course_events)

    context['time_blocks'] = table_code

    context['conflicts'] = conflicts

    #print(time_blocks)

    return render(request, template, context)

    # TODO Finish!

def roster_ics(request, user_slug):

    template = "administration/roster.ics"

    context = dict()

    context['events'] = CourseEvent.objects.all()  # FIXME: Filter to personal calendar items!

    return render(request, template, context)

def index(request):

    template = "administration/index.djhtml"

    #context = {'money': update_balance(None)}

    context = dict()

    context['links'] = [

        ("administration-settings",

         _("Personal settings"),

         _("Edit your personal information, billing address, home address, and so on.")),

        ("administration-curriculum",

         _("Curricula"),

         _("View all information related to your curricula, including exam results.<br />"

           "You can also change your current curriculum here, or request a change.")),

        ("administration-forms",

         _("Forms"),

         _("All forms for special services can be found on this page.")),

        ("administration-rooms",

         _("Rooms"),

         _("Room occupancy, free rooms, properties, ... <br />"

           "All this and much more is available on this page.")),

        ("administration-roster",

         _("Personal roster"),

         _("Everything about your roster and events at Hasselt University is available here.")),

        ("administration-bulletin-board",

         _("Bulletin board"),

         _("From time to time, UHasselt publishes announcements regarding changes, events, ..."

           "<br />All publications are neatly organized here for easy reference.")),

        ]

    return render(request, template, context)

    pass

def pre_registration(request):

    user_data_form = UserDataForm()

    template = "administration/pre_registration.djhtml"

    context = dict()

    if request.method == 'POST':

        user_data_form = UserDataForm(request.POST)

        context['user_data_form'] = user_data_form

        if user_data_form.is_valid():

            user_data_form.save()

            context['messsage'] = _("Your registration has been completed. You will receive an e-mail shortly.")

        else:

            context['messsage'] = _("The data you supplied had errors. Please review your submission.")

    else:

        context['user_data_form'] = UserDataForm(instance = user_data_form)

    return render(request, template, context)

    pass

@login_required

def settings(request):

    user_data = UserData.objects.get(user=request.user)

    user_data_form = UserDataForm(instance = user_data)

    template = "administration/settings.djhtml"

    context = dict()

    #context = {'money' : update_balance(None)}

    if request.method == 'POST':

        user_data_form = UserDataForm(request.POST, instance = user_data)

        context['user_data_form'] = user_data_form

        if user_data_form.is_valid():

            user_data_form.save()

            context['messsage'] = _("Your settings were successfully updated.")

        else:

            context['messsage'] = _("The data you supplied had errors. Please review your submission.")

    else:

        context['user_data_form'] = UserDataForm(instance = user_data)

    return render(request, template, context)

@login_required

def bulletin_board(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    context['exam_commission_decisions'] = ExamCommissionDecision.objects.filter(user=request.user)

    context['education_department_messages'] = EducationDepartmentMessages.objects.all()

    for item in context['education_department_messages']:

        print(item.text)

    template = "administration/bulletin_board.djhtml"

    return render(request, template, context)

def jobs(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    template = "administration/jobs.djhtml"

    #@context['decisions'] = ExamCommissionDecision.objects.filter(user=request.user)

    return render(request, template, context)

@login_required

def curriculum(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    template = "administration/curriculum.djhtml"

    context['curricula'] = Curriculum.objects.filter(student=request.user)

    for item in context['curricula']:

        for co in item.course_programmes_results():

            print(co)

    return render(request, template, context)

def result(request):

    return render(request, template, context)

@login_required

def results(request):

    results = CourseResult.objects.filter(student=request.user)

    template = "administration/results.djhtml"

    # TODO

    return render(request, template, context)

def forms(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    template = "administration/forms.djhtml"

    return render(request, template, context)

def user(request, slug_name):

    pass

def rooms(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    context['rooms'] = Room.objects.all()

    context['room_reservations'] = RoomReservation.objects.all()

    context['course_events'] = CourseEvent.objects.all()

    context['blocks'] = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']

    # Collecting all rooms that are free for at least one two hours from now

    now = datetime.datetime.now(datetime.timezone.utc)

    end = now + datetime.timedelta(hours=2)

    free_rooms = dict()

    for room in context['rooms']:

        if room.reservation_possible(now, end):

            event = room.next_event(end)

            reservation = room.next_reservation(end)

            if event is None and reservation is None:

                free_rooms[room] = None

            elif reservation is not None:

                free_rooms[room] = event.begin_time

            elif event is not None:

                free_rooms[room] = reservation.begin_time

            elif event.begin_time < reservation.begin_time:

                free_rooms[room] = event.begin_time

            else:

                free_rooms[room] = reservation.begin_time

    context['free_rooms'] = free_rooms

    template = "administration/rooms.djhtml"

    return render(request, template, context)

def room_detail(request, room):

    template = "administration/room_detail.djhtml"

    context = dict()

    #context = {'money' : update_balance(None)}

    room = Room.objects.get(name=room)

    context['room'] = room

    context['reservations'] = RoomReservation.objects.filter(room=room).filter(begin_time__gte=datetime.datetime.now())

    context['course_events'] = CourseEvent.objects.filter(room=room).filter(begin_time__gte=datetime.datetime.now())

    # Building the room occupancy of today:

    today = datetime.date.today()

    if today.isoweekday() in {6,7}:  # Weekend

        today = today + datetime.timedelta(days=8-today.isoweekday())

    context['days'] = [today]

    # Collecting events

    course_events = CourseEvent.objects.filter(room=room).filter(begin_time__date=today)

    print(course_events)

    #university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    #study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    #events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    conflicts, table_code = create_roster_rows(course_events)

    context['time_blocks'] = table_code

    context['conflicts'] = conflicts

    print(context['time_blocks'])

    return render(request, template, context)

def login(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    if request.method == "POST":

        name = request.POST['name']

        passphrase = request.POST['pass']

        user = authenticate(username=name, password=passphrase)

        if user is not None: # The user was successfully authenticated

            print("YA")

            return HttpResponseRedirect(request.POST['next'])

        else: # User credentials were wrong

            context['next'] = request.POST['next']

            context['message'] = _("The given credentials were not correct.")

    else:

        context['next'] = request.GET.get('next', None)

        if context['next'] is None:

            context['next'] = reverse('administration-index')

    template = 'administration/login.djhtml'

    return render(request, template, context)

Fundamenteel is deze bachelorproef nog altijd een werk dat moet bijdragen aan

het ALIPA-project van de UHasselt.\\

Voor het stroomlijnen van de ICT-infrastructuur is het ook nodig om kleine

problemen en mankementen op te lossen als ze gevonden worden. Een afgewerkt

geheel voedt het gevoel dat alles goed en orderlijk samenwerkt met elkaar, een

belangrijke doelstelling om vertrouwen te creëren in de gebruikers.

Tijdens het maken van dit proefwerk ben ik op enkele kleine punten gestoten die

niet direct van invloed waren op mijn proef, maar die ik hier toch wens te

vermelden. Het gaat dan om kleine slordigheden, schoonheidsfoutjes, verouderde

informatie, ...

Alle benodigde informatie, alsook een redenering wordt per punt uitgeschreven.

** Verouderde informatie

*** Campushopper afgeschaft

Op de pagina https://www.uhasselt.be/Contact-en-ligging onder de rubriek "Campus

 Hasselt/Gevangenis" wordt verteld dat men de

Campushopper kan nemen, maar deze werd al in 2017 afgeschaft. Beter is om Boulevardpendel

te nemen, of elke bus die het Dusartplein aandoet.[fn::Dit zijn de volgende

 lijnen: 1, 3, 5, 11, 13, 16, 18a, 20a, 22, 23, 35, 36, 45, 46, 48, 51, 52, 180,

 182, AL, BP, H13, H14, H41, H51. (https://www.delijn.be/nl/haltes/halte/403040/Hasselt_Dusartplein)]

** Onnodige informatie

*** Spartacusplan

Op https://www.uhasselt.be/Contact-en-ligging staat een link naar een

PDF-bestand omtrent het Spartacusplan. Dit heeft inderdaad te maken met het

openbaar vervoer, maar voegt weinig toe aan het eigenlijke doel van deze pagina:

Bezoekers informeren over hoe ze de UHasselt kunnen bereiken.\\

Ik stel voor om de vermelding hierover de verwijderen.

** Slecht te vinden informatie

*** Plattegronden

Er is weinig te vinden van plattegronden op de website; waar zijn welke lokalen

 te vinden, plattegronden van de 1ste verdieping, ...

Het kan ook zijn dat dit niet per sé nodig is; indien op de campus zelf adequate

 wegbewijzering wordt aangebracht, wordt een plattegrond minder belangrijk.

 Waar vind ik alle plattegronden van de campussen? Het zijn er maar 2...

 Ik heb er eentje gevonden van de campus Diepenbeek op https://www.uhasselt.be/Contact-en-ligging:

 https://www.uhasselt.be/images/UHasselt/maps/2015/campus-diepenbeek/campus-diepenbeek-gebouwDE.jpg

 Maar dat is ook enkel gelijkvloers, en niet up-to-date met nieuwe aanbouw.

** Verbeteringspunten

*** Video's op YouTube

Op https://www.uhasselt.be/Videos zijn er veel filmpjes te vinden over het

reilen en zeilen in de universiteit. Maar eigenlijk zijn het links naar het

videoplatform YouTube, onderdeel van Google Inc. Eerder werd in deze thesis

[[google-privacy][de integratie met diensten van Google]] op de korrel genomen.\\

te bieden, middels het [[https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Video][~

**** Licensiëring video's

De aangegeven licentie van de video's is de "Standaard YouTube-licentie", deze

licentie voldoet niet aan de vereisten voor een "Vrij cultureel werk".

De aard van deze video's is duidelijk: Ze dienen om toekomstige studenten te

informeren over de UHasselt en al haar richtingen, een blik te werpen op

studentenfaciliteiten (zoals verenigingen), en ook als een advertentie om voor

UHasselt te kiezen.\\

De doelstelling bereiken wordt met deze licentiekeuze actief tegengewerkt;

mensen mogen deze video's niet delen, of aanpassen voor nieuwe werken. Er zijn

ook voorwaarden op het privégebruik ervan.\\

Creatieve werken met deze doelstellingen dienen zo vrij mogelijk uitgegeven te

worden om de zichtbaarheid en verspreidingskansen ervan te maximaliseren. Door de huidige wetgeving

omtrent kopieerrechten is dit niet automatisch mogelijk, maar er bestaan wel

licenties die hiervoor een zeer toereikend soelaas bieden.

Ik raad aan om de licenties op de video's te vervangen met de

[[https://creativecommons.org/licenses/by/4.0/deed.nl][CC-BY 4.0]]-licentie, die deze problemen direct oplost. Dit kan ook gedaan worden als beslist

wordt de video's op YouTube te laten staan.

Een mooi uitgewerkte huisstijl is essentieel voor het creëren van een gevoel van

samenhorigheid met verschillende entiteiten: Ze dienen ter onderscheiding van de

rest, en 

In Joeni wordt de huisstijl van de UHasselt verder uitgewerkt en gebruikt. In

dit hoofdstuk wordt dit in detail uitgelegd, zodat het als basis kan dienen voor

andere software.

** Logo

Joeni heeft tot doel als vervanging te dienen voor het Studentendossier en

BlackBoard. In combinatie met de relatie tot de UHasselt, wordt voor Joeni het

volgende logo gebruikt:

#+CAPTION: Logo van Joeni

#+NAME:   fig:joeni-logo

[[./images/joeni-logo.png]]

Het logo is duidelijk afgeleid van het logo van de UHasselt. De driehoekjes zijn

zo geplaatst dat het geheel lijkt op een HTML-element, om het verband als

webapplicatie aan te duiden.

*** UHasselt

Het logo van de UHasselt is op verschillende plaatsen te vinden op de website.

De meest prominente locatie is de titelbalk.

#+CAPTION: Afbeelding van hoe het logo van de UHasselt in de titelbalk verwerkt is

#+NAME: fig:uhasselt-titlebar

[[./img/a.jpg]]

Alhoewel de vorm van de driehoekjes lichtjes afwijkt van het echte logo, valt

dit nauwelijks op. Het logo verwerken in de titel is mogelijk, omdat dit gewoon

tekst is, meer specifiek, ▶ ~U+25B6 BLACK RIGHT-POINTING TRIANGLE~.

Het voordeel hieraan is niet louter een besparing op bytes.[fn:utf-8] Omdat dit

tekst is, zal de betere webbrowser in staat zijn om, afhankelijk van de

achtergrond, het logo de juiste kleur te geven. Op de volgende afbeelding is dit

effect duidelijk te zien, zeker in contrast met het logo dat de

UHasselt-bibliotheek gebruikt.

[fn:utf-8] Meestal wordt een logo meegestuurd die langs de titel wordt

weergegeven in de titelbalk. Dat is niet fout, maar ze zijn wel een stuk groter in het

aantal bytes. [[https://bibliotheek.uhasselt.be/sites/default/files/favicon.ico][Het logo dat UHasselt gebruikt op haar eigen website]] is 1,150

bytes groot, [[https://www.fileformat.info/info/unicode/char/25b6/index.htm][▶(×2) is slechts 3(×2) bytes groot]], dus een aanzienlijke verkleining van de

benodigde ruimte.

#+CAPTION: Vergelijking tussen logo via UTF-8/tekst en als afbeelding. Merk op hoe het logo van de bibliotheek praktisch onzichtbaar is bij de zwarte achtergrond.

#+NAME: fig:utf8-better

[[./img/a.jpg]]

** Lettertype

Op de website wordt als [[https://www.uhasselt.be/UH/Help-Studenten-Algemene_Help-Huisstijl/Lettertype.html][lettertype]] Verdana aangereikt. Dit strookt echter niet

met het lettertype dat wordt gebruikt in de vele documenten die de UHasselt

verspreidt, gaande van informatieboekjes over de studierichtingen tot de

spandoeken die buiten aan het universiteitsgebouw worden opgehangen.

Het wordt nergens vermeld, maar dit lettertype gelijkt volledig op

[[https://design.ubuntu.com/font/][het Ubuntu-lettertype]], zoals de volgende vergelijking duidelijk aantoont.

#+CAPTION: Vergelijking tussen lettertype gebruikt door UHasselt en Ubuntu-lettertype op voorbeeldtekst

#+NAME: fig:font-comparison

[[./images/font-comparison.png]]

Dit lettertype wordt doorheen Joeni gebruikt voor het aanduide van belangrijke

(kop)teksten.

** Kleuren

De UHasselt gebruikt in de informatiebrochures wel een kleurenpalet dat eigen

lijkt te zijn aan de bepaalde faculteiten, maar verder wordt het haast nergens

anders gebruikt. Vermoedelijk komt dit omdat nergens in de huisstijl wordt

vermeld welke kleuren gebruikt kunnen worden voor wat.\\

Hieronder worden de verschillende kleurwaarden voor elke faculteit uiteengezet.

Ze geven een eigen gezicht aan de documentatie binnen elke faculteit, en kunnen

makkelijk gebruikt worden voor zowel voor- als achtergrondkleuren.

#+CAPTION: Een kleurenpalet dat gebruikt kan worden voor de huisstijl van de UHasselt verder uit te bouwen

#+NAME: fig:color-swatches

[[./images/color-swatches.png]]

#+language: nl

#+latex_class: article

#+latex_class_options: [a4paper]

#+latex_header: \usepackage{pdfpages}

#+latex_header: \usepackage[dutch]{babel}

#+OPTIONS: toc:nil

#+author: Maarten Vangeneugden @@latex:\\@@ prof. dr. Wim Lamotte

#+date: 2017-2018

#+title: Joeni

#+subtitle: Bachelorproef voorgedragen tot het behalen van de graad van bachelor in de informatica

* COMMENT Structuur

1. Samenvatting

2. Voorwoord

3. Inhoudsopgave

* Samenvatting

* Voorwoord

* Inhoudsopgave

#+TOC: headlines 6

#+INCLUDE: "./aandachtspunten.org"

In dit hoofdstuk wordt dieper ingegaan op de verantwoording voor de gekozen

software, en worden de mogelijke alternatieven besproken.

** Softwareframework

*** Django

Voor het schrijven van Joeni heb ik uitgesproken gebruik gemaakt van

[[https://www.djangoproject.com/][het Django-framework]].

**** Webframework

Django is een framework gericht op het ontwikkelen van websites. Omdat Joeni

hoort te dienen als een directe vervanging voor het Studentendossier en

BlackBoard, zou een website bouwen de overgang het gemakkelijkst laten gebeuren.

*** Python (3)

Alhoewel er wel voor elke programmeertaal één of meerdere frameworks voor het

maken van websites bestaan, ging de voorkeur uit naar Python.

*** UTF-8

Joeni maakt uitsluitend gebruik van UTF-8 voor encodering van tekst.\\

Niet alleen is dit standaard voor strings in Python 3, het laat ook toe om het

logo van de UHasselt in de titelbalk te verwerken, en zorgt ervoor dat alle

teksten correct gespeld en opgeslagen kunnen worden.

* Andere mogelijkheden

Tegenover de gemaakte keuzes staan ook een hoop alternatieven die niet werden

gebruikt. 

** Ruby (on Rails)

Mijn ervaring met Ruby is simpelweg onbestaande; ik heb nooit in deze taal

geprogrammeerd. De beperkte tijd die ik had voor de bachelorproef stond niet toe

dat ik mij nog zou verdiepen in een nieuwe programmeertaal.

** PHP

Ongetwijfeld een van de meest gebruikte talen voor het schrijven van dynamische

websites.\\

Het probleem is compleet het tegenovergestelde van [[Ruby (on Rails][Ruby]]; PHP ken ik zeer goed.

beveiligingslekken, vertoont extreem raar gedrag dat niet voorkomt in Python,

Django settings for Joeni project.

Generated by 'django-admin startproject' using Django 2.0b1.

For more information on this file, see

https://docs.djangoproject.com/en/dev/topics/settings/

For the full list of settings and their values, see

https://docs.djangoproject.com/en/dev/ref/settings/

"""

import os

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# Quick-start development settings - unsuitable for production

# See https://docs.djangoproject.com/en/dev/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!

SECRET_KEY = '!2634qc=b*lp0=helzcmvb3+1_wcl!6z@mhzi%p(vg7odq&gfz'

# TEMP Password: adminadmin | admin

# SECURITY WARNING: don't run with debug turned on in production!

DEBUG = True

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = [

    'django.contrib.admin',

    'django.contrib.auth',

    'django.contrib.contenttypes',

    'django.contrib.humanize',

    'django.contrib.sessions',

    'django.contrib.messages',

    'django.contrib.staticfiles',

    'administration',

    'agora',

    'courses',

    'joeni',

]

MIDDLEWARE = [

    'django.middleware.security.SecurityMiddleware',

    'django.middleware.locale.LocaleMiddleware',

    'django.middleware.common.CommonMiddleware',

    'django.middleware.csrf.CsrfViewMiddleware',

    'django.contrib.sessions.middleware.SessionMiddleware',

    'django.contrib.auth.middleware.AuthenticationMiddleware',

    'django.contrib.sessions.middleware.SessionMiddleware',

    'django.contrib.messages.middleware.MessageMiddleware',

    'django.middleware.clickjacking.XFrameOptionsMiddleware',

    'django.middleware.security.SecurityMiddleware',

    # Caching middleware

    'django.middleware.cache.UpdateCacheMiddleware',

    'django.middleware.common.CommonMiddleware',

    'django.middleware.cache.FetchFromCacheMiddleware',

]

# Caching settings

CACHE_MIDDLEWARE_ALIAS = 'default'

CACHE_MIDDLEWARE_SECONDS = 300

CACHE_MIDDLEWARE_KEY_PREFIX = ''

ROOT_URLCONF = 'joeni.urls'

TEMPLATES = [

    {

        'BACKEND': 'django.template.backends.django.DjangoTemplates',

        'DIRS': [os.path.join(BASE_DIR, 'templates')],

        'APP_DIRS': True,

        'OPTIONS': {

            'context_processors': [

                'django.template.context_processors.debug',

                'django.template.context_processors.request',

                'django.contrib.auth.context_processors.auth',

                'django.contrib.messages.context_processors.messages',

            ],

        },

    },

]

#WSGI_APPLICATION = 'joeni.wsgi.application'

# Database

# https://docs.djangoproject.com/en/dev/ref/settings/#databases

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.sqlite3',

        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),

    }

}

# Page to display when a user needs / wants to log in

LOGIN_URL = '/administration/login'

# Custom User model

AUTH_USER_MODEL = 'administration.User'

# Password validation

# https://docs.djangoproject.com/en/dev/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = []

if not DEBUG:

    # XXX: For testing and easily creating new accounts, I've disabled the

    # validators to make it easier to work with.

    AUTH_PASSWORD_VALIDATORS = [

        {

            'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',

        },

        {