joeni

from django.contrib.auth import views as auth_views

from . import views

from django.utils.translation import gettext_lazy as _

urlpatterns = ([

    path('', views.index, name='administration-index'),

    path(_('pre-registration'), views.pre_registration, name='administration-pre-registration'),  # HOLD

    path(_('settings'), views.settings, name='administration-settings'),

    path(_('curriculum'), views.curriculum, name='administration-curriculum'),  # TODO

    # Commented because they might very well be merged with curriculum

    #path(_('results'), views.results, name='administration-results'),

    #path(_('results/<slug:course>'), views.result, name='administration-results'),

    #path(_('results/<int:student_id>'), views.result, name='administration-results'),

    path(_('forms'), views.forms, name='administration-forms'),  # In Dutch: "Attesten"  # HOLD

    path(_('forms/<str:form>'), views.forms, name='administration-forms'),  # HOLD

    path(_('rooms'), views.rooms, name='administration-rooms'),  # TODO

    path(_('rooms/<str:room>'), views.room_detail, name='administration-room-detail'),  # TODO

    #path(_('rooms/reservate'), views.room_reservate, name='administration-room-reservate'),

    path(_('roster'), views.roster, name='administration-roster'),  # TODO

    re_path(_('roster/(?P<begin>[0-9]{2}-[0-9]{2}-[0-9]{4})/(?P<end>[0-9]{2}-[0-9]{2}-[0-9]{4})'), views.roster, name='administration-roster'),  # TODO

    path(_('jobs'), views.jobs, name='administration-jobs'),  # HOLD

    path(_('bulletin-board'), views.bulletin_board, name='administration-bulletin-board'),  # TODO

    path(_('user/<slug:slug_name>'), views.user, name='administration-user'),  # TODO

    path(_('roster/<slug:user_slug>.ics'), views.roster_ics, name='administration-roster-ics'),  # TODO

    path('login', views.login, name='administration-login'),  # FIXME

    ])

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

from django.contrib.auth import login as login_auth

@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")

            login_auth(request, user)

            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)

This repository is my work for my bachelor's assignment for the study of

