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>',

        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_first_quarter_column(hour, quarter):

    """Creates and returns the first part of the quarter row, which is the

    column with the current time in it."""

    quarter_line = "<tr><td style='font-size:"

    if quarter != 0:

        quarter_line += "xx-small; color: grey;"

    else:

        quarter_line += "x-small;"

    quarter_line += "'>"

    if hour < 10:

        quarter_line += "0"

    quarter_line +=  str(hour) +":"

    if quarter == 0:

        quarter_line += "0"

    quarter_line +=  str(quarter)

    quarter_line += "</td>"

    return quarter_line

def make_quarter_row(events, hour, quarter):

    """Creates an HTML row for a quarter. Expects *NO conflicts!*"""

    if len(conflicting_events(events)) != 0:

        print(conflicting_events(events))

        raise ValueError("events contains conflicts!")

    quarter_line = make_first_quarter_column(hour, quarter)

    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

This is the roster template. You can use this to display a hourly roster,

spread over a series of days. To function properly, this template requires

the following variables:

- days :: A list of all days for which a column must be made.

- time_blocks :: A list of all rows with their respective timings, that must

                 be displayed in the roster. These elements must *not* contain

                 any unsafe elements!

- conflicts :: A dictionary with all conflicting events that need to be listed.

{% endcomment %}

<!--<style>

    <th>

        {#<td></td> {# Empty row for hours #} {# Apparantly this isn't necessary with <th /> #}

        {% for day in days %}

            <td>{{ day|date:"l (d/m)" }}</td>

    </th>

    {% for element in time_blocks %}

        {{ element|safe }}

    {% endfor %}

</table>

{% for number, conflict_list in conflicts.items %}

    <h2 id="Conflict {{ number }}">Conflict {{ number }}</h2>

    {% for conflict in conflict_list %}

        {% if conflict.recently_created %}

            <div class="event-new">

            <div class="event-update">

        <a href="{% url "courses-course-index" conflict.course.course.slug_name %}">

            {{ conflict.course }}</a><br />

        {#<a href="{% url "administration-user" conflict.docent.user_data.slug_name %}">#}

        {#{{ conflict.docent }}</a><br />#}

        {{ conflict.docent }}<br />

        {{ conflict.begin_time|date:"H:i" }} - {{ conflict.end_time|date:"H:i" }}<br />

        <a href="{% url "administration-room-detail" conflict.room %}">

            {{ conflict.room }}</a> ({{ conflict.subject }})

        </div>

{% endfor %}

    font-family: ubuntu;

    border-style: solid;

    text-transform: uppercase;

    border-width: 0.3em;

    margin: 1em;

    border-color: $uhasselt-color;

    padding: 0.2em;

    text-decoration: none;

    color: $uhasselt-color;

    font-weight: bold;

}

a.btn:hover {

    background-color: $uhasselt-color;

    color: white;

}

dl dt {

    margin: 5px;

}

.event {

    padding: 5px;

}

td {

    padding-right: 1em;

}

.event-update {

    padding: 5px;

    background-color: yellow;

    color: red;

    border: medium dotted red;

}

.event-new {

    padding: 5px;

    background-color: white;

    color: black;

    border: medium dashed black;

}

.event-note {

    padding: 5px;

    color: purple;

    border: medium double purple;

}

.event-conflict {

    padding: 5px;

    background-color: red;

    color: white;

    border: medium dashed;

    border-color: inherit;

}

p.conflict {