168 lines
5.5 KiB
Python
168 lines
5.5 KiB
Python
from django.core.management.base import BaseCommand
|
|
|
|
from symposion.conference.models import Section, current_conference
|
|
|
|
from symposion.schedule.models import (Day, Presentation, Room, SlotKind, Schedule, Slot, SlotRoom)
|
|
|
|
from symposion.proposals.models import ProposalBase
|
|
|
|
from dateutil.parser import parse
|
|
|
|
from collections import Counter
|
|
from pathlib import Path
|
|
import csv
|
|
|
|
|
|
class Command(BaseCommand):
|
|
known_headers = ["date", "start time", "end time", "kind", "rooms"]
|
|
SLOTS = 'slots'
|
|
TALKS = 'talks'
|
|
|
|
help = "Updates the schedule based on two csv files, "\
|
|
"one that gives all the talk slots, the other the talks."
|
|
|
|
def add_arguments(self, parser):
|
|
parser.add_argument(self.SLOTS, type=Path)
|
|
parser.add_argument(self.TALKS, type=Path)
|
|
|
|
def parse_slots(self, options):
|
|
self.date_strs = set()
|
|
self.room_names = set()
|
|
self.slotkind_names = set()
|
|
self.slot_details = {}
|
|
|
|
slot_type_count = Counter()
|
|
|
|
with open(options[self.SLOTS]) as csv_file:
|
|
csv_reader = csv.reader(csv_file)
|
|
|
|
headers = next(csv_reader)
|
|
|
|
assert headers == self.known_headers
|
|
|
|
for row in csv_reader:
|
|
assert len(row) == len(self.known_headers)
|
|
|
|
rowdate, start_time, end_time, kind, rooms = row
|
|
self.slotkind_names.add(kind)
|
|
|
|
if rowdate:
|
|
date = rowdate
|
|
self.date_strs.add(date)
|
|
|
|
assert kind, "kind cannot be blank"
|
|
|
|
slot_type_count[(date, kind)] += 1
|
|
kindslot = f"{kind} {slot_type_count[(date, kind)]}"
|
|
|
|
for room in rooms.split(';'):
|
|
room = room.strip()
|
|
self.room_names.add(room)
|
|
|
|
self.slot_details[(date, kindslot, room)] = (start_time, end_time)
|
|
|
|
def parse_talks(self, options):
|
|
self.talks = {}
|
|
|
|
with open(options[self.TALKS]) as csv_file:
|
|
csv_reader = csv.reader(csv_file)
|
|
|
|
self.used_rooms = next(csv_reader)
|
|
|
|
assert self.used_rooms[0] == '', "Cell (1, 1) must be empty"
|
|
|
|
for room in self.used_rooms[1:]:
|
|
assert room in self.room_names, f"Unknown room: {room}"
|
|
|
|
for row in csv_reader:
|
|
cell = row[0]
|
|
|
|
if cell.rsplit(' ', 1)[0] in self.slotkind_names:
|
|
kindslot = cell
|
|
|
|
for i, room in enumerate(self.used_rooms[1:], 1):
|
|
talk_id = row[i]
|
|
|
|
if not talk_id:
|
|
continue
|
|
|
|
assert (date, kindslot, room) in self.slot_details,\
|
|
f"Slot ({date}, '{kindslot}', '{room}') not found"
|
|
|
|
self.talks[(date, kindslot, room)] = int(talk_id)
|
|
|
|
else:
|
|
assert parse(row[0]), "Not a date: {row[0]}"
|
|
|
|
date = row[0]
|
|
|
|
for col in row[1:]:
|
|
assert col == '', f"All other columns must be empty: {date}"
|
|
|
|
def create_simple_models(self):
|
|
self.days = {}
|
|
for date in self.date_strs:
|
|
day, _created = Day.objects.get_or_create(
|
|
schedule=self.schedule, date=date)
|
|
self.days[date] = day
|
|
|
|
self.rooms = {}
|
|
for room_name in self.room_names:
|
|
room, _created = Room.objects.get_or_create(
|
|
schedule=self.schedule,
|
|
name=room_name,
|
|
order=self.used_rooms.index(room_name))
|
|
self.rooms[room_name] = room
|
|
|
|
self.slotkinds = {}
|
|
for slotkind_name in self.slotkind_names:
|
|
slotkind, _created = SlotKind.objects.get_or_create(
|
|
schedule=self.schedule, label=slotkind_name)
|
|
self.slotkinds[slotkind_name] = slotkind
|
|
|
|
def create_complex_models(self):
|
|
for details, talk_id in self.talks.items():
|
|
date, kindslot, room_name = details
|
|
kind_name = kindslot.rsplit(' ', 1)[0]
|
|
|
|
(start_time, end_time) = self.slot_details[(date, kindslot, room_name)]
|
|
|
|
proposal = ProposalBase.objects.filter(pk=talk_id).first()
|
|
|
|
assert proposal, f"Could not find proposal {talk_id}"
|
|
|
|
preso = Presentation.objects.filter(proposal_base=proposal).first()
|
|
|
|
assert preso, f"Could not find Presentation for talk {talk_id}"
|
|
|
|
if not preso.slot:
|
|
|
|
# TODO the exclusive list should not be hard coded, another csv file maybe.
|
|
exclusive = kind_name in ["plenary", "morning tea", "lunch", "afternoon tea"]
|
|
|
|
preso.slot = Slot.objects.create(
|
|
day=self.days[date],
|
|
kind=self.slotkinds[kind_name],
|
|
start=start_time,
|
|
end=end_time,
|
|
exclusive=exclusive)
|
|
|
|
# FIXME update the preso.slot, e.g. if the day/time changes
|
|
|
|
preso.save()
|
|
|
|
# FIXME what happens if the room changes?
|
|
slotroom, _create = SlotRoom.objects.get_or_create(
|
|
slot=preso.slot,
|
|
room=self.rooms[room_name])
|
|
|
|
def handle(self, *args, **options):
|
|
self.parse_slots(options)
|
|
self.parse_talks(options)
|
|
|
|
conf = current_conference()
|
|
section = Section.objects.filter(conference=conf, slug="main").all().first()
|
|
self.schedule, _created = Schedule.objects.get_or_create(section=section)
|
|
|
|
self.create_simple_models()
|
|
self.create_complex_models()
|