def edit_topic_get(self):
edit_form = Form(self.request.topic.edit_schema().bind(request=self.request), buttons=('save',))
return {
'page_title': 'Edit Topic',
'username': self.request.username,
'edit_form': edit_form.render(self.request.topic.__dict__)
}
def new(self):
""" create new model object """
schema = self.context.schema.bind(db_session=self.context.db_session)
form = Form(schema, buttons=('add',))
resources = form.get_widget_resources()
js_resources = resources['js']
css_resources = resources['css']
js_links = [self.request.static_url(r) for r in js_resources]
css_links = [self.request.static_url(r) for r in css_resources]
js_tags = [literal('<script type="text/javascript" src="%s"></script>' % link)
for link in js_links]
css_tags = [literal('<link rel="stylesheet" href="%s"/>' % link)
for link in css_links]
resource_tags = js_tags + css_tags
if self.request.method == 'POST':
controls = self.request.params.items()
try:
params = form.validate(controls)
item = self.context.add(params)
del self.request.matchdict['traverse']
location = self.request.resource_url(
self.context,
route_name=self.request.matched_route.name,
route_kw=self.request.matchdict)
return HTTPFound(location=location)
except ValidationFailure as e:
return dict(form=e.render(), resource_tags=resource_tags)
return dict(form=form.render(), resource_tags=resource_tags)
def edit_question_get(self):
edit_form = Form(self.request.question.edit_schema().bind(request=self.request), buttons=('save',))
return {
'page_title': 'Edit Question',
'username': self.request.username,
'edit_form': edit_form.render(self.request.question.__dict__),
}
def get_question_creation_form(self):
try:
schema, _ = forms.get_question_creation_schema(self.request.GET)
action = self.request.route_path('create_question', question_set_id=self.request.GET['question_set_id'])
form = Form(schema.bind(request=self.request), buttons=('create',), action=action)
return Response(body=form.render())
except Exception as _:
return HTTPClientError()
def register(self):
schema = forms.RegistrationSchema().bind(request=self.request)
form = Form(schema, buttons=('submit',))
if self.request.method == 'POST' and 'submit' in self.request.POST:
try:
appstruct = form.validate(self.request.POST.items())
user = User.create(appstruct, self.request.db)
Session.login(self.request.session, user)
return HTTPFound(self.request.route_url('profile'))
except ValueError as e:
exc = colander.Invalid(form.widget, str(e))
form.widget.handle_error(form,exc)
rendered_form = form.render()
except ValidationFailure as e:
rendered_form = e.render()
else:
rendered_form = form.render()
return {'page_title':'Register', 'form':rendered_form}
def login(self):
schema = forms.LoginSchema().bind(request=self.request)
form = Form(schema, buttons=('Login',))
if self.request.method == 'POST' and 'Login' in self.request.POST:
try:
appstruct = form.validate(self.request.POST.items())
user = User.login(appstruct, self.request.db)
if user:
Session.login(self.request.session, user)
return HTTPFound(self.request.route_url('profile'))
else:
exc = colander.Invalid(form.widget, 'Username or password is incorrect.')
form.widget.handle_error(form, exc)
rendered_form = form.render()
except ValidationFailure as e:
rendered_form = e.render()
else:
rendered_form = form.render()
return {'page_title':'Login','form':rendered_form}
def edit_topic_post(self):
template_vars = {'page_title': 'Edit Topic', 'username': self.request.username}
try:
edit_form = Form(self.request.topic.edit_schema().bind(request=self.request), buttons=('save',))
appstruct = edit_form.validate(self.request.POST.items())
self.request.topic.edit(appstruct, self.request.db)
return HTTPFound(self.request.route_url('profile'))
except ValueError as e:
exc = colander.Invalid(edit_form.widget, str(e))
edit_form.widget.handle_error(edit_form, exc)
template_vars['edit_form'] = edit_form.render()
except ValidationFailure as e:
template_vars['edit_form'] = e.render()
return template_vars
def setup(self):
question_set_id = self.request.question_set.id
set_name = self.request.question_set.description
question_set = self.request.question_set.get_questions(self.request.db)
try:
template_vars = {'page_title':'Answer', 'username': self.request.username} #Need better title.
self.request.session[Session.QUESTION_STATE] = QuestionSetState(question_set, question_set_id, set_name)
question = self.request.session[Session.QUESTION_STATE].get_current_question()
schema = question.answer_schema(self.request)
question_form = Form(schema, buttons=('submit',))
template_vars['question_form'] = question_form.render()
return template_vars
except ValueError as e:
self.request.session.flash(str(e))
return HTTPFound(self.request.route_url('profile'))
def render_results_view(self):
strDisp = ""
if self.data is not None:
for field in self.data:
#Allows for concatenation for display
title = field['title']
description = field['description']
field_type = field['field_type']
#concatenating the data
strDisp = strDisp.concatenate(' %s %s %s ' % (title, description, field_type))
#temporary schema to see if the results are being transferred
schism = TextSchema().bind(type = ['turtle','peacock'])
form = Form(schism,button=('save',))
#return HTTPFound(strDisp)
return {'form':form.render(),'form_resources':form.get_widget_resources(None)}
def edit_question_post(self):
template_vars = {'page_title': 'Edit Question', 'username': self.request.username}
if 'save' in self.request.POST:
edit_form = Form(self.request.question.edit_schema().bind(request=self.request), buttons=('save',))
try:
appstruct = edit_form.validate(self.request.POST.items())
self.request.question.edit(appstruct, self.request.db)
#Temporary, need to redirect to question set page
return HTTPFound(self.request.route_url('profile'))
except ValueError as e:
exc = colander.Invalid(edit_form.widget, str(e))
edit_form.widget.handle_error(edit_form,exc)
template_vars['edit_form'] = edit_form.render()
except ValidationFailure as e:
template_vars['edit_form'] = e.render()
else:
return HTTPFound(self.request.route_url('profile'))
return template_vars
def __call__(self):
schema = self.context.schema.bind(db_session=self.context.db_session)
form = Form(schema, buttons=('save',))
resources = form.get_widget_resources()
js_resources = resources['js']
css_resources = resources['css']
js_links = [self.request.static_url(r) for r in js_resources]
css_links = [self.request.static_url(r) for r in css_resources]
js_tags = [literal('<script type="text/javascript" src="%s"></script>' % link)
for link in js_links]
css_tags = [literal('<link rel="stylesheet" href="%s"/>' % link)
for link in css_links]
resource_tags = js_tags + css_tags
if self.request.method == 'POST':
controls = self.request.params.items()
try:
params = form.validate(controls)
except ValidationFailure as e:
return dict(form=e.render(), resource_tags=resource_tags)
return dict(form=form.render(self.context.appstruct),
resource_tags=resource_tags)
def create_question(self):
template_vars = {
'page_title': 'Create Question',
'username': self.request.username,
'question_choices': forms.get_question_select_options(self.request.route_url('question_creation_form')),
}
if self.request.method == 'POST':
try:
schema, question_type = forms.get_question_creation_schema(self.request.POST)
action = self.request.route_path('create_question', question_set_id=self.request.question_set.id)
form = Form(schema.bind(request=self.request), buttons=('create',), action=action)
appstruct = form.validate(self.request.POST.items())
question_set_id = self.request.matchdict['question_set_id']
Question.create(question_set_id, appstruct, self.request.db)
return HTTPFound(self.request.route_url('profile'))
except ValueError as e:
exc = colander.Invalid(form.widget, str(e))
form.widget.handle_error(form,exc)
template_vars['form'] = (question_type, form.render())
except ValidationFailure as e:
template_vars['form'] = (question_type, e.render())
return template_vars
def answer(self):
if 'submit' in self.request.POST and Session.QUESTION_STATE in self.request.session:
template_vars = {'page_title':'Answer', 'username': self.request.username}
try:
#Store the previous question's answer.
question = self.request.session[Session.QUESTION_STATE].get_current_question()
schema = question.answer_schema(self.request)
question_form = Form(schema)
appstruct = question_form.validate(self.request.POST.items())
self.request.session[Session.QUESTION_STATE].record_answer(appstruct['answer'])
#Present the next question.
question = self.request.session[Session.QUESTION_STATE].get_next_question()
if question:
schema = question.answer_schema(self.request)
question_form = Form(schema, buttons=('submit',))
template_vars['question_form'] = question_form.render()
else:
return HTTPFound(self.request.route_url('report'))
except ValidationFailure as e:
template_vars['question_form'] = e.render()
return template_vars
else:
return HTTPFound(self.request.route_url('profile'))
def get_method_schema_preview(method_schema_id):
"""
Create and render the method schema identified by method_schema_id as HTML.
:param method_schema_id: ID of the MethodSchema to preview.
:return: Deform rendered HTML form for the identified MethodSchema (Note: The <form> element is removed).
"""
method_schema = DBSession.query(MethodSchema).filter_by(id=method_schema_id).first()
if method_schema is None:
return "<p>Please create your data mapping using the standardised and custom fields.</p>"
model_schema = DataTypeSchema(method_schema)
# Create a dummy request object to make file upload widgets display properly for preview purposes.
settings = {'workflows.files': "./"}
Registry = namedtuple('registry', 'settings')
Request = namedtuple('registry', ['registry', 'session'])
dummy_request = Request(registry=Registry(settings=settings), session=DummySession())
model_schema._bind({'request': dummy_request}) # Use _bind instead of bind so the schema isn't cloned
form = Form(model_schema, action="")
display = form.render({})
display = display[display.index(">")+1:].replace("</form>", "").strip()
return display
def gamedep_add_binary(context, request):
check_owner(context, request)
gamedeptype = request.matchdict.get('type')
g = GameDepLib(gamedeptype)
page_id = request.matchdict.get('page_id')
binary_id = request.matchdict.get('binary_id')
revision = request.matchdict.get('revision')
edittype = request.matchdict.get('edittype')
try:
bin_obj = g.show_binary(binary_id)
except GameDepNotFound:
bin_obj = None
if binary_id and edittype:
pass
# Initialise form library
if not binary_id and not edittype:
schema = AddBinarySchema()
elif binary_id and edittype == "1":
schema = EditBinarySchema()
elif binary_id and edittype == "2":
schema = EditOSArchSchema()
else:
request.session.flash(s.show_setting("ERROR_INVALID_BINARY_ID"), ERROR)
return redirect(request, "gamedep_item", page_id=page_id,
type=gamedeptype)
schema = schema.bind(gamedep_type=gamedeptype, bin_obj=bin_obj,
req_file_folder=["%s/" % page_id])
myform = Form(schema, buttons=['submit'])
reqts = myform.get_widget_resources()
if 'submit' in request.POST:
controls = request.POST.items()
try:
deserialized = myform.validate(controls)
except ValidationFailure as e:
# Failed validation
return {'page_id': page_id, 'form': e.render(),
'js_links': reqts['js']}
# Form submitted, all validated!
binary = deserialized.get("binary")
operatingsystem = deserialized.get("operatingsystem")
architecture = deserialized.get("architecture")
if not binary_id and not edittype:
g.create_binary(page_id, revision, operatingsystem, architecture,
binary['fp'], binary['mimetype'],
binary['filename'], request)
request.session.flash(s.show_setting("INFO_BINARY_ADDED")
% binary['filename'], INFO)
else:
g.update_binary(page_id, revision, binary_id, operatingsystem,
architecture, binary, request)
request.session.flash(s.show_setting("INFO_BINARY_UPDATED")
% binary['filename'], INFO)
return redirect(request, "gamedep_item", page_id=page_id,
type=gamedeptype)
# Display default form
return {'page_id': page_id, 'form': myform.render(),
'js_links': reqts['js']}
def gamedep_add_binary(context, request):
check_owner(context, request)
gamedeptype = request.matchdict.get('type')
g = GameDepLib(gamedeptype)
page_id = request.matchdict.get('page_id')
binary_id = request.matchdict.get('binary_id')
revision = request.matchdict.get('revision')
edittype = request.matchdict.get('edittype')
try:
bin_obj = g.show_binary(binary_id)
except GameDepNotFound:
bin_obj = None
if binary_id and edittype:
pass
# Initialise form library
if not binary_id and not edittype:
schema = AddBinarySchema()
elif binary_id and edittype == "1":
schema = EditBinarySchema()
elif binary_id and edittype == "2":
schema = EditOSArchSchema()
else:
request.session.flash(s.show_setting("ERROR_INVALID_BINARY_ID"), ERROR)
return redirect(request,
"gamedep_item",
page_id=page_id,
type=gamedeptype)
schema = schema.bind(gamedep_type=gamedeptype,
bin_obj=bin_obj,
req_file_folder=["%s/" % page_id])
myform = Form(schema, buttons=['submit'])
reqts = myform.get_widget_resources()
if 'submit' in request.POST:
controls = request.POST.items()
try:
deserialized = myform.validate(controls)
except ValidationFailure as e:
# Failed validation
return {
'page_id': page_id,
'form': e.render(),
'js_links': reqts['js']
}
# Form submitted, all validated!
binary = deserialized.get("binary")
operatingsystem = deserialized.get("operatingsystem")
architecture = deserialized.get("architecture")
if not binary_id and not edittype:
g.create_binary(page_id, revision, operatingsystem, architecture,
binary['fp'], binary['mimetype'],
binary['filename'], request)
request.session.flash(
s.show_setting("INFO_BINARY_ADDED") % binary['filename'], INFO)
else:
g.update_binary(page_id, revision, binary_id, operatingsystem,
architecture, binary, request)
request.session.flash(
s.show_setting("INFO_BINARY_UPDATED") % binary['filename'],
INFO)
return redirect(request,
"gamedep_item",
page_id=page_id,
type=gamedeptype)
# Display default form
return {
'page_id': page_id,
'form': myform.render(),
'js_links': reqts['js']
}
