def gradeResult(request):
render = {}
grade = get_object_or_404(Grade, id = request.POST.get('grade'))
resultdate = get_object_or_404(ResultDate, id = request.POST.get('resultdate'))
render['grade'] = grade.id
render['resultdate'] = resultdate.id
if grade in request.user.grades.all():
if not request.POST.get('send'):
pupils = Pupil.objects.filter(grade = grade)
results = []
from math import pow
for pupil in pupils:
try:
result = Result.objects.get(resultdate = resultdate, pupil = pupil, subject = request.user.current_subject)
form = ResultForm(prefix = pupil.id, instance = result)
except ObjectDoesNotExist:
form = ResultForm(prefix = pupil.id)
sum = 0
marks = Mark.objects.filter(lesson__date__range = (resultdate.startdate, resultdate.enddate),
pupil = pupil,
lesson__subject = request.user.current_subject)
for mark in marks:
if mark.mark:
sum += mark.mark
if marks.__len__()<>0 and sum<>0:
sa = round(float(sum)/float(marks.__len__()), 3)
else:
sa = 0
results.append({'name': pupil.fi(), 'form': form, 'sa': sa})
render['pupils'] = results
return render_to_response('marks/teacher/gradeResult.html', render, context_instance = RequestContext(request))
else:
error = 0
for pupil in Pupil.objects.filter(grade = grade):
if request.POST.get('%d-mark' % pupil.id):
form = ResultForm(request.POST, prefix = pupil.id)
if form.is_valid():
try:
result = Result.objects.get(pupil = Pupil.objects.get(id = pupil.id),
resultdate = resultdate, subject = request.user.current_subject)
except ObjectDoesNotExist:
result = Result()
result.pupil = pupil
result.resultdate = resultdate
result.mark = form.cleaned_data['mark']
result.subject = request.user.current_subject
result.save()
else:
error = 1
if error == 0:
return HttpResponseRedirect('/marks/result/')
else:
results = []
pupils = Pupil.objects.filter(grade = grade)
for pupil in pupils:
results.append({'name': pupil.fi(), 'form': ResultForm(request.POST, prefix = pupil.id)})
render['pupils'] = results
return render_to_response('marks/teacher/gradeResult.html', render, context_instance = RequestContext(request))
else:
return Http404
def add_result():
all_p = Player.query.order_by(Player.name.asc()).all()
names = names_schema.dump(all_p)
n_list = list(names.data)
n_list.insert(0, {"name": " "})
form = ResultForm(n_list)
if form.validate_on_submit():
if request.form["username"] == request.form["p2_name"]:
return redirect("/add-match")
p = Player.query.filter_by(
name=request.form["username"]).first_or_404()
if p.verify_password(request.form["password"]):
new_match = Match(
request.form["username"],
request.form["p2_name"],
request.form["p1_score"],
request.form["p2_score"],
)
new_match.status = "pending"
db.session.add(new_match)
db.session.commit()
return redirect("/add-match")
else:
return jsonify(data="Incorrect Password", status_code=401)
return render_template("add-result.html",
title="Add Match Result",
form=form)
def callback():
form = ResultForm(request.args)
if form.validate():
print(form.number.data)
return {'success': True, 'errors': {}}
return {'success': False, 'errors': form.errors}
def edit_result(id):
result = Result.query.get_or_404(id)
form = ResultForm(obj=result)
if form.validate_on_submit():
form.populate_obj(result)
db.session.commit()
else:
print form, form.errors
print form.last_name.data
return render_template("edit.html", result=form, id=id)
def card_edit(card_id):
if can_user_edit_card(current_user, card_id):
form = ResultForm(obj=Result.query.get_or_404(card_id))
if form.validate_on_submit():
form.populate_obj(Result.query.get_or_404(card_id))
db.session.commit()
return redirect(url_for('profile_show', id=current_user.id))
else:
print form.errors
return render_template("card_edit.html", result=form, id=card_id)
return redirect(url_for('start_page'))
def get(self, request, request_result_id):
'''
Method for getting a Result based on the id provided.
'''
params = dict((key, val) for key, val in request.QUERY_PARAMS.iteritems())
params['request_result_id'] = request_result_id
form = ResultForm(params)
if not form.is_valid():
raise BadRequestException()
return Response(form.submit(request))
def card_create():
form = ResultForm()
if form.validate_on_submit():
form.user_id.data = current_user.id
result = Result()
form.populate_obj(result)
db.session.add(result)
db.session.commit()
return redirect(url_for('profile_show', id=current_user.id))
else:
print form.errors
return render_template('add_card.html', form=form)
def get(self, request, request_result_id):
'''
Method for getting a Result based on the id provided.
'''
params = dict(
(key, val) for key, val in request.QUERY_PARAMS.iteritems())
params['request_result_id'] = request_result_id
form = ResultForm(params)
if not form.is_valid():
raise BadRequestException()
return Response(form.submit(request))
def add_result():
form = ResultForm()
if form.validate_on_submit():
p = Player.query.filter_by(name=request.form["username"]).first_or_404()
if p.verify_password(request.form["password"]):
new_match = Match(
request.form["username"],
request.form["p2_name"],
request.form["p1_score"],
request.form["p2_score"],
)
new_match.status = "pending"
db.session.add(new_match)
db.session.commit()
return redirect("/rankings")
else:
return jsonify("Authentication error", status_code=401)
return render_template("add-result.html", title="Add Match Result", form=form)
def show_result(request, url, sha1sum):
"""Show the result page - execute commands for the downloaded file."""
form = ResultForm(request.POST or None)
status = ""
redirect = False
if form.is_valid() and 'command' in request.POST:
# Result form was submitted
command = request.POST['command']
if command == 'SHA1':
# Validate SHA1 sum, output result
if validate_sha1(url, sha1sum):
status = "SHA1-summen er gyldig!"
else:
status = "SHA1-summen er IKKE gyldig, filen er korrumperet."
if command == 'ACK':
# Acknowledge receipt of document
acknowledge_document(url)
status = "Dokumentet er afsluttet, stiller tilbage ..."
redirect = True
else:
# No ack or sha1 command submitted, just render
# result page.
"""
We fetch an example image if such exists.
"""
print "POST: " + str(request.POST)
"""
image = get_thumbnail_image(request.POST['template'])
if image != "":
image = TEMPLATE_URL + image
else:
image = "media/files/styling/trans.gif"
"""
return render_to_response('new_result_page.html', {
'url': url,
'sha1sum': sha1sum,
'status': status,
'form': form,
'redirect': redirect,
'broker_url': BROKER_BASE_URL
},
context_instance=RequestContext(request))
def post(self, request, debateid):
form = ResultForm(request.POST)
if form.is_valid():
result = Debate.objects.get(id=debateid).result
print form.cleaned_data
result.ogsp1 = form.cleaned_data['ogsp1']
result.ogsp2 = form.cleaned_data['ogsp2']
result.oosp1 = form.cleaned_data['oosp1']
result.oosp2 = form.cleaned_data['oosp1']
result.cgsp1 = form.cleaned_data['cgsp1']
result.cgsp2 = form.cleaned_data['cgsp2']
result.cosp1 = form.cleaned_data['cosp1']
result.cosp2 = form.cleaned_data['cosp2']
result.add_positions_from_speaks()
else:
return HttpResponseBadRequest()
result.full_clean()
result.save()
return HttpResponse(result.id)
def get_results():
try:
result_form = ResultForm()
reset_form = ResetButtons()
plot_url = None
code = request.args.get('code', '')
if request.method == 'POST':
if reset_form.submit.data:
return redirect(url_for('home'))
elif reset_form.reset_all.data:
shutil.rmtree(results_dir)
shutil.rmtree(model_path_dir)
shutil.rmtree(test_path_dir)
shutil.rmtree(train_path_dir)
os.makedirs(results_dir)
os.makedirs(model_path_dir)
os.makedirs(test_path_dir)
os.makedirs(train_path_dir)
return redirect(url_for('home'))
elif result_form.download_plot.data:
if GlobalFlags.is_recently_tested:
return send_file(results_plot_test_path, mimetype='image/png', as_attachment=True)
else:
return send_file(results_plot_train_path, mimetype='image/png', as_attachment=True)
elif result_form.download_pred.data:
return send_file(results_pred_path, mimetype='text/csv', as_attachment=True)
elif result_form.download_info.data:
return send_file(results_info_path, mimetype='application/json', as_attachment=True)
elif result_form.download_test.data:
return send_file(results_test_path, mimetype='text/csv', as_attachment=True)
elif result_form.download_train.data:
return send_file(results_train_path, mimetype='text/csv', as_attachment=True)
if ((code == '0' or code == '1') and GlobalFlags.is_recently_trained) or \
(code == '2' and GlobalFlags.is_recently_tested):
train_loss, test_loss, full_info = get_losses_info(results_train_path, results_test_path, results_info_path)
with open(model_path, 'r', encoding='utf-8') as model_file:
model_json = json.load(model_file)
full_info.update(model_json)
if GlobalFlags.is_recently_trained:
best_iter, best_train_loss = get_best_by_train(train_loss)
result_form.train_loss.data = str(best_train_loss)
full_info['best_train_by_train'] = best_train_loss
full_info['best_iter_by_train'] = int(best_iter + 1)
full_info.pop('best_test_loss_by_test', None)
full_info.pop('best_train_loss_by_test', None)
full_info.pop('best_iter_by_test', None)
plot_url = get_plot(train_loss, [], results_plot_train_path)
if GlobalFlags.is_recently_tested:
best_iter, best_test_loss, best_train_loss = get_best_by_test(train_loss, test_loss)
result_form.train_loss.data = str(best_train_loss)
result_form.test_loss.data = str(best_test_loss)
full_info['best_test_loss_by_test'] = best_test_loss
full_info['best_train_loss_by_test'] = best_train_loss
full_info['best_iter_by_test'] = int(best_iter + 1)
plot_url = get_plot(train_loss, test_loss, results_plot_test_path)
with open(results_info_path, 'w') as info_file:
json.dump(full_info, info_file)
elif not GlobalFlags.no_f5:
if code == '1':
GlobalFlags.no_f5 = True
thread = Thread()
thread.train(data_paths['train'], model_path, model_dumped_path, results_dir,
results_train_path, results_info_path, GlobalFlags)
elif code == '2':
GlobalFlags.no_f5 = True
thread = Thread()
thread.test(data_paths['test'], model_dumped_path, results_dir,
results_test_path, results_pred_path, results_info_path, GlobalFlags)
return render_template('results.html', result_form=result_form, reset_form=reset_form,
global_flags=GlobalFlags, plot_url=plot_url)
except Exception as exc:
app.logger.info('Exception: {0}'.format(exc))
def start_page():
form = ResultForm()
if current_user.is_authenticated:
print "AUTHED", current_user, current_user.id
return render_template("index.html", form=form)
def show_full_card_info(card_id):
form = ResultForm(obj=Result.query.get_or_404(card_id))
return render_template("card_profile.html", card=form)
def showResults(date):
form = ResultForm(request.form)
form.dates.choices = [(k, v) for k, v in measurementDates]
# define the names for the graphics of the selected date
imageNames = {
'lanet_v4': date + '_edgelist_v4.png',
'lanet_v6': date + '_edgelist_v6.png',
'degree_v4': date + '_degree_distribution_v4.png',
'degree_v6': date + '_degree_distribution_v6.png',
'avg_neighbor_v4': date + '_avg_neighbor_v4.png',
'avg_neighbor_v6': date + '_avg_neighbor_v6.png',
'cluster_v4': date + '_cluster_v4.png',
'cluster_v6': date + '_cluster_v6.png',
'heatmap_v4': date + '_heatmap_v4.png',
'heatmap_v6': date + '_heatmap_v6.png'
}
try:
form.dlScript.data = session['dlScript']
except KeyError:
print('no saved value for dlScript found')
if form.validate_on_submit() and form.changeDate.data:
print('here')
return redirect(url_for('showResults', date=form.dates.data))
elif form.validate_on_submit() and form.download.data:
# create temporary dir for the .json-files
os.makedirs('downloads/files/')
# create .json-files to download depending on input
if request.form['dlMsmIds'] == 'yes':
getMeasurementIds(tracerouteColl, date)
if request.form['dlLanet'] == 'yes':
getDlImg(imageNames['lanet_v4'])
getDlImg(imageNames['lanet_v6'])
if request.form['dlDegree'] == 'yes':
getDlImg(imageNames['degree_v4'])
getDlImg(imageNames['degree_v6'])
if request.form['dlNeighbor'] == 'yes':
getDlImg(imageNames['avg_neighbor_v4'])
getDlImg(imageNames['avg_neighbor_v6'])
if request.form['dlCluster'] == 'yes':
getDlImg(imageNames['cluster_v4'])
getDlImg(imageNames['cluster_v6'])
if request.form['dlHeatmaps'] == 'yes':
getDlImg(imageNames['heatmap_v4'])
getDlImg(imageNames['heatmap_v6'])
if request.form['dlAsns'] == 'yes':
getDlData(asnColl, date)
if request.form['dlProbes'] == 'yes':
getDlData(probeColl, date)
if request.form['dlEdges'] == 'yes':
getDlData(edgeColl, date)
if request.form['dlPaths'] == 'yes':
try:
shutil.copy('paths/' + date + '_paths_v4.csv',
'downloads/files/')
except Exception:
print('No IPv4 Paths found')
try:
shutil.copy('paths/' + date + '_paths_v6.csv',
'downloads/files/')
except Exception:
print('No IPv6 Paths found')
# write .json-files into zipfile and make it accesible for Respone()
data = io.BytesIO()
with zipfile.ZipFile(data, 'w') as z:
for file in os.listdir('downloads/files/'):
z.write('downloads/files/' + file)
# add dlScript, if selected
if request.form['dlScript'] == 'yes':
for file in os.listdir('downloads/'):
z.write('downloads/' + file)
data.seek(0)
# delete the directory
shutil.rmtree('downloads/files/')
# save the dlScript value into the session
session['dlScript'] = request.form['dlScript']
# return the zip-File as a Download
return Response(data,
mimetype='application/zip',
headers={
'Content-Disposition':
'attachment;filename=%smeasurementData.zip' % date
})
return render_template('results.html',
form=form,
**imageNames,
date=datetime.strptime(
date, '%Y%m%d').strftime("%d %b %Y"))
