joeni

building of the roster. """

from django.shortcuts import render

from collections import OrderedDict

import datetime

from django.urls import reverse

from django.utils.translation import gettext as _

from .models import *

import administration

def same_day(datetime_a, datetime_b):

    """True if both a and b are on the same day, false otherwise."""

    return (

        datetime_a.day == datetime_b.day and

        datetime_a.month == datetime_b.month and

        datetime_a.year == datetime_b.year)

def same_daytime(moment, hour, minute):

    return (moment.minute == minute and moment.hour == hour)

def conflicting_events(events):

    """Finds conflicting events in the given set, and returns a list of all

    conflicting events, grouped according to their conflicts in lists."""

    conflicts = list()

    test_conflict = list()

    #for event in events.order_by("begin_time"):

    for event in events:

        if len(test_conflict) == 0:

            test_conflict.append(event)

        else:

            possible_conflict = test_conflict.pop()

            #print("comparing" + str(possible_conflict) + " - " + str(event))

            if possible_conflict.end_time > event.begin_time:  # New conflict!

                test_conflict.append(possible_conflict)

                test_conflict.append(event)

                #print(test_conflict)

            elif len(test_conflict) == 0:  # No conflict

                test_conflict.append(event)

            else:  # No conflict, but previous conflicting events exist

                test_conflict.append(possible_conflict)

                conflicts.append(test_conflict.copy())

                test_conflict.clear()

    if len(test_conflict) >= 2:

        conflicts.append(test_conflict.copy())

    return conflicts

def replace_conflict(events, conflicts):

    """Removes the conflicts from events, and replaces them with a new

    event. Returns the key number for this conflict set. Expects the conflicts

    to be in chronological order based on begin_time."""

    for conflict in conflicts:

        events.remove(conflict)

    conflict_number = 0

    for event in events:

        if event.note == "Conflict " + str(conflict_number):

            conflict_number += 1

    replacement = Event(

        begin_time = conflicts[0].begin_time,

        end_time = conflicts[-1].end_time,

        note = "Conflict " + str(conflict_number),

        )

    events.append(replacement)

    return conflict_number

def replace_conflicts(events):

    """Searches for all events that are in conflict regarding timespans, and

    replaces them with a general event. Returns a dictionary with keys referencing

    a specific conflict block, and the values being a list of the events that are

    in conflict with each other."""

    all_conflicts = conflicting_events(events)

    conflict_dict = dict()

    for conflict_list in all_conflicts:

        conflict_number = replace_conflict(events, conflict_list)

        conflict_dict[conflict_number] = conflict_list

    return conflict_dict

def create_roster_event(event_type, quarters, content, style="", note=""):

    return '<td class="{event_type}" style="{style}" {title} rowspan="{quarters}">{content}</td>'.format(

        event_type=event_type,

        style=style,

        quarters=quarters,

        content=content,

        title=note)

def create_roster_conflict_event(event):

    quarters = (event.end_time - event.begin_time).seconds // 60 // 15

    content = _('<strong>Conflicting events!<br />See <a href="#'+event.note+'">'+event.note+'</a> for more information.</strong>')

    return create_roster_event("event-conflict", quarters, content)

def create_roster_study_event(event):

    pass  # TODO

def create_roster_university_event(event):

    pass  # TODO

def create_roster_course_event(event):

    # FIXME: Currently not all users are equipped with a user_data object.

    # Because of this, reversing the link to the docent's page may throw a

    # RelatedObjectDoesNotExist error. Until that's resolved, I've wrapped

    # creating that link in a try catch.

    docent_link = ""

    try:

        docent_link = reverse('administration-user', args=(event.docent.user_data.slug_name(),))

    except :

        pass

    quarters = (event.end_time - event.begin_time).seconds // 60 // 15

    course_link = reverse('courses-course-index', args=(event.course.course.slug_name,))

    room_link = reverse('administration-room-detail', args=(str(event.room),))

    event_type = "event"

    content = "{course}<br /> {docent}<br />{begin} - {end}<br /> {room} ({subject})".format(

        course = '<a href="'+course_link+'">'+str(event.course)+'</a>',

        docent = '<a href="'+docent_link+'">'+str(event.docent)+'</a>',

        begin  = event.begin_time.strftime("%H:%M"),

        end    = event.end_time.strftime("%H:%M"),

        room   = '<a href="'+room_link+'">'+str(event.room)+'</a>',

        subject = event.subject,

        )

    style = "background-color: #"+event.course.course.color+"; color: white;"

    if event.recently_created():

        event_type = "event-new"

        style = ""

    elif event.recently_updated():

        event_type = "event-update"

        style = ""

    elif event.note != "":

        event_type = "event-note"

    return create_roster_event(event_type, quarters, content, style, event.note)

def first_last_day(events):

    """Returns the first and last day of the starting times of the given events."""

    earliest = events[0].begin_time

    latest = events[0].begin_time

    for event in events:

        if event.begin_time < earliest:

            earliest = event.begin_time

        if event.begin_time > latest:

            latest = event.begin_time

    first = datetime.date(earliest.year, earliest.month, earliest.day)

    last = datetime.date(latest.year, latest.month, latest.day)

    return first, last

def create_roster_for_event(event, conflict=False):

    """Determines which function to call to build the roster entry for the given event."""

    if conflict and isinstance(event, Event):

        return create_roster_conflict_event(event)

    elif isinstance(event, CourseEvent):

        return create_roster_course_event(event)

    elif isinstance(event, UniversityEvent):

        return create_roster_university_event(event)

    elif isinstance(event, StudyEvent):

        return create_roster_study_event(event)

    elif isinstance(event, Event):

        return create_roster_event(event)

    else:

        raise TypeError("Given object is not of any Event type")

def make_quarter_row(events, hour, quarter):

        quarter_line += "0"

    quarter_line +=  str(hour) +":"

    if quarter == 0:

        quarter_line += "0"

    quarter_line +=  str(quarter)

    quarter_line += "</td>"

    first_day, last_day = first_last_day(events)

    for i in range((first_day - last_day).days, 1):

        column_added = False

        current_day = (last_day + datetime.timedelta(days=i))

        current_daytime = datetime.datetime(

            current_day.year,

            current_day.month,

            current_day.day,

            hour=hour,

            minute=quarter,

            tzinfo = datetime.timezone.utc)

        for event in events:

            if (same_day(event.begin_time, current_day) and

                same_daytime(event.begin_time, hour, quarter)):  # Event starts on this quarter

                quarter_line += create_roster_for_event(

                    event,

                    conflict = (event.note.startswith("Conflict ")))

                column_added = True

            elif (same_day(event.begin_time, current_day) and

                  event.begin_time < current_daytime and

                  event.end_time >= current_daytime):

                column_added = True

                break

        if not column_added:

            quarter_line += "<td></td>"

    quarter_line += "</tr>"

    return quarter_line

def create_roster_rows(events):

    if len(events) == 0:

        return {}, []

    events = list(events.order_by("begin_time"))

    conflict_dict = replace_conflicts(events)

    print(conflict_dict)

    for event in events:

        print(event.begin_time)

    table_code = []

    current_quarter = datetime.datetime.now().replace(hour=8, minute=0)

    while current_quarter.hour != 20 or current_quarter.minute != 00:

        table_code.append(make_quarter_row(events, current_quarter.hour, current_quarter.minute))

        current_quarter += datetime.timedelta(minutes=15)

    return conflict_dict, table_code

{% cycle "hour" "first quarter" "half" "last quarter" as hour silent %}

{# "silent" blocks the cycle operator from printing the cycler, and in subsequent calls #}

{% load i18n %}

{% block title %}

    {% trans "Roster" %} | {{ block.super }}

{% endblock %}

{% block main %}

    {% include "administration/nav.djhtml" %}

    <h1>{% trans "Personal timetable" %}</h1>

    <h2>{% trans "Main hour roster" %}</h2>

    <style>

        <a class="btn" href="{% url "administration-roster" begin=prev_begin end=prev_end %}">

            {% trans "Previous week" %}

        </a>

        <a class="btn" href="{% url "administration-roster" %}">

            {% trans "Current week" %}

        </a>

        <a class="btn" href="{% url "administration-roster" begin=next_begin end=next_end %}">

            {% trans "Next week" %}

        </a>

        {# TODO: Add links to "previous week", "next week" and "current week" with large buttons #}

    <h2>{% trans "Explanation" %}</h2>

    <p>

        {% trans "Personal roster from" %} {{ begin|date }} {% trans "to" %} {{ end|date }}

    </p>

    <p>

        {% blocktrans %}

            Some fields may have additional information that might be of interest

            to you. This information is shown in different ways with colour codes.

        {% endblocktrans %}

    </p>

    <dl>

        <dt><span class="event-update">

            {% trans "Recent event update" %}

        </span></dt>

        <dd>

            {% blocktrans %}

                This event had one or more of its properties changed

                in the last five days. This can be the room, the hours, the subject, ...

                You're encouraged to take note of that.

            {% endblocktrans %}

        </dd>

        <dt><span class="event-new">

            {% trans "New event" %}

        </span></dt>

        <dd>

            {% blocktrans %}

                This is a new event, added in the last five days.

            {% endblocktrans %}

        </dd>

        <dt><span class="event-note">

            {% trans "Notification available" %}

        </span></dt>

        <dd>

            {% blocktrans %}

                This event has a note attached to it by the docent. Hover over

                the event to display the note.

            {% endblocktrans %}

        </dd>

    </dl>

{% endblock main %}

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

from .pingping import update_balance

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 index(request):

    template = "administration/index.djhtml"

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

    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 = {'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)

    context['cource_results'] = CourseResult.objects.filter(student=request.user)

    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