def add(self):
content_type = self.request.params.get('content_type')
root = find_root(self.context)
c_t_obj = root[content_type]
schema = c_t_obj.get_schema(context = self.context, request = self.request)
form = Form(schema, buttons=('save',))
post = self.request.POST
response = {}
response['form_resources'] = form.get_widget_resources(None)
if 'save' in post:
controls = post.items()
try:
appstruct = form.validate(controls)
except ValidationFailure, e:
response['form'] = e.render()
return response
obj = MemberData(content_type=content_type, values = appstruct)
#FIXME: Make adaptable to same titles
self.context["%s" % len(self.context)] = obj
url = resource_url(obj, self.request)
return HTTPFound(location=url)
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 _fixme_edit(self):
choices = set()
for (name, plugin) in self.request.registry.getAdapters([self.context], IFieldAdapter):
choices.add((name,plugin.title))
conTemp = ContentTemplateSchema().bind(choices=choices)
form = Form(conTemp,buttons=('submit',))
post = self.request.POST
if 'submit' in post:
controls = post.items()
try:
appstruct = form.validate(controls)
except ValidationFailure, e:
return {'form':e.render(),'form_resources':e.get_widget_resources(None)}
self.data = {}
for field in appstruct['fields']:
ft = FieldTemplate()
ft.title = field['title']
ft.description = field['description']
ft.field_type = field['field_type']
self.context[slugify(ft.title)] = ft
#self.data[slugify(ft.title)] = ft
#data[slugify(ft.title)] = ft #adds to the data array
#results = ResultsView(self, self.context, self.request)
#results.set_data(self.data)
#url = resource_url(results, self.request)
return HTTPFound(appstruct)
def add(self):
schema = ContentTemplateSchema()
schema = schema.bind(context = self.context, request = self.request)
form = Form(schema, buttons=('save',))
post = self.request.POST
response = {}
response['form_resources'] = form.get_widget_resources(None)
if 'save' in post:
controls = post.items()
try:
appstruct = form.validate(controls)
except ValidationFailure, e:
response['form'] = e.render()
return response
obj = ContentTemplate()
obj.title = appstruct['title']
obj.description = appstruct['description']
obj.fields = appstruct['fields']
#FIXME: Make adaptable to same titles
self.context[slugify(obj.title)] = obj
url = resource_url(obj, self.request)
return HTTPFound(location=url)
def add(self):
if 'cancel' in self.request.POST:
url = resource_url(self.context, self.request)
return HTTPFound(location=url)
type = self.request.GET['type']
obj = createContent(type)
schema = createSchema(obj.schemas['add']).bind(context = self.context, request = self.request)
form = Form(schema, buttons=('save', 'cancel',))
self.register_form_resources(form)
if 'save' in self.request.POST:
controls = self.request.POST.items()
try:
appstruct = form.validate(controls)
except ValidationFailure, e:
self.response['form'] = e.render()
return self.response
obj.set_field_appstruct(appstruct)
name = obj.suggest_name(self.context)
self.context[name] = obj
url = resource_url(self.context, self.request)
return HTTPFound(location=url)
def create_member_view(self):
schema = MemberSchema()
schema = schema.bind(context = self.context, request = self.request)
form = Form(schema, buttons = ('submit',))
post = self.request.POST
self.context.f_name = None
self.context.m_name = None
self.context.l_name = None
self.context.birthdate = None
response = {}
response['form_resources'] = form.get_widget_resources(None)
if 'submit' in post:
controls = post.items()
try:
appstruct = form.validate(controls)
except ValidationFailure, e:
response['form'] = e.render()
self.context.f_name = appstruct['f_name']
self.context.m_name = appstruct['m_name']
self.context.l_name = appstruct['l_name']
self.context.birthdate = appstruct['birthdate']
def my_post(request):
form = Form(SampleSchema(), buttons=('up', ))
controls = request.params.items()
params = form.validate(controls)
f = params['image']
request.response.body = f['fp'].read()
f['fp'].close()
return request.response
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 edit(self):
schema = ContentTemplateSchema()
schema = schema.bind(context = self.context, request = self.request, field_types = self.get_field_types())
form = Form(schema, buttons=('save',))
post = self.request.POST
response = {}
response['form_resources'] = form.get_widget_resources(None)
if 'save' in post:
controls = post.items()
try:
appstruct = form.validate(controls)
except ValidationFailure, e:
response['form'] = e.render()
return response
self.context.title = appstruct['title']
self.context.description = appstruct['description']
self.context.fields = appstruct['fields']
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 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 edit(self):
if 'cancel' in self.request.POST:
url = resource_url(self.context, self.request)
return HTTPFound(location=url)
schema = createSchema(self.context.schemas['edit']).bind(context = self.context, request = self.request)
form = Form(schema, buttons=('save', 'cancel',))
self.register_form_resources(form)
if 'save' in self.request.POST:
controls = self.request.POST.items()
try:
appstruct = form.validate(controls)
except ValidationFailure, e:
self.response['form'] = e.render()
return self.response
self.context.set_field_appstruct(appstruct)
url = resource_url(self.context, self.request)
return HTTPFound(location=url)
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 __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 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']}
