def register(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
new_enrollments = {}
course = Courses.get(id=str(request.POST['course_id']))
for x in request.POST:
role_match = re.match(r'^role_(\d+)$', x)
role_type_match = re.match(r'^role_type_(\d+)$', x)
if role_match:
student_id = role_match.groups()[0]
if student_id not in new_enrollments:
new_enrollments[student_id] = {}
new_enrollments[student_id]['role'] = request.POST[x]
elif role_type_match:
student_id = role_type_match.groups()[0]
if student_id not in new_enrollments:
new_enrollments[student_id] = {}
new_enrollments[student_id]['role_type'] = request.POST[x]
for x in new_enrollments:
student = Students.fetch(id=int(x))
Enrollments.create(student=student,
course=course,
role=new_enrollments[x]['role'],
role_type=new_enrollments[x]['role_type'],
status=request.POST['status'])
return redirect('/reports/students/2016/')
def roster(request, id):
course = Courses.fetch(id=id)
bad = restricted(request, 1)
if bad:
return bad
context = {'course': course}
return render(request, 'reports/rowspan_roster.html', context)
def show(request, **kwargs):
bad = restricted(request, 1)
if bad:
return bad
policy = Policies.fetch(year=kwargs.get('year'))
context = {'policy': policy}
return render(request, 'radmin/policy/show.html', context)
def sudochangepassword(request, **kwargs):
both = getme(request, both=True)
if 'them_id' in kwargs:
them = Users.fetch(id=kwargs['them_id'])
else:
them = both['sudo']
me = both['login']
if not me:
return redirect('/')
bad = restricted(request,6,them,allow_sudo=True)
if bad:
return bad
user = copy(request.POST,['password','pw_confm'])
valid = Users.isValid(user, partial=True)
if not valid:
request.session['e'] = Users.errors(user, partial=True)
correct = me.password(request.POST['current_pw'])
if not correct:
request.session['e']['current_pw'] = "Your password is incorrect"
if correct and valid:
if not them:
return HttpResponse('User not found.', status=404)
request.session['e'] = {}
them.password = str(request.POST['password'])
them.save()
return redirect(request.META['HTTP_REFERER'])
def create(request, model, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
if 'foreign_model' in kwargs:
old_model = model
model = str(kwargs['foreign_model'])
else:
old_model = None
manager = MODELS[model]
thing = {}
for ftp in FIELDS[model]:
template = ftp['template']
field = ftp['field']
value = request.POST[
field] if field in request.POST else template.default
thing = template.set(thing, field, request.POST, False)
thing = manager.create(**thing)
if old_model:
old = MODELS[old_model].fetch(id=kwargs['id'])
if old and hasattr(old, model):
old.__setattr__(model, thing)
old.save()
return redirect(
'/rest/show/{}/{}/'.format(old_model, kwargs['id']) if old_model else
'/rest/show/{}/{}/'.format(thing.rest_model, thing.id))
def delete(request, model, id):
bad = restricted(request, 5)
if bad:
return bad
manager = MODELS[model]
thing = manager.get(id=id)
thing.delete()
return redirect('/rest/')
def audition_menu(request, **kwargs):
bad = restricted(request,4)
if bad:
return bad
context = {
'courses' : Courses.filter(enrollment__status__in=["aud_pend","pendpass","pendfail"]).distinct()
}
return render(request, 'audition_menu.html', context)
def delete(request, model, old_id, new_id):
bad = restricted(request, 6)
if bad:
return bad
else:
manager = MODELS[model]
old = manager.get(id=old_id)
old.delete()
return redirect('/rest/show/{}/{}/'.format(model, new_id))
def index(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
context = {
'courses': Courses.filter(year=getyear()).order_by('tradition__order'),
'year': getyear(),
}
return render(request, 'reports/index.html', context)
def show_or_edit(request, model, id, isEdit):
manager = MODELS[model]
thing = manager.get(id=id)
bad = restricted(request, 5) if isEdit else restricted(
request, 4, thing, 1)
if bad:
return bad
method = request.GET.get('method')
if method:
call = thing.__getattribute__(method)
if hasattr(call, '__call__'):
call()
return redirect('/rest/{}/{}/{}/'.format('edit' if isEdit else 'show',
model, id))
tempset = FIELDS[model]
display = []
for ftp in tempset:
field = ftp['field']
value = thing.__getattribute__(field)
value = value if value else ''
template = ftp['template']
if isEdit:
value = template.widget(field, value)
else:
value = template.static(field, value)
if value == None:
value = ''
display.append({
'field':
template.field
if hasattr(template, 'field') and template.field else field,
'input':
value
})
context = {
'thing': thing,
'display': display,
'model': model,
'Model': sub(model, {
'coursetrad': 'Course Tradition'
}).title()
}
return render(request, 'rest/edit.html' if isEdit else 'rest/show.html',
context)
def bib(request, **kwargs):
bad = restricted(request,5)
if bad:
return bad
if request.method == 'GET':
return new(request, **kwargs)
elif request.method == 'POST':
return create(request, **kwargs)
else:
return HttpResponse("Unrecognized HTTP Verb")
def load(request):
bad = restricted(request,6)
if bad and len(Users.all()):
return bad
if request.method == 'GET':
return load_get(request)
elif request.method == 'POST':
return load_post(request)
else:
return HttpResponse("Unrecognized HTTP Verb")
def refresh_summary(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
kwargs.setdefault('year', getyear())
for course in Courses.filter(year__in=[kwargs['year'], kwargs['year'] - 1],
tradition__action='trig'):
for student in Students.filter(enrollment__course=course):
course.trig(student)
return redirect('/reports/summary/')
def summary(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
kwargs.setdefault('year', getyear())
context = {
'year': Year(int(kwargs['year'])),
'prev': Year(int(kwargs['year']) - 1),
'date': datetime.datetime.now(),
}
return render(request, 'reports/summary.html', context)
def update(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
policy = Policies.fetch(year=request.POST.get('year'))
if policy:
policy.markdown = request.POST.get('markdown')
policy.save()
else:
policy = Policies.create(**copy(request.POST, ['year', 'markdown']))
return redirect('/admin/policy/show/{}'.format(policy.year))
def audition_results(request, **kwargs):
course = Courses.fetch(id=kwargs['id'])
bad = restricted(request,5,course,4)
if bad:
return bad
context = {
'course' : course,
'students': Enrollments.filter(course=course,status__in=['aud_pend','pendpass','pendfail']).order_by('student__family__last','student__birthday'),
'me' : getme(request),
}
return render(request, 'audition_results.html', context)
def registration(request, **kwargs):
bad = restricted(request, 1)
if bad:
return bad
year = int(request.GET.copy().setdefault('year', getyear()))
context = {
'year': year,
'now': datetime.datetime.now(),
'sc': Courses.fetch(year=year, tradition=CourseTrads.fetch(id='SC')),
}
context.update(layered_students_and_families(year, enrollments=True))
return render(request, 'reports/registration.html', context)
def historical(request, **kwargs):
bad = restricted(request, 1)
if bad:
return bad
history = []
for year in gethist():
history.append({
'year': year,
'courses': Courses.filter(year=year),
})
context = {'history': history}
return render(request, 'reports/historical.html', context)
def copy(request, model, old_id, new_id):
bad = restricted(request, 5)
if bad:
return bad
field = request.GET.get('field')
manager = MODELS[model]
old = manager.get(id=old_id)
new = manager.get(id=new_id)
new.__setattr__(field, old.__getattribute__(field))
new.save()
return redirect('/rest/merge/{}/{}/{}/'.format(model, old_id, new_id))
def directory(request, **kwargs):
bad = restricted(request, 1)
if bad:
return bad
year = getyear()
# families = Families.filter(children__enrollment__course__year=year).order_by('last').distinct()
families = layered_students_and_families(year)['families']
context = {
'families': families,
'year': year,
}
return render(request, 'reports/directory.html', context)
def index(request, model):
bad = restricted(request)
if bad:
return bad
columns = []
for ftp in FIELDS[model]:
field = ftp['field']
columns.append(field)
query = collect(request.GET, str)
order_by = query.get('order_by')
if order_by:
query.pop('order_by')
limit = query.get('limit')
offset = query.get('offset')
limit = int(limit) if limit else None
offset = int(offset) if offset else None
if limit and offset:
query.pop('limit')
query.pop('offset')
qset = MODELS[model].filter(**query)[offset:offset + limit]
elif limit:
query.pop('limit')
qset = MODELS[model].filter(**query)[:limit]
elif offset:
query.pop('offset')
qset = MODELS[model].filter(**query)[offset:]
else:
qset = MODELS[model].filter(**query)
if order_by:
qset = qset.order_by(order_by)
display = []
for thing in qset:
dthing = [
'<a href="/rest/show/{}/{}">{}</a>'.format(model, thing.id,
thing.id)
]
for ftp in FIELDS[model]:
field = ftp['field']
value = thing.__getattribute__(field)
template = ftp['template']
value = value if value else template.default
dthing.append(template.static(field, value))
display.append(dthing)
context = {
'columns': columns,
'display': display,
'model': model,
'Model': sub(model, {
'coursetrad': 'Course Tradition'
}).title()
}
return render(request, 'rest/index.html', context)
def address(request, **kwargs):
bad = restricted(request, 1)
if bad:
return bad
year = getyear()
context = {
'families':
Families.filter(children__enrollment__course__year=year).order_by(
'last').distinct(),
'year':
year,
}
return render(request, 'reports/addresses.html', context)
def edit(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
year = int(kwargs.get('year') or getyear())
policy = Policies.fetch(year=year)
if not policy:
policy = Policies.fetch(year=year - 1)
context = {
'current': policy.markdown,
'year': year,
}
return render(request, 'radmin/policy/edit.html', context)
def run(request):
bad = restricted(request,7,allow_sudo=True)
if bad:
return bad
me = getme(request)
command = str(request.POST.get('command'))
modified_command = command.replace('log(','log(request,')
request.session['command'] = command
request.session['log'] = []
start = datetime.datetime.now()
exec(modified_command)
request.session['runtime'] = str(datetime.datetime.now()-start)
return redirect('/hot/')
def invoice_index(request, family_id):
family = Families.fetch(id=family_id)
bad = restricted(request, 5, family)
if bad:
return bad
invoices = Invoices.filter(family=family)
context = {
'hist':
collect(
gethist(0), lambda year: {
'year': year,
'invoices': Invoices.filter(year=year, family=family)
})
}
return render(request, 'invoice_index.html', context)
def audition_process(request, **kwargs):
me = getme(request)
course = Courses.fetch(id=kwargs['id'])
bad = restricted(request,5,course,4)
if bad:
return bad
for key in request.POST:
if key.isdigit():
student = Students.fetch(id=int(key))
enrollment = student.enrollments.filter(course=course)[0]
if request.POST[key] == u'accept':
enrollment.accept(me)
if request.POST[key] == u'reject':
enrollment.reject(me)
return redirect('/admin/auditions/')
def sudo_invoice(request, **kwargs):
invoice = Invoices.fetch(id=kwargs.get('id'))
bad = restricted(request,5,standing=invoice)
if bad:
return bad
action = request.GET.get('action')
method = request.GET.get('method')
if invoice and action == 'pay' and method in Each(Invoices.model.method_choices).lower():
invoice.status = 'P'
invoice.method = method
for item in invoice.items:
item.pay()
invoice.save()
print Each(Invoices.model.method_choices).lower()
return redirect('/{ref}/invoice/{id}/'.format(**kwargs))
def update(request, model, id):
bad = restricted(request, 5)
if bad:
return bad
manager = MODELS[model]
thing = manager.get(id=id)
for ftp in FIELDS[model]:
template = ftp['template']
field = ftp['field']
value = request.POST[
field] if field in request.POST else template.default
thing = template.set(thing, field, request.POST, True)
thing.save()
# return redirect("/rest/index/coursetrad?e=True")
return redirect("/rest/show/{}/{}".format(model, thing.id))
def students(request, ref, id):
if restricted(request):
return redirect('/')
elif request.method == 'GET':
if id == 'new':
return students_new(request, ref)
else:
return students_edit(request, ref, id)
elif request.method == 'POST':
if id == 'new':
return students_create(request, ref)
else:
return students_update(request, ref, id)
else:
print "Unrecognized HTTP Verb"
return index(request, ref)
def records(request, model, old_id, new_id):
bad = restricted(request, 5)
if bad:
return bad
manager = MODELS[model]
old = manager.get(id=old_id)
new = manager.get(id=new_id)
tempset = FIELDS[model]
display = []
for ftp in tempset:
field = ftp['field']
template = ftp['template']
old_value = old.__getattribute__(field)
old_value = old_value if old_value else ''
old_value = template.static(field, old_value)
if old_value == None:
old_value = ''
new_value = new.__getattribute__(field)
new_value = new_value if new_value else ''
new_value = template.static(field, new_value)
if new_value == None:
new_value = ''
display.append({
'field':
template.field if template.field else field,
'old':
old_value,
'new':
new_value,
'merge':
template.merge(old, new) if hasattr(template, 'merge') else ''
})
context = {
'old': old,
'new': new,
'display': display,
'model': model,
'Model': substitute(model, {
'coursetrad': 'Course Tradition'
}).title()
}
return render(request, 'rest/merge.html', context)
