def get(self):
path = os.path.join(os.path.dirname(__file__), 'templates/requests.html')
template_values = {
'event': Event.all().filter('event_name', 'paasrapport').fetch(1),
'guardians': Guardian.all().fetch(9999)
}
self.response.out.write(template.render(path, template_values))
def createGuardianPasses(self, event):
for g in Guardian.all():
sD = SubscriptionDetails()
sD.event = event
sD.guardian = g
sD.requested = False
sD.passphrase = binascii.b2a_hex(os.urandom(15))
sD.put()
def post(self):
session = get_current_session()
'''A guardian is already logged in'''
if self.isAuthenticatedGuardian():
self.redirectToSubscriptionPage(self)
return
'''A visitor is not authenticated as a guardian, so move on'''
session.clear()
notifications = []
templVal = {
'notifications': notifications
}
'''The guardian-id and/or passphrase are/is empty'''
if not (self.request.get('guardian-id') and self.request.get('passphrase')):
notifications.append('Vul uw voogdnummer in en de sleutel die u ontvangen heeft.')
self.showLoginPage(templVal)
return
guardian = Guardian.get_by_key_name(self.request.get('guardian-id'))
passphrase = self.request.get('passphrase')
'''A gardian with the given keyname does not exists'''
if not guardian:
notifications.append('Vul een bestaand voogdnummer in.')
self.showLoginPage(templVal)
return
'''A combination of the gardian and the passphrase does not exists.'''
subscriptionDetailsList = SubscriptionDetails.gql("WHERE guardian = :1 AND passphrase = :2", guardian, passphrase).fetch(1,0)
if not subscriptionDetailsList:
notifications.append('Vul een geldige combinatie van voogdnummer en sleutel in.')
self.showLoginPage(templVal)
return
subscriptionDetails = subscriptionDetailsList[0]
'''The guardian has already made a subscription for the concerning event'''
if subscriptionDetails.requested:
notifications.append('U kunt geen verzoeken meer indienen.')
path = os.path.join(os.path.dirname(__file__), '../templates/notification.html')
self.response.out.write(template.render(path, templVal))
return
'''Everything is ok, so login and go to the subscription page!'''
event = subscriptionDetails.event
session['guardian'] = guardian
session['event'] = event
self.redirectToSubscriptionPage(self)
def get(self):
# Add some guardians
new_guardian = Guardian(guardian_id=6781,
firstname="A.J.",
preposition="van",
lastname="Brandsma")
new_guardian.put()
new_guardian = Guardian(guardian_id=6900,
firstname="M.",
lastname="Tervuure")
new_guardian.put()
# Add an event
new_event = Event(tables=40,
talk_time=15)
new_event.put()
# Add some days to the aforementioned event
new_day = Day(date=datetime.datetime(year=2011, month=11, day=11, hour=20, minute=00),
talks=12,
event=new_event)
new_day.put()
new_day = Day(date=datetime.datetime(year=2011, month=11, day=12, hour=20, minute=00),
talks=12,
event=new_event)
new_day.put()
new_day = Day(date=datetime.datetime(year=2011, month=11, day=13, hour=20, minute=00),
talks=12,
event=new_event)
new_day.put()
# Add an event
new_event = Event(tables=40,
talk_time=15)
new_event.put()
# Add some days to the aforementioned event
new_day = Day(date=datetime.datetime(year=2011, month=11, day=20, hour=19, minute=30),
talks=12,
event=new_event)
new_day.put()
new_day = Day(date=datetime.datetime(year=2011, month=11, day=21, hour=20, minute=00),
talks=12,
event=new_event)
new_day.put()
new_day = Day(date=datetime.datetime(year=2011, month=11, day=22, hour=19, minute=45),
talks=12,
event=new_event)
new_day.put()
def get(self, eventId, guardianId):
'''The visitor is not an authenticated guardian'''
if not SubscriptionLoginHandler.isAuthenticatedGuardian():
self.redirect('/inschrijven/')
return
'''The guardian is not authorized to see the page with the given eventId/guardianId'''
if not self.isAuthorized(eventId, guardianId):
SubscriptionLoginHandler.redirectToSubscriptionPage(self)
return
'''The guardian is an authorized guardian, so show the form'''
event = Event.get_by_id(int(eventId))
days = Day.gql("WHERE event = :1", event).fetch(999)
guardian = Guardian.get_by_key_name(guardianId)
notifications = []
templVal = {
'notifications': notifications
}
subscriptionDetailsList = SubscriptionDetails.gql("WHERE event = :1 AND guardian = :2", event, guardian).fetch(1, 0)
if not subscriptionDetailsList:
notifications.append('Pagina niet gevonden.')
self.showError(templVal)
return
subscriptionDetails = subscriptionDetailsList[0]
if subscriptionDetails and subscriptionDetails.requested:
notifications.append('U kunt geen verzoeken meer indienen.')
self.showError(templVal)
return
students = Student.gql("WHERE guardian = :1", guardian).fetch(999, 0)
students_subjects = self.getStudentsSubjects(students)
if event and guardian and students and days:
templVal = {
'event': event,
'days': days,
'guardian': guardian,
'students': students_subjects
}
path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription.html')
self.response.out.write(template.render(path, templVal))
def get(self):
# Load all Guardians
path = os.path.join(os.path.dirname(__file__), 'data/voogdouder.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_guardian = Guardian(key_name=row[0].strip())
new_guardian.title=row[1].strip()
new_guardian.initials=row[2].strip()
new_guardian.preposition=row[3].strip()
new_guardian.lastname=row[4].strip()
new_guardian.streetname=row[6].strip()
new_guardian.housenumber=row[7].strip()
new_guardian.city=row[8].strip()
new_guardian.postalcode=row[9].strip()
new_guardian.email=row[12].strip()
new_guardian.save()
print "Guardian " + new_guardian.key().id_or_name() + " stored"
# Load all Students
path = os.path.join(os.path.dirname(__file__), 'data/leerlingen.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_student = Student(key_name=row[0].strip())
new_student.firstname=row[1].strip()
new_student.preposition=row[2].strip()
new_student.lastname=row[3].strip()
new_student.gender=row[4].strip()
new_student.class_id=row[5].strip()
new_student.guardian=Guardian.all().filter("__key__ >=", Key.from_path('Guardian', row[6].strip())).get()
new_student.save()
print "Student " + new_student.key().id_or_name() + " stored"
# Load all Teachers
path = os.path.join(os.path.dirname(__file__), 'data/docenten.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_teacher = Teacher(key_name=row[0].strip())
new_teacher.name=row[1].strip()
new_teacher.boxnumber=int(row[2].strip())
new_teacher.email=row[3].strip()
new_teacher.save()
print "Teacher " + new_teacher.key().id_or_name() + " stored"
# Load all Subjects
path = os.path.join(os.path.dirname(__file__), 'data/vakken.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_subject = Subject(key_name=row[0].strip())
new_subject.name=row[1].strip()
new_subject.save()
print "Subject " + new_subject.key().id_or_name() + " stored"
# Load all Students
path = os.path.join(os.path.dirname(__file__), 'data/docent_vak.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_combination = Combination()
new_combination.class_id=row[0].strip()
new_combination.subject=Subject.all().filter("__key__ >=", Key.from_path('Subject', row[1].strip())).get()
new_combination.teacher=Teacher.all().filter("__key__ >=", Key.from_path('Teacher', row[2].strip())).get()
new_combination.save()
print "Combination " + str(new_combination.key().id_or_name()) + " stored"
self.redirect("/fix")
# Set random seed
random.seed(1138)
# Add an event
event = Event(event_name="paasrapport",
tables=40,
talk_time=15)
event.put()
# Add some days to the aforementioned event
day = Day(date=datetime.datetime(year=2011, month=11, day=11, hour=20, minute=00),
talks=12,
event=event)
day.put()
guardians = Guardian.all().fetch(99999999)
samplesize = int(len(guardians)/3)
guardians = random.sample(guardians, samplesize)
for guardian in guardians:
time = TimePreference()
time.event = event
time.guardian = guardian
time.preference = random.randint(0, 2)
time.save()
days = event.days.fetch(999)
random.shuffle(days)
for i, day in enumerate(days):
day_pref = DayPreference()
day_pref.guardian = guardian
day_pref.day = day
day_pref.rank = i
def post(self, eventId, guardianId):
'''The visitor is not an authenticated guardian'''
if not SubscriptionLoginHandler.isAuthenticatedGuardian():
self.redirect('/inschrijven/')
return
'''The guardian is not authorized to the given'''
if not self.isAuthorized(eventId, guardianId):
SubscriptionLoginHandler.redirectToSubscriptionPage(self)
return
event = Event.get_by_id(int(eventId))
days = Day.gql("WHERE event = :1", event).fetch(999)
guardian = Guardian.get_by_key_name(guardianId)
students = Student.gql("WHERE guardian = :1", guardian).fetch(999, 0)
students_subjects = self.getStudentsSubjects(students)
notifications = []
templVal = {
'event': event,
'days': days,
'guardian': guardian,
'students': students_subjects,
'notifications': notifications
}
if not (event and days and guardian and students):
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
self.showError(templVal)
return
subscriptionDetailsList = SubscriptionDetails.gql("WHERE event = :1 AND guardian = :2", event, guardian).fetch(1, 0)
if not subscriptionDetailsList:
notifications.append('Pagina niet gevonden.')
self.showError(templVal)
return
subscriptionDetails = subscriptionDetailsList[0]
if subscriptionDetails and subscriptionDetails.requested:
notifications.append('U kunt geen verzoeken meer indienen.')
self.showError(templVal)
return
studentKeys = [str(k.replace('subject_', '')) for k in self.request.arguments() if re.match("subject_.+", k)]
requests = []
dayPrefs = []
for s in students[:]:
if str(s.key().name()) not in studentKeys:
students.remove(s)
if not students:
notifications.append('U kunt geen verzoek indienen als u geen enkel vak geselecteerd heeft. ')
for student in students[:]:
subjectCodes = [c for c in self.request.get_all("subject_" + str(student.key().name()))]
subjects = Subject.get_by_key_name(subjectCodes)
if len(subjectCodes) > 3:
notifications.append('U kunt maximaal 3 vakken per leerling bespreken.')
if len(subjectCodes) != len(subjects):
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
for subject in subjects:
combination = Combination.gql("WHERE class_id = :1 AND subject = :2", student.class_id, subject).fetch(1,0)[0]
if not combination:
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
self.showError(templVal)
return
request = Request()
request.event = event
request.guardian = guardian
request.student = student
request.combination = combination
requests.append(request)
'''Process timepreference'''
timePref = TimePreference()
timePref.event = event
timePref.guardian = guardian
timePref.preference = 0
if not (self.request.get('time_pref') and (int(self.request.get('time_pref')) in [0,1,2])):
notifications.append('U moet een voorkeur voor tijd aangeven.')
else:
timePref.preference = int(self.request.get('time_pref'))
'''Check if dates from the form match the dates from the event '''
dayKeys = [long(k.replace('date_', '')) for k in self.request.arguments() if re.match("date_.+", k)]
dayKeysFromStore= [day.key().id() for day in days]
daysOk = True
for dayKey in dayKeys:
if dayKey not in dayKeysFromStore:
daysOk = False
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
self.showError(templVal)
return
'''Check if the daypreference are correct filled in'''
dayPrefsList = [int(self.request.get(k)) for k in self.request.arguments() if re.match("date_.+", k)]
dayPrefsList.sort()
dayPrefsOk = True
if dayPrefsList != [1,2,3]:
dayPrefsOk = False
notifications.append('U moet een eerste, een tweede en een derde voorkeur aangeven')
'''Process daypreferences'''
if daysOk and dayPrefsOk:
for day in days:
dayPref = DayPreference()
dayPref.day = day
dayPref.guardian = guardian
dayPref.rank = int(self.request.get("date_" + str(day.key().id())))
dayPrefs.append(dayPref)
if notifications:
path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription.html')
self.response.out.write(template.render(path, templVal))
return
'''Store the requests'''
for request in requests:
request.put()
for dayPref in dayPrefs:
dayPref.put()
timePref.put()
subscriptionDetails.requested = True
subscriptionDetails.put()
SubscriptionLogoutHandler.logoutGuardian()
path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription-success.html')
self.response.out.write(template.render(path, templVal))
return
def get(self):
print ""
print "<html><body style='font-family: Helvetica; font-size: 0.9em;'>"
print time.strftime("%H:%M:%S", time.localtime()) + ": Start<br>"
logging.info("Fetching all info")
# if arg != None:
# event = Event.get_by_id(int(arg))
# else:
event = Event.all().filter("event_name", "paasrapport").get()
days = Day.all().filter("event", event).fetch(999)
days.sort(key=lambda day: day.date)
max_requests = 0
max_timepref = 0
max_rank = 0
allguardians = Guardian.all().fetch(9999)
guardians = []
requests = []
for guardian in allguardians:
requests = Request.all().filter("guardian", guardian).filter("event", event).fetch(999)
if len(requests) > 0:
max_requests = max([max_requests, len(requests)])
guardian.requests = requests
guardian.day_prefs = []
for day in days:
guardian.day_prefs.append(DayPreference.all().filter("guardian", guardian).filter("day", day).get())
guardian.day_prefs.sort(key=lambda day: day.rank)
max_rank = max([max_rank, max([day.rank for day in guardian.day_prefs])])
guardian.time_pref = TimePreference.all().filter("guardian", guardian).filter("event", event).get()
max_timepref = max([max_timepref, guardian.time_pref.preference])
if len(requests) > 5:
guardianCopy = copy.deepcopy(guardian)
guardian.requests = guardian.requests[: int(len(requests) / 2)]
guardianCopy.requests = guardianCopy.requests[int(len(requests) / 2) :]
guardianCopy.day_prefs[0].rank = 999
guardians.append(guardianCopy)
guardians.append(guardian)
timepref_options = range(max_timepref + 1)
timepref_options = [1, 2, 0]
planning = Planning(event, days)
logging.info("All guardians/requests collected")
for length in range(max_requests, 0, -1):
for timepref in timepref_options:
for rank in range(0, max_rank + 1):
for day_num, day in enumerate(days):
for guardian in filter(
lambda guardian: (len(guardian.requests) == length)
and (guardian.time_pref.preference == timepref)
and (
filter(lambda day_pref: day_pref.day.date == day.date, guardian.day_prefs)[0].rank
== rank
),
guardians,
):
# try to place these requests
placed = planning.place(guardian, day_num)
# on succes, remove guardian from guardian
# on fail, the guardian will return on a less preferable round
if placed:
guardians.remove(guardian)
logging.info("Placed")
for dayIndex, day in enumerate(planning.days):
start = time.clock()
lowestValue = 0
for i, slot in enumerate(day[0]):
lowestValue += len(planning.conflictedTeachers(day, i))
logging.info("conflicts: " + str(lowestValue))
# <--- Build a list of all regions
logging.info("Building regions")
regions = []
for tableIndex, table in enumerate(day):
region = [tableIndex, 0, -1]
previousGuardian = ""
for slotIndex, slot in enumerate(table):
guardianId = planning.getGuardianIdFromRequest(slot)
block = table[region[1] : region[2] + 1]
if guardianId == "":
if len(block) == 0:
region = [tableIndex, slotIndex, slotIndex]
elif block.count(None) == 0:
if previousGuardian != "":
region[2] = slotIndex
regions.append(region)
region = [tableIndex, 0, -1]
elif block.count(None) > 0:
if len(block) > block.count(None):
regions.append(region)
region = [tableIndex, slotIndex, slotIndex]
previousGuardian = ""
else:
if guardianId != previousGuardian and previousGuardian != "":
regions.append(region)
region = [tableIndex, slotIndex, slotIndex]
region[2] = slotIndex
previousGuardian = guardianId
block = table[region[1] : region[2] + 1]
if len(block) > block.count(None) > 0:
regions.append(region)
logging.info("Regions built")
permutationSets = {}
preconflicts = 0
pre_max_conflicts = 0
for i, slot in enumerate(day[0]):
slotConflicts = len(planning.conflictedTeachers(day, i))
pre_max_conflicts = max([pre_max_conflicts, slotConflicts])
preconflicts += slotConflicts
logging.info("Starting conflicts: " + str(preconflicts))
logging.info("Starting max slotconflicts: " + str(pre_max_conflicts))
for set in regions:
block = day[set[0]][set[1] : set[2] + 1]
block.sort(key=lambda x: planning.getTeacherStringFromRequest(x))
day[set[0]][set[1] : (set[2] + 1)] = block
sortedconflicts = 0
sorted_max_conflicts = 0
for i, slot in enumerate(day[0]):
slotConflicts = len(planning.conflictedTeachers(day, i))
sorted_max_conflicts = max([sorted_max_conflicts, slotConflicts])
sortedconflicts += slotConflicts
logging.info("Conflicts after sorting: " + str(sortedconflicts))
logging.info("Max slotconflicts after sorting: " + str(sorted_max_conflicts))
conflicts = 9999
max_conflicts = 9999
while (
conflicts >= preconflicts
and conflicts >= sortedconflicts
and max_conflicts >= pre_max_conflicts
and max_conflicts >= sorted_max_conflicts
):
for set in regions:
block = day[set[0]][set[1] : set[2] + 1]
random.shuffle(block)
day[set[0]][set[1] : (set[2] + 1)] = block
conflicts = 0
max_conflicts = 0
for i, slot in enumerate(day[0]):
slotConflicts = len(planning.conflictedTeachers(day, i))
max_conflicts = max([max_conflicts, slotConflicts])
conflicts += slotConflicts
logging.info("Conflicts after shuffling: " + str(conflicts))
logging.info("Max slotconflicts after shuffling: " + str(max_conflicts))
# <--- Cycle through conflicted regions
loop = 0
while lowestValue > 0:
logging.info("Dropping non-conflicted regions")
conflictedRegions = [
region
for region in regions
if planning.numberOfConflictsPerRegion(day, region) > 0 and (region[2] - region[1]) < 7
]
logging.info("Sorting regions to start with smallest region with highest number of conflicts")
conflictedRegions.sort(
key=lambda set: (set[2] - set[1], -planning.numberOfConflictsPerRegion(day, set))
)
logging.info(str(conflictedRegions))
loop += 2
if loop > len(conflictedRegions):
loop = len(conflictedRegions)
for set in conflictedRegions[:loop]:
logging.info("Working on set: " + str(set))
logging.info("Set size: " + str(set[2] - set[1] + 1))
# logging.info("Number of conflicts in region: "+str(planning.numberOfConflictsPerRegion(day, set)))
if planning.numberOfConflictsPerRegion(day, set) <= 0:
logging.info("Already fixed; moving on...")
continue
if not tuple(set) in permutationSets:
# logging.info("This set is new to the dictionary")
block = day[set[0]][set[1] : set[2] + 1]
permutations = itertools.permutations(block)
permutations = list(permutations)
permutationSets[tuple(set)] = permutations
else:
# logging.info("This set was already in the dictionary")
permutations = permutationSets[tuple(set)]
conflictCounter = []
for permIndex, perm in enumerate(permutations):
block = day[set[0]][set[1] : (set[2] + 1)]
day[set[0]][set[1] : (set[2] + 1)] = perm
conflicts = 0
for i, slot in enumerate(day[0]):
conflicts += len(planning.conflictedTeachers(day, i))
conflictCounter.append(conflicts)
lowestValue = min(conflictCounter)
bestOptions = [enum for enum, x in enumerate(conflictCounter) if x == lowestValue]
bestOption = random.choice(bestOptions)
newList = permutations[bestOption]
day[set[0]][set[1] : set[2] + 1] = newList
logging.info("Total conflicts: " + str(lowestValue))
if lowestValue == 0:
break
if lowestValue == 0:
break
if time.clock() - start > 600:
break
planning.outputHTML()
for dayIndex, day in enumerate(planning.days):
for tableIndex, table in enumerate(day):
for slotIndex, slot in enumerate(table):
if slot != None:
new_appointment = Appointment(
request=slot, day=days[dayIndex], table=tableIndex, slot=slotIndex
)
new_appointment.put()
def get(self, arg):
event = Event.get_by_id(int(arg))
notifications = []
if not event:
notifications.append("De bewerking kon niet worden voltooid omdat het event niet bestaat.")
events = Event.all()
path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-list.html')
template_values = {'events': events, 'logoutlink': users.create_logout_url("/") , 'notifications': notifications }
self.response.out.write(template.render(path, template_values))
return
requests = event.requests.fetch(9999)
guardians_keys = []
for request in requests:
if request.guardian.key().name() not in guardians_keys:
guardians_keys.append(request.guardian.key().name())
if not guardians_keys:
notifications.append("Er zijn geen voogden met verzoeken")
events = Event.all()
path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-list.html')
template_values = {'events': events, 'logoutlink': users.create_logout_url("/") , 'notifications': notifications }
self.response.out.write(template.render(path, template_values))
return
for guardian_num, guardian_key in enumerate(guardians_keys):
guardian = Guardian.get_by_key_name(guardian_key)
guardian_requests = Request.gql("WHERE guardian = :1 AND event = :2", guardian, event).fetch(999)
guardian_appointments = [guardian_request.appointment.get() for guardian_request in guardian_requests if guardian_request.appointment.get()]
day_ids = [appointment.day.key().id() for appointment in guardian_appointments if appointment]
day_ids = list(set(day_ids))
if not guardian_appointments:
continue
mail = Email()
message = 'Beste ' + guardian.title
if not guardian.preposition == '':
message += ' ' + guardian.preposition
message += ' ' + guardian.lastname + ',\n\n'
message += 'Er zijn afspraken ingepland voor de ouderavond(en) van het ' + event.event_name + ". "
message += 'Hieronder vind u de afspraken die voor u zijn gemaakt:\n\n'
for day_id in day_ids:
day = Day.get_by_id(day_id)
message += 'Op ' + str(day.date.day) + ' ' + AdministrationInviteGuardiansHandler.getMonthText(self, day.date.month) + ' ' + str(day.date.year) + ':\n'
for appointment in guardian_appointments:
if appointment.day.key().id() == day_id:
student = appointment.request.student
m = event.talk_time * appointment.slot
d = timedelta(minutes=m)
time = day.date + d
message += 'Tijd: ' + str(time.hour) + ':' + str(time.minute) + '\n'
message += 'Tafel: ' + str(appointment.table) + '\n'
message += 'Leerling: ' + student.firstname + ' ' + student.preposition + ' ' + student.lastname + '\n'
message += 'Vak: ' + appointment.request.combination.subject.name + '\n'
message += 'Docent: ' + appointment.request.combination.teacher.name + '\n'
message += 'Docentcode: ' + appointment.request.combination.teacher.key().name() + '\n\n'
# mail.sendMail(guardian.email, 'Afspraken ouderavond(en) ' + event.event_name, message)
if guardian_num == 0:
print message
return
def post(self, arg):
event = Event.get_by_id(int(arg))
notifications = []
appointments = []
template_values = {
'event': event,
'appointments': appointments,
'notifications': notifications,
'logoutlink': users.create_logout_url("/")
}
if not event:
notifications.append("Er is geen ouderavondreeks gevonden met het nummer " + str(arg))
path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-appointments.html')
self.response.out.write(template.render(path, template_values))
return
code = self.request.POST['search-code']
method = self.request.POST['search-on']
if not code:
notifications.append("Er dient een docentcode of voogdnummer ingevoerd te worden.")
if not method:
notifications.append("Er dient aangegeven te worden of er op docent of voogd gezocht wordt.")
if not (code and method):
path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-appointments.html')
self.response.out.write(template.render(path, template_values))
return
if method == 'guardian':
guardian = Guardian.get_by_key_name(code)
if not guardian:
notifications.append("Er is geen voogd gevonden met het voogdnummer " + str(code))
path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-appointments.html')
self.response.out.write(template.render(path, template_values))
return
requests = guardian.all_requests.filter('event', event).fetch(999)
for request in requests:
if request.appointment.get():
appointments.append(request.appointment.get())
if not appointments:
notifications.append("Er zijn geen afspraken gevonden voor de voogd met het voogdnummer " + str(code))
path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-appointments.html')
self.response.out.write(template.render(path, template_values))
return
# days = []
# for appointment in appointments:
# found = False
# for day in days:
# if day.key().id() == appointment.day.key().id():
# found = True
# break
# if not found:
# days.append(appointment.day)
#
# days_appointments = []
# for day in days:
# appointments_in_day = []
# for appointment in appointments:
# if appointment.day.key().id() == day.key().id():
# appointments_in_day.append(appointment)
#
# days_appointments.append([day, appointments_in_day])
#
# days_tables_appointments = []
# for day_appointments in days_appointments:
# tables = []
# for appointment in day_appointments[1]:
# if appointment.table not in tables:
# tables.append(int(appointment.table))
#
# day_tables = []
# for table in tables:
# table_appointments = []
# for appointment in day_appointments[1]:
# if int(appointment.table) == table:
# table_appointments.append(appointment)
# day_tables.append([table, table_appointments])
# days_tables_appointments.append([day_appointments[0], day_tables])
#
# day_tables_slots = []
# for day_tables_appointments in days_tables_appointments:
# for table_appointments in day_tables_appointments[1]:
# table_slots = []
# for slot in range(1, day_tables_appointments[0].talks+1):
# added = False
# for appointment in table_appointments[1]:
# if(int(appointment.slot) == slot):
# added = True
# table_slots.append(appointment)
# if not added:
# table_slots.append(1)
# day_tables_slots.append([day_tables_appointments[0], [table_appointments[0], table_slots]])
elif method == 'teacher':
teacher = Teacher.get_by_key_name(code.upper())
if not teacher:
notifications.append('Er is geen docent gevonden met de opgegeven docentcode.')
if teacher:
subjects = teacher.subjects.fetch(999)
requests = []
for subject in subjects:
reqs = subject.requests.fetch(999)
for req in reqs:
requests.append(req)
appointments = [request.appointment.get() for request in requests if request.appointment.get()]
if not appointments:
notifications.append("Er zijn geen afspraken gevonden voor de docent met docentcode " + str(code))
path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-appointments.html')
self.response.out.write(template.render(path, template_values))
