def event_edit_entry(event_id, song_id):
evt = database.Event(event_id)
if evt.are_submissions_open:
pwform = SongPasswordForm()
if pwform.validate_on_submit():
form = SubmitForm()
song = database.get_song_by_token_and_id(pwform.token.data, song_id)
if song:
form.bga_author.default = song.bga_author
form.bms_author.default = song.author
form.bms_email.default = song.email
form.bms_link.default = song.link
form.bms_name.default = song.name
form.description.default = song.description
form.fake_author.default = song.fake_author
form.token.default = song.token # token is valid anyway
form.process() # actually set the defaults
# okay we're set, modification in progress
return render_template("submit.html", event=evt, form=form, modify=True, song=song)
else:
# logging.error("Null song.")
return render_template("section_closed.html", event=evt)
else:
# logging.error("Null form.")
return render_template("section_closed.html", event=evt)
else:
# Invalid event?
return render_template("section_closed.html", event=evt)
def preset_submit(request):
if request.method == "POST":
form = SubmitForm(request.POST, request.FILES)
if form.is_valid():
preset = request.FILES["preset_file"]
message = EmailMessage(**{
"subject": "[Arista] Preset for %s" % preset.name[:-8],
"body": "A user has uploaded a new preset!",
"from_email": form.cleaned_data["email"],
"to": [x[1] for x in settings.ADMINS],
"attachments": [
(preset.name, preset.read(), "application/x-bzip-compressed-tar"),
],
})
message.send()
return HttpResponseRedirect("/presets/?thanks=1")
else:
form = SubmitForm()
return render(request, "presets/submit.html", {
"form": form,
})
def addparameter_response(model_id, interface_id):
if not session.get("logged_in"):
return redirect(url_for("login"))
add_parameter_response = ParameterResponseForm()
submit = SubmitForm()
if submit.validate_on_submit():
add = Parameter(interface_id=interface_id,
parameter_type=20,
parameter_group_id=add_parameter_response.parameter_group_id.data,
parameter_name=add_parameter_response.parameter_name.data,
necessary=add_parameter_response.necessary.data,
type=add_parameter_response.type.data,
default=add_parameter_response.default.data,
remark=add_parameter_response.remark.data,
level=add_parameter_response.level.data)
db.session.add(add)
db.session.commit()
return redirect(url_for("parameter_response",
model_id=model_id,
interface_id=interface_id))
return render_template("addparameter_response.html",
add_parameter_response=add_parameter_response,
model_id=model_id,
interface_id=interface_id,
submit=submit)
def index():
form = SubmitForm()
# if form was submitted, do the following
if form.validate_on_submit():
data = {}
data["callsign"] = form.callsign.data
data["weight"] = form.weight.data
data["parachute"] = form.parachute.data
data["balloon"] = form.balloon.data
data["helium"] = form.helium.data
host = "127.0.0.1"
port = 50001
sock = socket.socket()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.connect((host,port))
sock.send(json.dumps(['start_real_time', data]))
msg = sock.recv(1028)
print(msg)
sock.close()
return redirect('http://127.0.0.1:5000/map/{0}.html'.format(data["callsign"]))
return render_template('submit.html',
title='Home',
form=form)
def editparameter_response(model_id, interface_id, parameter_id):
if not session.get("logged_in"):
return redirect(url_for("login"))
parameter_response_one = Parameter.query.filter_by(parameter_id=parameter_id).first()
edit_parameter_response = ParameterResponseForm()
submit = SubmitForm()
if submit.validate_on_submit():
parameter_response_one.parameter_name = edit_parameter_response.parameter_name.data
parameter_response_one.necessary = edit_parameter_response.necessary.data
parameter_response_one.type = edit_parameter_response.type.data
parameter_response_one.default = edit_parameter_response.default.data
parameter_response_one.remark = edit_parameter_response.remark.data
parameter_response_one.parameter_group_id = edit_parameter_response.parameter_group_id.data
parameter_response_one.level = edit_parameter_response.level.data
db.session.commit()
return redirect(url_for("parameter_response",
model_id=model_id,
interface_id=interface_id))
edit_parameter_response.parameter_name.data = parameter_response_one.parameter_name
edit_parameter_response.necessary.data = parameter_response_one.necessary
edit_parameter_response.type.data = parameter_response_one.type
edit_parameter_response.default.data = parameter_response_one.default
edit_parameter_response.remark.data = parameter_response_one.remark
edit_parameter_response.parameter_group_id.data = parameter_response_one.parameter_group_id
edit_parameter_response.level.data = parameter_response_one.level
return render_template("editparameter_response.html",
model_id=model_id,
interface_id=interface_id,
parameter_id=parameter_id,
edit_parameter_response=edit_parameter_response,
submit=submit)
def submit():
global trainer
form = SubmitForm()
if request.method == 'POST':
if form.validate() == False:
flash('All fields are required.')
return render_template('submit.html', form=form)
else:
trainingdata = ''
if form.dataFile.data:
trainingdata += request.files[form.dataFile.name].read()
if form.trainingData.data:
trainingdata += form.trainingData.data
if trainingdata:
timestampes = parseJson(trainingdata)
img1, img2, metrics = trainer.train(timestampes)
return render_template('submit.html',
success=True,
img1=img1,
img2=img2,
metrics=metrics)
elif request.method == 'GET':
return render_template('submit.html', form=form)
def contact():
form = SubmitForm(request.form)
contact = ContactAdmin(request.form)
if contact.validate_on_submit():
flash(
Markup("<strong>Thank you!</strong> Your message has been sent."))
msg = Messages(timestamp=dt.utcnow(),
email=contact.email.data,
msg=contact.msg.data)
db.session.add_all([msg])
db.session.commit()
return redirect(url_for('contact'))
if form.validate_on_submit():
flash(
Markup(
"<strong>Success!</strong> Thank you for submitting a resource. Your post is being reviewed."
))
post = Posts(post_title=form.post_title.data,
email=form.email.data,
description=form.description.data,
post_type=form.post_type_submit.data,
link=form.link.data,
ph_num=form.ph_num.data,
timestamp=dt.utcnow())
db.session.add_all([post])
db.session.commit()
return redirect(url_for('contact'))
return render_template('contact.html', contact=contact, form=form)
# @app.route('/api',methods=['GET'])
# def api():
# return jsonify(Posts.query.order_by(Posts.timestamp.desc()).all().to_dict())
def index():
form = SubmitForm()
q = Complaint()
if request.mimetype == "application/json" and request.method == "POST":
code, message = json_handler(request.json, q, db)
return jsonify(message), code, {"content-type": "application/json"}
if request.method == "GET":
return render_template("index.html", form=form)
if form.validate_on_submit():
print(form.validate())
print("It is working.")
q.lat = form.lat.data
q.long = form.long.data
# q.accuracy = form.accuracy.data
q.short_describtion = form.short_describtion.data
q.long_describtion = form.long_describtion.data
db.session.add(q)
db.session.commit()
flash("Thank you so much for your submission!")
address = get_address(form.lat.data, form.long.data)
else:
print("Where to f**k i f****d up.")
for error in form.errors.items():
flash(error)
return render_template("index.html", form=form, address=address)
def submit(request, game_type):
game = get_object_or_404(Game, slug=game_type)
ParticipantFormSet = formset_factory(ParticipantForm,
formset=RequiredFormSet,
max_num=game.players_per_side,
extra=game.players_per_side)
if request.method == 'POST':
form = SubmitForm(request.POST)
formset = ParticipantFormSet(request.POST)
if form.is_valid() and formset.is_valid():
# Get all the uids given
uid_set = set([ u.id for u in chain.from_iterable([ d.cleaned_data.values() for d in [ f for f in formset.forms ] ])])
if len(uid_set) != game.players_per_side * 2:
# FIXME This may not be the right way to handle this, but at least
# it doesn't try to save something wrong.
raise forms.ValidationError("Cannot repeat participants.")
match = form.save(request, game)
[ f.save(match) for f in formset.forms ]
compute_rankings_for_match(match)
return HttpResponseRedirect(game.get_absolute_url())
else:
form = SubmitForm()
formset = ParticipantFormSet()
return render(request, 'match/submit.html', {
'form': form, 'formset': formset
})
def submit(request, game_type):
# XXX Set this as part of the url
try:
game = Game.objects.get(slug=game_type)
except Game.DoesNotExist:
game = Game.objects.create(slug="pingpong", name="Ping Pong", require_results=True)
ParticipantFormSet = formset_factory(
ParticipantForm, formset=RequiredFormSet, max_num=game.players_per_side, extra=game.players_per_side
)
if request.method == "POST":
form = SubmitForm(request.POST)
formset = ParticipantFormSet(request.POST)
if form.is_valid() and formset.is_valid():
# Get all the uids given
uid_set = set(
[u.id for u in chain.from_iterable([d.cleaned_data.values() for d in [f for f in formset.forms]])]
)
if len(uid_set) != game.players_per_side * 2:
# FIXME This may not be the right way to handle this, but at least
# it doesn't try to save something wrong.
raise forms.ValidationError("Cannot repeat participants.")
match = form.save(request, game)
[f.save(match) for f in formset.forms]
compute_rankings_for_match(match)
return HttpResponseRedirect("/")
else:
form = SubmitForm()
formset = ParticipantFormSet()
return render(request, "match/submit.html", {"form": form, "formset": formset})
def editinterface(model_id, interface_id):
if not session.get("logged_in"):
return redirect(url_for("login"))
interface_model_one = Interface.query.filter_by(interface_id=interface_id).first()
edit_interface_model = InterfaceForm()
submit = SubmitForm()
if submit.validate_on_submit():
interface_model_one.interface_name = edit_interface_model.interface_name.data
interface_model_one.interface_url = edit_interface_model.interface_url.data
interface_model_one.interface_method = edit_interface_model.interface_method.data
interface_model_one.request_exam = edit_interface_model.request_exam.data
interface_model_one.response_exam = edit_interface_model.response_exam.data
db.session.commit()
return redirect(url_for("interface",
model_id=model_id))
edit_interface_model.interface_name.data = interface_model_one.interface_name
edit_interface_model.interface_url.data = interface_model_one.interface_url
edit_interface_model.interface_method.data = interface_model_one.interface_method
edit_interface_model.request_exam.data = interface_model_one.request_exam
edit_interface_model.response_exam.data = interface_model_one.response_exam
return render_template("editinterface.html",
model_id=model_id,
interface_id=interface_id,
edit_interface_model=edit_interface_model,
submit=submit)
def submit(request):
if request.method != 'POST':
raise Http404("use POST")
form = SubmitForm(request.POST, request.FILES)
if not form.is_valid():
return HttpResponseBadRequest(form.errors.as_json())
data = form.cleaned_data
submit_mapping(data['file'])
return HttpResponse(_("import is successful").capitalize())
def submit(request):
if request.method != 'POST':
raise Http404("use POST")
form = SubmitForm(request.POST, request.FILES)
if not form.is_valid():
return HttpResponseBadRequest(form.errors.as_json())
data = form.cleaned_data
submit_mapping(data['file'])
return HttpResponse(_("import is successful").capitalize())
def submit(request):
if request.method == 'POST':
form = SubmitForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/thanks')
else:
form = SubmitForm(initial={'submitter': request.user.id})
return render_to_response('submit.html', { 'form': form }, context_instance=RequestContext(request))
def submit():
form = SubmitForm()
if form.validate_on_submit():
conn = sql.connect('database.db')
conn.execute('INSERT INTO users (username, message) VALUES (?,?)',
(form.username.data, form.message.data))
conn.commit()
conn.close()
return (redirect(url_for('view')))
return render_template('submit.html', form=form)
def submit(request):
if request.method == 'POST':
form = SubmitForm(request.POST)
if form.is_valid():
form.save(request)
return HttpResponseRedirect('/')
else:
form = SubmitForm()
return direct_to_template(request, 'submit.html', {
'form': form
})
def home():
form = SubmitForm()
if form.validate_on_submit():
hp = int(form.horsepower.data)
mpg = int(form.mileage.data)
sit = float(form.seats.data)
cyl = int(form.cylinders.data)
gr = int(form.gears.data)
return setpost(mpg, cyl, hp, gr, sit)
return render_template('home.html', title='Home', form=form)
def submit(): #delete everything in uploads folder
if (os.path.exists(uploadFile)):
os.remove(uploadFile)
form = SubmitForm()
if form.is_submitted():
fileContent = form.inputFile.data
fileName = fileContent.filename
fileContent.save(
uploadFile
) #delete contents of upload file somehow, prob at beginning of this function
return redirect(url_for('display'))
return render_template('submit.html', form=form)
def edit(request, strike_id):
strike = get_object_or_404(Strike, pk=strike_id)
if request.method == 'POST':
form = SubmitForm(request.POST, instance=strike)
if form.is_valid():
form.save()
return HttpResponseRedirect('/submissions')
else:
form = SubmitForm(instance=strike)
return render_to_response('submit.html', { 'form': form }, context_instance=RequestContext(request))
def addmodel():
if not session.get("logged_in"):
return redirect(url_for("login"))
add_model = ModelForm()
submit = SubmitForm()
if submit.validate_on_submit():
add = Model(model_name=add_model.model_name.data)
db.session.add(add)
db.session.commit()
return redirect(url_for("model"))
return render_template("addmodel.html",
add_model=add_model,
submit=submit)
def submit(req):
if req.method == 'GET':
form = SubmitForm()
return render_to_response('problem_submit.html', {
'path': req.path,
'form': form
}, context_instance=RequestContext(req))
if req.method == 'POST':
form = SubmitForm(req.POST)
form.set_user(req.user)
form.set_contest(req.POST.get('contest', -1))
if form.is_valid():
new_submit = form.save()
con = Connect()
receive = con.judge_code(new_submit.id)
logger.info(receive)
logger.info(u"User: "******"s Submited Problem: <" + new_submit.problem.oj + str(
new_submit.problem.problem_id) + u"> Title: " + new_submit.problem.title)
if form.contest_id >= 0:
return HttpResponseRedirect("/contest/c/" + str(form.contest_id)) # + "?status=1"
return HttpResponseRedirect("/status")
else:
return render_to_response("problem_submit.html", {
'path': req.path,
'form': form,
}, context_instance=RequestContext(req))
def editmodel(model_id):
if not session.get("logged_in"):
return redirect(url_for("login"))
model_one = Model.query.filter_by(model_id=model_id).first()
edit_model = ModelForm()
submit = SubmitForm()
if submit.validate_on_submit():
model_one.model_name = edit_model.model_name.data
db.session.commit()
return redirect(url_for("model"))
edit_model.model_name.data = model_one.model_name
return render_template("editmodel.html",
edit_model=edit_model,
submit=submit)
def submit():
# return render_template('submit.html', title='Submit')
form = SubmitForm()
if form.validate_on_submit():
# START DROP DOWN EFFORT HERE
task = Submit(task=form.task.data,
email=form.email.data,
priority=form.priority.data)
db.session.add(task)
db.session.commit()
flash(f'Task for {form.email.data} added.', 'success')
return redirect(url_for('home'))
return render_template('submit.html', form=form)
def doctor():
form = SubmitForm(csrf_enabled=False)
if form.validate_on_submit():
rawlist = []
for item in form:
if item.type == "BooleanField" and item.data == True:
rawlist.append(item.name)
token,query_dict = tr.query_info(rawlist,form.identifier.data)
return render_template('query_result.html',
token= token,
json = json.dumps(query_dict,indent=4))
return render_template('submit.html',
form=form)
def g14_cmd():
form = SubmitForm()
if request.method == 'POST':
output = cmd_Get_Status()
print output
bytelist = [bin(int(output[0].encode("hex"),16)),bin(int(output[1].encode("hex"),16)),bin(int(output[2].encode("hex"),16)),bin(int(output[3].encode("hex"),16)),bin(int(output[4].encode("hex"),16)),bin(int(output[5].encode("hex"),16))]
status_hex = "x"+output[0].encode("hex")+"x"+output[1].encode("hex")+"x"+output[2].encode("hex")+"x"+output[3].encode("hex")+"x"+output[4].encode("hex")+"x"+output[5].encode("hex")
n=0
for byte in bytelist:
bytelist[n] = byte[2:]
x=8-len(byte)
for i in range(x-1):
bytelist[n] = "0"+bytelist[n]
n+=1
print bytelist
bitlist = [[0]*6 for i in range(8)]
x=0
y=0
for byte in bytelist:
for char in byte:
#print x,y
bitlist[x][y]=char
x+=1
y+=1
x=0
print bitlist
return render_template('g14success.html', status = bitlist, statusHex = status_hex)
elif request.method == 'GET':
return render_template('g14CMD.html', form = form)
def event_update_entry(event_id, song_id):
evt = database.Event(event_id)
if evt.are_submissions_open:
form = SubmitForm()
if form.validate_on_submit():
evt.update_entry(form.bms_name.data,
form.bms_author.data,
form.fake_author.data,
form.bga_author.data,
form.description.data,
form.bms_link.data,
form.bms_email.data,
song_id, form.token.data)
return redirect(url_for('event_song_impressions', event_id=event_id, song_id=song_id))
else:
return render_template("section_closed.html", event=evt)
def g15_cmd():
global ts1
form = SubmitForm()
st = datetime.datetime.now().strftime(
"%Y-%m-%d--%H-%M") # exmp: 2018-07-01--16-57
ts = str(st) #.split('.')[0] #eliminise miliseconds
ts11 = "/home/pi/Public/WWWpy/static/images/" + ts + ".jpg"
ts1 = "images/" + ts + ".jpg"
print ts1
filelist = [] # filelist[1]=
for root, dirs, files in os.walk("./static/images", topdown=False):
for name in sorted(files, reverse=True):
filelist.append(name)
print name
if request.method == 'POST':
call([
"fswebcam", "-d", "/dev/video0", "-r", "1280x720", "--top-banner",
ts11
])
return render_template('g15success.html', ts1=ts1, filelist=filelist)
elif request.method == 'GET':
return render_template('g15CMD.html', form=form)
def index():
form = SubmitForm()
if form.validate_on_submit():
try:
session = DBSession()
a = Generate_Board().go(session)
b = 0
session.commit()
except:
session.rollback()
a, b = random.randint(50, 100), 0
finally:
session.close()
return redirect(url_for('choose_mode', a=a, b=b))
return render_template("start.html", form=form)
def submit():
form = SubmitForm()
if form.validate_on_submit():
questiondata = Questions(question=form.question.data,
option1=form.option1.data,
option2=form.option2.data,
option3=form.option3.data,
option4=form.option4.data,
answer=form.answer.data,
creatorid=current_user.id,
category=form.category.data,
difficulty=form.difficulty.data)
db.session.add(questiondata)
db.session.commit()
flash('Your question has been nestled deep within the quizzing engine')
return render_template('submit.html', form=form, users=getStandings())
return render_template('submit.html', form=form, users=getStandings())
def main():
form = SubmitForm(request.form)
if form.validate_on_submit():
flash(
"Success! Thank you for submitting a resource. Your post is being reviewed."
)
post = Posts(post_title=form.post_title.data,
email=form.email.data,
description=form.description.data,
post_type=form.post_type_submit.data,
link=form.link.data,
ph_num=form.ph_num.data,
timestamp=dt.utcnow())
db.session.add_all([post])
db.session.commit()
return redirect(url_for('main'))
data = Posts.query.order_by(Posts.timestamp.desc()).all()
return render_template('main.html', form=form, data=data, choices=choices)
def home():
form = SubmitForm()
hundred = ''
ten = ''
effects = ''
if form.is_submitted():
response = requests.post('http://flask-data:5003/data')
effects = response.json()['result']
return render_template('home.html',
form=form,
hundred=hundred,
ten=ten,
effects=effects)
def g12_cmd():
form = SubmitForm()
if request.method == 'POST':
form_output = cmd_Get_PIB()
return render_template('g12success.html', output=form_output)
elif request.method == 'GET':
return render_template('g12CMD.html', form=form)
def submit():
form = SubmitForm()
if form.validate_on_submit():
questiondata = Questions(
question=form.question.data,
option1=form.option1.data,
option2=form.option2.data,
option3=form.option3.data,
option4=form.option4.data,
answer=form.answer.data,
creatorid=current_user.id,
category=form.category.data,
difficulty=form.difficulty.data
)
db.session.add(questiondata)
db.session.commit()
flash('Your question has been nestled deep within the quizzing engine')
return render_template('submit.html', form=form, users=getStandings())
return render_template('submit.html', form=form, users=getStandings())
def submit(request):
if request.method == 'POST':
form = SubmitForm(request.POST)
if form.is_valid():
form.save(request)
return HttpResponseRedirect('/')
else:
form = SubmitForm()
return direct_to_template(request, 'submit.html', {'form': form})
def S2ward():
id = request.values.get('id')
print id
form = SubmitForm()
if form.is_submitted():
user = User()
user.info['name'] = request.form.get('name',type=str,default=None)
user.info['tel'] = request.form.get('tel',type=str,default=None)
user.info['oidname'] = request.form.get('oidname',type=str,default=None)
user.info['add'] = request.form.get('add',type=str,default=None)
print user.info
return render_template('/result.html')
#user = User()
#user.info['name'] = request.form.get('name',type=str,default=None)
#user.info['tel'] = request.form.get('tel',type=str,default=None)
#user.oidname = form.oidname.date
#user.add = form.add.date
flash('thaks')
return render_template('S2ward.html',form=form)
def home():
form = SubmitForm(request.form)
options = Options()
if request.form:
if form.validate_on_submit():
return render_template('home.html',
title="Home",
form=SubmitForm(),
prediksjon=predict(form),
options=options)
else:
return render_template('home.html',
title="Home",
form=form,
invalid=True,
options=options)
return render_template('home.html',
title="Home",
form=form,
options=options)
def addinterface(model_id):
if not session.get("logged_in"):
return redirect(url_for("login"))
add_interface = InterfaceForm()
submit = SubmitForm()
if submit.validate_on_submit():
add = Interface(interface_name=add_interface.interface_name.data,
model_id=model_id,
interface_url=add_interface.interface_url.data,
interface_method=add_interface.interface_method.data,
request_exam=add_interface.request_exam.data,
response_exam=add_interface.response_exam.data)
db.session.add(add)
db.session.commit()
return redirect(url_for("interface",
model_id=model_id))
return render_template("addinterface.html",
add_interface=add_interface,
model_id=model_id,
submit=submit)
def submit():
form = SubmitForm(request.form)
if request.method == 'POST':
if not form.validate():
return render_template('submit.html', form=form, user=get_user())
else:
# save new post
u = get_user()
p = Post()
p.name = form.post_name.data
p.body = form.post_body.data
p.clndr_datetime = form.clndr_datetime.data
p.user_id = u.id
p.timestamp = datetime.datetime.utcnow()
db.session.add(p)
db.session.commit()
msg = "post successfully added."
return render_template('submit.html', form=form, user=u, msg=msg, post=p)
else:
return render_template('submit.html', form=form, user=get_user())
def submit(request, game_type):
game = get_object_or_404(Game, slug=game_type)
ParticipantFormSet = formset_factory(ParticipantForm,
formset=RequiredFormSet,
max_num=game.players_per_side,
extra=game.players_per_side)
if request.method == 'POST':
form = SubmitForm(request.POST)
formset = ParticipantFormSet(request.POST)
if form.is_valid() and formset.is_valid():
# Get all the uids given
uid_set = set([
u.id for u in chain.from_iterable([
d.cleaned_data.values()
for d in [f for f in formset.forms]
])
])
if len(uid_set) != game.players_per_side * 2:
# FIXME This may not be the right way to handle this, but at least
# it doesn't try to save something wrong.
raise forms.ValidationError("Cannot repeat participants.")
match = form.save(request, game)
[f.save(match) for f in formset.forms]
compute_rankings_for_match(match)
return HttpResponseRedirect(game.get_absolute_url())
else:
form = SubmitForm()
formset = ParticipantFormSet()
return render(request, 'match/submit.html', {
'form': form,
'formset': formset
})
def interview(username):
if not User.is_authenticated(username):
flash("You are not authorized to view that page.")
return redirect(url_for('views.profiles'))
user = User.get_user(username)
if request.method == 'GET':
answers = {a.question_id: a.answer for a in user.interview_answers}
return render_template('interview.html',
submit_form=SubmitForm(),
questions=QUESTIONS,
answers=answers)
elif SubmitForm(request.form).validate_on_submit():
for a in user.interview_answers:
db.session.delete(a)
for (q_id, answer) in request.form.iteritems():
answer = answer.strip()
if answer and q_id not in ('csrf', 'submit'):
a = InterviewAnswer(int(q_id), answer, user.id)
db.session.add(a)
db.session.commit()
return redirect(url_for('views.profile', username=username))
def submit(request):
if request.method == 'POST':
form = SubmitForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/thanks')
else:
form = SubmitForm(initial={'submitter': request.user.id})
return render_to_response('submit.html', {'form': form},
context_instance=RequestContext(request))
def event_handle_submission(event_id):
try:
evt = database.Event(event_id)
if evt.are_submissions_open:
form = SubmitForm()
if form.validate_on_submit():
name = form.bms_name.data
author = form.bms_author.data
fake_author = form.fake_author.data
bga_author = form.bga_author.data
description = form.description.data
link = form.bms_link.data
email = form.bms_email.data
token = evt.insert_entry(name,
author,
fake_author,
bga_author,
description,
link,
email)
return render_template("submit_success.html",
name=name,
author=author,
link=link,
event=evt,
token=token,
success=True)
return render_template("submit.html",
form=form,
event=evt,
success=False)
else:
return render_template("section_closed.html", event=evt)
except database.IncorrectEvent as e:
return render_template("section_closed.html", event=None)
def submit():
global next_run_id
form = SubmitForm()
if form.validate_on_submit():
problem_id = int(request.form.get('problem_id', ''))
code = request.form.get('source', '')
language = request.form.get('language', '')
if not os.path.exists(USER_CODE_DIR + current_user.username + '/'):
os.mkdir(USER_CODE_DIR + current_user.username)
with open(USER_CODE_DIR + current_user.username + '/' +
str(next_run_id) + LANGUAGE_IDX2NAME[language][1],
'w',
encoding='utf-8') as f:
f.writelines(code.split('\n'))
attempts[str(next_run_id)] = {
'run_id': next_run_id,
"user_id": current_user.username,
"problem_id": problem_id,
"result": "Judging",
"memory": "***",
"time": "***",
"language": LANGUAGE_IDX2NAME[language][0],
"code_length": str(len(code)) + 'B',
"submit_time": time.strftime('%Y-%m-%d %H:%M:%S')
}
with open(ATTEMPTS_FILE, 'w', encoding='utf-8') as f:
json.dump(attempts, f, indent=4, ensure_ascii=False)
threading.Thread(target=judge, args=[next_run_id]).start()
next_run_id += 1
return redirect(url_for('usr_status', id=current_user.username))
return render_template('submit.html',
form=form,
username=current_user.username,
problem_id=request.args.get('id'))
def submit():
global trainer
form = SubmitForm()
if request.method == 'POST':
if form.validate() == False:
flash('All fields are required.')
return render_template('submit.html', form=form)
else:
trainingdata = ''
if form.dataFile.data :
trainingdata += request.files[form.dataFile.name].read()
if form.trainingData.data :
trainingdata += form.trainingData.data
if trainingdata :
timestampes = parseJson(trainingdata)
img1, img2 = trainer.train(timestampes)
return render_template('submit.html', success=True, img1=img1, img2=img2)
elif request.method == 'GET':
return render_template('submit.html', form=form)
def streaming_intro(request):
"""Renders the home page."""
assert isinstance(request, HttpRequest)
clicked = "Not Submitted"
if request.method == "POST":
form = SubmitForm(request.POST)
if form.is_valid():
clicked = "Submitted"
# post = form.save(commit=False)
print clicked
r = subprocess.call("python ./app/util/load_random.py", shell=True)
print r
# return redirect('/streaming_intro')
return render(request, 'app/streaming_intro.html', {
'title': 'Streaming',
'clicked': clicked,
'form': SubmitForm
})
def edit(request, strike_id):
strike = get_object_or_404(Strike, pk=strike_id)
if request.method == 'POST':
form = SubmitForm(request.POST, instance=strike)
if form.is_valid():
form.save()
return HttpResponseRedirect('/submissions')
else:
form = SubmitForm(instance=strike)
return render_to_response('submit.html', {'form': form},
context_instance=RequestContext(request))
def submit_order(request, orderid):
"""
Change the order status from CLIENT_EDITING to CLIENT_SUBMITTED, and notify waiters.
TODO - error handling, logging,
"""
if request.user.is_staff:
order = WorkingOrder.objects.get(pk=orderid)
else:
order = request.user.workingorder_set.get(id=orderid)
if order.status != BaseOrder.Const.DEALER_EDIT:
return HttpResponseServerError()
# always submit orders in the context of proper account
account = order.owner.get_profile().account
if request.method == "GET":
form = SubmitForm(instance=order)
else:
form = SubmitForm(request.POST, instance=order)
if form.is_valid():
order = form.save(commit=False)
cost = order.cost or decimal.Decimal()
if cost > account.credit_balance:
## users account doesn't have enough juice.. send then to the ecom engine
## to pay, then get them back here ...
order = form.save()
products = [form.cleaned_data["design_product"]]
option = form.cleaned_data.get("processing_option", None)
if option:
products.append(option)
new_cart(request, products)
request.method = "GET"
return paypal_checkout(request, success_url=reverse("submit-order", args=[orderid]))
else:
register_design_order(order.owner, order.owner.get_profile().account, order, cost)
order = form.save(commit=False)
order.status = BaseOrder.Const.SUBMITTED
order.submitted = datetime.now()
order.save()
# return HttpResponseRedirect('completed_order_summary', args=[orderid]) # TODO
return HttpResponseRedirect(reverse("submit-order-completed", args=[order.id]))
return dict(order=order, form=form)
def submit(pid = None):
form = SubmitForm()
if request.method == 'POST':
if form.validate_on_submit() and check_qaptcha():
pid = form.problem_id.data
p = Problem.query.get(pid)
if p is None:
flash("Problem %d doesn't exist!" % (pid))
return redirect(url_for('submit'))
elif (p.released == False) and (g.user.role not in ['admin', 'ta']): #problem not released
flash("You don't have access to problem %d!" % (pid))
return redirect(url_for('submit'))
else:
try:
languages[form.language.data]
except KeyError:
flash('Language not allowed!')
return redirect(url_for('submit'))
#mkdir
filename = secure_filename(form.upload_file.data.filename)
file_data = form.upload_file.data.read()
if not os.path.exists(os.path.join(basedir, 'users/%s/' % (g.user.username))):
os.makedirs(os.path.join(basedir, 'users/%s/' % (g.user.username)))
#rename
hmd5 = hashlib.md5()
hmd5.update(file_data)
filehash = hmd5.hexdigest()
if form.language.data == C:
extension = '.c'
elif form.language.data == CPP:
extension = '.cpp'
rfn = rand_fn()
filepath = os.path.join(basedir, 'users/%s/%s%s' % (g.user.username, datetime.now().strftime('%Y-%m-%d-%H:%M:%S'), '_' + filehash[0:5] + rfn + extension))
#save file with new name
fnew = open(filepath, 'w')
# test utf8
try:
fnew.write(file_data.decode("utf8"))
except:
try:
fnew.write(file_data.decode("gbk").encode("utf8"))
except:
#detect encoding
result = chardet.detect(file_data)
if result['encoding'] is not None:
try:
fnew.write(file_data.decode(result['encoding']).encode("utf8"))
except:
fnew.write(file_data)
else:
fnew.write(file_data)
fnew.close()
#write database
sub = Submit(problem = pid,
user = g.user.id,
language = form.language.data,
submit_time = datetime.now(),
code_file = filepath)
db.session.add(sub)
db.session.commit()
return redirect(url_for('status'))
return render_template('submit.html',
form = form,
pid = pid,
user = g.user)