Informatics at [[https://uhasselt.be/][Hasselt University]]. Because of the sheer size of the project,

it's imperative that I keep track of all the things that have to be done.

In this file, I try to collect them all, in a structurally sound way.

It's possible that this file will be removed in the future, to be combined with

another file to make use of Org's clocking features, but for now, everything

will be listed here.

* Agora

*Note: Agora is NOT a priority right now!* This has been discussed with the

 promotor, and implementing the administration and courses system is a LOT more

 important than having a social platform. Nevertheless, once Courses and

 Administration are finished, work on Agora can commence, thus if there is work

 that should be done, it will be listed here, to avoid forgetting it.

** Models

** Views

** Templates

** Forms

*** TODO Post form

*** TODO Group form

*** TODO Account settings form

*** TODO Account collection form

** Urls

* Courses

** Models

*** TODO Implement group of student in a course

Dixit Lamotte: "Some studies are so big, the students have to be split up in

different groups." Thus, implement a system where the students /can/ be split in

groups by the education team of the course. If no groups exist, then they're all

treated as one giant group.

** Views

** Templates

** Forms

** Urls

** Other

* Administration

** PAGES

Eventually, a finished page consists of

- A finished template

- All models that can be accessed from that page, are finished

- A working view function

- A working URL link

- If applicable, working forms (= All forms can initiate, store, and modify

  data, and display the right error messages)

This does not include CSS or other things that overlap multiple pages. This

checklist therefore is a list of all pages that are basically done, and don't

need further action.

- [ ] Roster

- [X] Bulletin Board

- [ ] Index

- [ ] Curriculum

- [ ] Pre-registration

- [ ] Settings

- [ ] Forms

- [ ] Jobs

- [ ] Rooms

- [ ] Login

*** Rooms

**** TODO SVG rooms in an HTML canvas

That would make them clickable, so information about the rooms at UHasselt can

be retrieved by just clicking on them. You'd have to make an SVG blueprint of

the campus but eh.

** Notes

At this moment: *Implement what is already in the models.* By finishing what I

already have, I can create space in my mind for the new things.

** Models

*** TODO IBAN validator

IBAN numbers have a special format, which needs to be valid. For this, a

validator must be written.

*** TODO BIC validator

See [[IBAN validator]]

*** *ALERT* SQL standard issues!

I've got several fields that should be unique, but can also be null.

SQLite indicates two null values in the same column as a NOT UNIQUE,

but that's wrong, according to the SQL standard. This excerpt from the

PostgreSQL documentation:

In general, a unique constraint is violated if there is more than one row

 in the table where the values of all of the columns included in the constraint

are equal.

 However, two null values are never considered equal in this comparison.

 That means even in the presence of a unique constraint it is possible to

 store duplicate rows that contain a null value in at least one of the

constrained columns.

 This behavior conforms to the SQL standard,

 but we have heard that other SQL databases might not follow this rule.

 So be careful when developing applications that are intended to be portable.

** Views

*** TODO Forms, documents, ... generators

This is mainly about the legal documents that should be generated for students,

like degrees, evidence of being a student, ... These are often not to display

information, but should be put out as a PDF file, that the user can then print.

This should be done using the ReportLab Python PDF library.

Check out [[file:///home/simba/Documentation/Django/howto/outputting-pdf.html]] for

more information on how to do this.

** Templates

** TODO Roster

** TODO Personal settings

** TODO Public page

** Forms

*** TODO Personal details form

** Urls

** Other

*** TODO Implement roster system

All students (and staff) have personal rosters. This system should be able to

automatically update that. The roster will automatically show the following:

- Course schedules :: For all courses that the student follows, show the

     scheduled rooms /for their group/. If no groups are made, show the complete

     course schedule.

- Exam roster :: Show all exams of the student.

- Room reservations :: If a student has reserved a room, that will show up in

     their roster.

- Custom schedulings :: The user can also make custom schedulings, and attach

     necessary info to them.

The roster automatically opens on the current week, except when it's Saturday or

Sunday; then it shows next week.

All this data is presented through a clear and nice HTML page, and is

automatically updated in a personal iCal-file, that the user can connect to.

If that is finished, make a special form to ask for generic planning from a

certain study, course, ...

*** TODO Implement alumni system

UHasselt Alumni need to be able to give a new e-mail address. This should become

available when one has obtained a degree.

*** TODO Implement study costs system

The costs that have to be paid, must be recorded, and be presented. Data from

each year needs to be available. Check for what should be recorded at [[https://uhintra02.uhasselt.be/studdosst/sdsInschrijvingsgeld.aspx][the website]].

*** TODO System for rulings exam committee

These are probably messages that are sent out to a specific user, regarding

special measures, or some stuff like that.

*** TODO System for automatic creation of exam schedules

This system checks all current students, and needs the following info:

- For each Course:

  - The (amount of) students

  - The type of exam (verbal, writing, ...)

  - (Optionally) a notification

  - The amount of exams that have to take place

And attempts to fulfill the following requirements:

- *All exams for model trajects are spread as far as possible from one another*

- No student has overlapping exams

- All exams must take place in the given timespan

- Different exams can be given in the same room, but the maximal capicity

  must be respected

- The algorithm prefers interspacing of 2 empty seats per student. These empty

  seats may be occupied by students from other exams.

- Exams take place only in rooms with at least *double* the amount of students

  for that exam (to allow spacing). Of course, these spaces can be occupied by

  another exam batch.

- Exams that require special equipment (e.g. computers, ...) must be respected

- Rooms that already have reservations will be overridden, but a warning will be

  placed to inform about the deletion of the previous reservation.

The data is then printed to the screen, after which it can be verified. If

everything is okay, the user can accept the proposed planning, after which the

room reservations are automatically carried out.

After this point, students can view their exam rosters, and their personal

schedules are automatically updated.

*** TODO Refactoring of roster functionality

The roster needs a lot of preparation before being sent to the template. It's

currently hastly written and in the view module, but it can't stay there.

In the future, make a special roster module, and move all functionality there.

Refactor the functions, make tests so they're safe against errors, and so on.

* Report

All this needs to be put together in a giant report. For comparison: Joris'

thesis was a whopping 84 pages. Given the size of my project, I think I won't be

much below that.

** Points to talk about

*** TODO Why this MUST NOT be the final version

main digital platform of a university. Explain how the current UI is an example

of what could be. Also mention that the current existing database is suited for

directly hooking into with the new program.

*** TODO Why JavaScript is actively banned

    and my law: "If you can't make your website function properly without

    JavaScript, it shouldn't be a website in the first place."