def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
name = self.request.get(u'name')
description = self.request.get(u'description')
css = self.request.get(u'css')
if not name:
error_msg = u'You must specify a name for your style definition'
else:
style_entity = dao.get_style_by_name(template, name)
if style_entity:
error_msg = u'Adding style failed: Duplicate style name in template'
else:
try:
dao.Style(name=name, description=description, css=css, parent=template.key).put()
self.redirect("/template/style?template_id={}".format(template.key.id()))
return
except Exception as e:
error_msg = u'Adding style failed: {}'.format(e)
# Display the webpage
self.render(template, error_msg)
def get(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
# Display the webpage
self.render(template)
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
document_entity = dao.get_document_by_id(
template, self.request.get(u'document_id'))
error_msg = None if document_entity else u'Unable to access specified document'
# Handle delete request
if document_entity and self.request.get(u'delete'):
try:
document_entity.key.delete()
self.redirect("/template/document?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Deleting document from template failed: {}'.format(
e)
# Handle update request
if document_entity and self.request.get(u'update'):
try:
document_entity.description = self.request.get(u'description')
document_entity.style_name = self.request.get(u'doc_style')
document_entity.put()
self.redirect("/template/document?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Updating document failed: {}'.format(e)
# Display the webpage
self.render(template, document_entity, error_msg)
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
name = self.request.get(u'name')
description = self.request.get(u'description')
doc_style = self.request.get(u'doc_style')
if not name:
error_msg = u'You must specify a name for your document definition'
else:
document_entity = dao.get_document_by_name(template, name)
if document_entity:
error_msg = u'Adding document failed: Duplicate document name in template'
else:
try:
document_entity = dao.Document(name=name,
internal_name=dao.convert_name_to_internal_name(name),
description=description, style_name=doc_style,
parent=template.key)
document_entity.put()
self.redirect("/template/document?template_id={}".format(template.key.id()))
return
except Exception as e:
error_msg = u'Adding document failed: {}'.format(e)
# Display the webpage
self.render(template, error_msg)
def post(self):
if not dao.test_site_permission(dao.SITE_ADMIN_USERS):
webapp2.abort(401)
# Get specified Template entity
template_id = self.request.get(u'template_id')
template = dao.get_template_by_id(template_id)
error_msg = None if template else u'Unable to access specified template'
# Handle delete request
if template and self.request.get(u'delete'):
try:
dao.delete_project(template)
self.redirect("/site_admin/template_admin")
return
except Exception as e:
error_msg = u'Deleting template failed: {}'.format(e)
# Handle update request
if template and self.request.get(u'update'):
try:
template.description = self.request.get(u'description')
if not template.description:
raise Exception(
u'You must provide a description for the template')
template.status = self.request.get(u'status')
template.put()
self.redirect("/site_admin/template_admin")
return
except Exception as e:
error_msg = u'Updating template failed: {}'.format(e)
# Display the webpage
self.render(template_id, template, error_msg)
def get(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
variable_list = list()
for variable_entity in dao.get_variables(template):
variable = dict()
variable[u'id'] = variable_entity.key.id()
variable[u'name'] = variable_entity.name
variable[u'description'] = variable_entity.description
variable[u'is_repeating'] = variable_entity.is_repeating
variable[u'input_field'] = variable_entity.input_field
variable[u'assignments'] = self.get_assignments(template, variable)
variable[u'documents'] = self.get_documents(template, variable)
variable_list.append(variable)
# Create template and template values, render the page
jinja_template = ui.get_template(self, u'template/variable/index.html')
jinja_template_values = dao.get_standard_template_values(template)
jinja_template_values[u'variables'] = variable_list
self.response.out.write(jinja_template.render(jinja_template_values))
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
name = self.request.get(u'name')
description = self.request.get(u'description')
variable_type = self.request.get(u'type')
if not name:
error_msg = u'You must specify a name for your assignment definition'
elif not variable_type:
error_msg = u'You must specify whether this is a single or repeating assignment'
else:
assignment_entity = dao.get_assignment_by_name(template, name)
if assignment_entity:
error_msg = u'Adding assignment failed: Duplicate assignment name in template'
else:
try:
assignment_entity = dao.Assignment(
name=name,
description=description,
is_repeating=(variable_type == u'repeating'),
parent=template.key)
assignment_entity.put()
self.redirect("/template/assignment?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Adding assignment failed: {}'.format(e)
# Display the webpage
self.render(template, error_msg)
def get(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
document_entity = dao.get_document_by_id(template, self.request.get(u'document_id'))
error_msg = None if document_entity else u'Unable to access specified document'
# Display the webpage
self.render(template, document_entity, error_msg)
def get(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
jinja_template = ui.get_template(self, u'template/index.html')
jinja_template_values = dao.get_standard_template_values(template)
jinja_template_values[u'template'] = template
self.response.out.write(jinja_template.render(jinja_template_values))
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
error_msg = None
# Handle contribute request
if self.request.get(u'contribute'):
try:
name = self.request.get(u'name').strip()
if not name:
raise Exception(
u'You must provide a name for the public template')
if dao.get_public_template_by_name(name):
raise Exception(u'Sorry, that name is taken')
new_template = dao.Project(
name=name,
project_type=dao.PUBLIC_TEMPLATE,
status=dao.STATUS_PENDING,
description=self.request.get(u'description'))
new_template.put()
for assignment_entity in dao.get_assignments(template):
assignment_entity.clone(new_template).put()
for document_entity in dao.get_documents(template):
template_document_entity = document_entity.clone(
new_template)
template_document_entity.put()
for document_item_entity in dao.get_document_items(
document_entity):
document_item_entity.clone(
template_document_entity).put()
for interview_entity in dao.get_interviews(template):
cloned_interview_entity = interview_entity.clone(
new_template)
cloned_interview_entity.put()
for style_entity in dao.get_styles(template):
style_entity.clone(new_template).put()
for variable_entity in dao.get_variables(template):
variable_entity.clone(new_template).put()
self.redirect("/template?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Contributing project failed: {}'.format(e)
# Display the webpage
self.render(template, error_msg)
def get(self):
if not dao.test_site_permission(dao.SITE_ADMIN_TEMPLATES):
webapp2.abort(401)
# Get specified Template entity
template_id = self.request.get(u'template_id')
template = dao.get_template_by_id(template_id)
error_msg = None if template else u'Unable to access specified template'
# Display the webpage
self.render(template_id, template, error_msg)
def get(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
# Create template and template values, render the page
jinja_template = ui.get_template(self, u'template_admin/template_user_admin.html')
jinja_template_values = dao.get_standard_template_values(template)
jinja_template_values[u'users'] = dao.get_template_users(template)
self.response.out.write(jinja_template.render(jinja_template_values))
def get(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
# Get specified ProjectUser entity
template_user_id = self.request.get(u'template_user_id')
template_user = dao.get_template_user_by_id(template, template_user_id)
error_msg = None if template_user else u'Unable to access specified template user'
# Display the webpage
self.render(template, template_user_id, template_user, error_msg)
def get(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
# Build list of permission checkboxes and whether they should be checked
permissions = list()
for template_permission in dao.get_all_template_permissions():
permissions.append({u'name': template_permission, u'checked': u''})
# Display the webpage
self.render(template, permissions)
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
# Validate the submitted email address
submitted_email = self.request.get(u'email')
if submitted_email == u'':
error_msg = u'Email address must be specified'
elif email_pattern.match(submitted_email):
# Test whether TemplateUser entity for that email already exists
if dao.test_email_in_template(template, submitted_email):
error_msg = u'Already a member of this template: {}'.format(
submitted_email)
else:
# Attempt to add a new TemplateUser entity
permissions = list()
for permission in dao.get_all_template_permissions():
if self.request.get(permission):
permissions.append(permission)
if not dao.test_template_permissions(template,
[dao.TEMPLATE_OWN]):
if dao.TEMPLATE_OWN in permissions:
webapp2.abort(401)
try:
dao.ProjectUser(email=submitted_email.lower(),
parent=template.key,
permissions=permissions).put()
self.redirect(
"/template_admin/template_user_admin?template_id={}".
format(template.key.id()))
return
except Exception as e:
error_msg = u'Adding user to template failed: {}'.format(e)
else:
error_msg = u'Invalid email: {}'.format(submitted_email)
# Build list of permission checkboxes and whether they should be checked
permissions = list()
for template_permission in dao.get_all_template_permissions():
permission = {
u'name':
template_permission,
u'checked':
u'checked' if self.request.get(template_permission) else u''
}
permissions.append(permission)
# Display the webpage
self.render(template, permissions, error_msg)
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
error_msg = None
# Handle delete request
if self.request.get(u'delete'):
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN]):
webapp2.abort(401)
try:
dao.delete_template(template)
self.redirect("/")
return
except Exception as e:
error_msg = u'Deleting template failed: {}'.format(e)
# Handle update request
if self.request.get(u'update'):
current_user = users.get_current_user()
current_email = current_user.email().lower()
try:
name = self.request.get(u'name').strip()
if name != template.name:
if not name:
raise Exception(
u'You must provide a name for your template')
for test_template in dao.get_private_template_by_name(
name):
if dao.test_email_is_template_owner(
test_template, current_email):
raise Exception(
u'Sorry, you already own a different template named \"{}\"'
.format(name))
template.name = name
template.description = self.request.get(u'description')
template.put()
self.redirect("/template?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Updating template failed: {}'.format(e)
# Display the webpage
self.render(template, error_msg)
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
# Get specified TemplateUser entity
template_user_id = self.request.get(u'template_user_id')
template_user = dao.get_template_user_by_id(template, template_user_id)
error_msg = None if template_user else u'Unable to access specified template user'
# Handle delete request
if template_user and self.request.get(u'delete'):
try:
self.require_owner(template, exclude_user=template_user)
template_user.key.delete()
self.redirect("/template_admin/template_user_admin?template_id={}".format(template.key.id()))
return
except Exception as e:
error_msg = u'Deleting template user failed: {}'.format(e)
# Handle update request
if template_user and self.request.get(u'update'):
# Attempt to update the TemplateUser entity's permissions
permissions = list()
for permission in dao.get_all_template_permissions():
if self.request.get(permission):
permissions.append(permission)
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN]):
if (dao.TEMPLATE_OWN in template_user.permissions and dao.TEMPLATE_OWN not in permissions) or (
dao.TEMPLATE_OWN not in template_user.permissions and dao.TEMPLATE_OWN in permissions):
webapp2.abort(401)
template_user.permissions = permissions
try:
self.require_owner(template)
template_user.put()
self.redirect("/template_admin/template_user_admin?template_id={}".format(template.key.id()))
return
except Exception as e:
error_msg = u'Updating template user failed: {}'.format(e)
# Display the webpage
self.render(template, template_user_id, template_user, error_msg)
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
assignment_entity = dao.get_assignment_by_id(
template, self.request.get(u'assignment_id'))
error_msg = None if assignment_entity else u'Unable to access specified assignment'
# Handle delete request
if assignment_entity and self.request.get(u'delete'):
try:
assignment_entity.key.delete()
# Delete associated generated interviews
for interview_entity in dao.get_interviews_by_assignment_name(
template, assignment_entity.name):
interview_entity.key.delete()
self.redirect("/template/assignment?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Deleting assignment from template failed: {}'.format(
e)
# Handle update request
if assignment_entity and self.request.get(u'update'):
try:
assignment_entity.description = self.request.get(
u'description')
assignment_entity.is_repeating = (
self.request.get(u'type') == u'repeating')
assignment_entity.put()
self.redirect("/template/assignment?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Updating assignment failed: {}'.format(e)
# Display the webpage
self.render(template, assignment_entity, error_msg)
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
name = self.request.get(u'name')
description = self.request.get(u'description')
variable_type = self.request.get(u'type')
input_field = self.request.get(u'input_field')
if not name:
error_msg = u'You must specify a name for your variable definition'
elif not variable_type:
error_msg = u'You must specify whether this is a single or repeating variable'
elif not input_field:
error_msg = u'You must specify which size of input field to display'
else:
internal_name = dao.convert_name_to_internal_name(name)
variable_entity = dao.get_variable_by_internal_name(
template, internal_name)
if variable_entity:
error_msg = u'Adding variable failed, name collision in template: {}'.format(
variable_entity.name)
else:
try:
dao.Variable(name=name,
internal_name=internal_name,
description=description,
is_repeating=(variable_type == u'repeating'),
input_field=input_field,
content=u'',
parent=template.key).put()
self.redirect("/template/variable?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Adding variable failed: {}'.format(e)
# Display the webpage
self.render(template, error_msg)
def get(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
style_list = list()
for style_entity in dao.get_styles(template):
style = dict()
style[u'id'] = style_entity.key.id()
style[u'name'] = style_entity.name
style[u'description'] = style_entity.description
style[u'css'] = style_entity.css
style_list.append(style)
# Create template and template values, render the page
jinja_template = ui.get_template(self, u'template/style/index.html')
jinja_template_values = dao.get_standard_template_values(template)
jinja_template_values[u'styles'] = style_list
self.response.out.write(jinja_template.render(jinja_template_values))
def get(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
document_list = list()
for document_entity in dao.get_documents(template):
document = dict()
document[u'id'] = document_entity.key.id()
document[u'name'] = document_entity.name
document[u'description'] = document_entity.description
document[u'style'] = document_entity.style_name
document_list.append(document)
# Create template and template values, render the page
jinja_template = ui.get_template(self, u'template/document/index.html')
jinja_template_values = dao.get_standard_template_values(template)
jinja_template_values[u'documents'] = document_list
self.response.out.write(jinja_template.render(jinja_template_values))
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
variable_entity = dao.get_variable_by_id(
template, self.request.get(u'variable_id'))
error_msg = None if variable_entity else u'Unable to access specified variable'
# Handle delete request
if variable_entity and self.request.get(u'delete'):
try:
variable_entity.key.delete()
self.redirect("/template/variable?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Deleting variable from template failed: {}'.format(
e)
# Handle update request
if variable_entity and self.request.get(u'update'):
try:
variable_entity.description = self.request.get(u'description')
variable_entity.is_repeating = (
self.request.get(u'type') == u'repeating')
variable_entity.input_field = self.request.get(u'input_field')
variable_entity.put()
self.redirect("/template/variable?template_id={}".format(
template.key.id()))
return
except Exception as e:
error_msg = u'Updating variable failed: {}'.format(e)
# Display the webpage
self.render(template, variable_entity, error_msg)
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
document_entity = dao.get_document_by_id(template, self.request.get(u'document_id'))
error_msg = None if document_entity else u'Unable to access specified document'
if document_entity:
# Handle add request
item_type = None
if self.request.get(u'add_text'):
item_type = dao.TEXT
elif self.request.get(u'add_single_variable'):
item_type = dao.SINGLE_VARIABLE
elif self.request.get(u'add_repeating_variable'):
item_type = dao.REPEATING_VARIABLE
if item_type:
try:
dao.DocumentItem(item_type=item_type, position=dao.get_document_item_count(document_entity) + 1,
parent=document_entity.key).put()
except Exception as e:
error_msg = u'Adding document item failed: {}'.format(e)
# Handle request
items = [item for item in dao.get_document_items(document_entity)]
# Update items
for item in items:
index = item.position - 1
if item.item_type == dao.SINGLE_VARIABLE:
item.variable_name = self.request.get(u'single_name.{}'.format(index))
elif item.item_type == dao.REPEATING_VARIABLE:
item.variable_name = self.request.get(u'repeating_name.{}'.format(index))
elif item.item_type == dao.TEXT:
item.text = self.request.get(u'text.{}'.format(index))
item.style_name = self.request.get(u'style_name.{}'.format(index))
item.flow_control = self.request.get(u'flow_control.{}'.format(index))
try:
item.put()
except Exception as e:
error_msg = u'Updating document failed: {}'.format(e)
break
for request in self.request.arguments():
# Handle change-position request
change_position = change_pattern.match(request)
if change_position:
old_index = int(change_position.group(1))
new_position_string = None
try:
new_position_string = self.request.get(u'position.{}'.format(old_index))
new_position = int(new_position_string)
except:
error_msg = u'Invalid position specified: {}'.format(new_position_string)
break
if new_position < 1:
new_position = 1
if new_position > len(items):
new_position = len(items)
new_index = new_position - 1
compressed_items = items[:old_index] + items[old_index + 1:]
new_items = compressed_items[:new_index]
new_items.append(items[old_index])
new_items += compressed_items[new_index:]
self.compute_positions(new_items)
# Handle remove request
remove_position = remove_pattern.match(request)
if remove_position:
index = int(remove_position.group(1))
item = items[index]
item.key.delete()
new_items = items[:index] + items[index + 1:]
self.compute_positions(new_items)
if self.request.get(u'update') and not error_msg:
self.redirect("/template/document?template_id={}".format(template.key.id()))
return
# Display the webpage
self.render(template, document_entity, error_msg)
def post(self):
if not dao.test_current_user_registered():
webapp2.abort(401)
current_user = users.get_current_user()
current_email = current_user.email().lower()
# Attempt to create a new project
try:
name = self.request.get(u'name').strip()
if not name:
raise Exception(u'You must provide a name for your project')
for project in dao.get_projects_by_name(name):
if dao.test_email_is_project_owner(project, current_email):
raise Exception(
u'Sorry, you already own a project by that name')
# Create the new Project entity
project = dao.Project(name=name,
project_type=dao.PROJECT,
description=self.request.get(u'description'))
project_key = project.put()
# Create a ProjectUser entity, making the current user owner of the new project
dao.ProjectUser(email=dao.get_current_site_user().email,
permissions=[dao.PROJECT_OWN],
parent=project_key).put()
# Get the selected template ID
template_id = self.request.get(u'template_id')
if template_id:
# Generate HTML for the template
template_entity = dao.get_template_by_id(template_id)
html_generator_service = HtmlGeneratorService(template_entity)
html_generator_service.generate_all_html()
# Copy entities owned by the template entity into the project
for assignment_entity in dao.get_assignments(template_entity):
assignment_entity.clone(project).put()
for document_entity in dao.get_documents(template_entity):
template_document_entity = document_entity.clone(project)
template_document_entity.put()
for document_item_entity in dao.get_document_items(
document_entity):
document_item_entity.clone(
template_document_entity).put()
for interview_entity in dao.get_interviews(template_entity):
cloned_interview_entity = interview_entity.clone(project)
if cloned_interview_entity.auto_assign:
cloned_interview_entity.assigned_email = current_email
cloned_interview_entity.put()
for style_entity in dao.get_styles(template_entity):
style_entity.clone(project).put()
for variable_entity in dao.get_variables(template_entity):
variable_entity.clone(project).put()
self.redirect("/project?project_id={}".format(project_key.id()))
return
except Exception as e:
error_msg = u'Creating project failed: {}'.format(e)
# Display the webpage
self.render(error_msg)
def post(self):
template = dao.get_template_by_id(self.request.get(u'template_id'))
if not dao.test_template_permissions(
template, [dao.TEMPLATE_OWN, dao.TEMPLATE_EDIT]):
webapp2.abort(401)
assignment_entity = dao.get_assignment_by_id(
template, self.request.get(u'assignment_id'))
error_msg = None if assignment_entity else u'Unable to access specified assignment'
if assignment_entity:
# Handle request
assignment_entity.instructions_to_manager = self.request.get(
u'instructions_to_manager')
assignment_entity.instructions_to_writer = self.request.get(
u'instructions_to_writer')
# Handle prerequisite assignments
prereq_assignment_names = list()
for argument in self.request.arguments():
prereq_assignment_name = prereq_pattern.match(argument)
if prereq_assignment_name:
name = dict()
name[u'position'] = int(prereq_assignment_name.group(1))
name[u'name'] = self.request.get(argument)
prereq_assignment_names.append(name)
prereq_assignment_names.sort(
cmp=lambda x, y: cmp(x[u'position'], y[u'position']))
for argument in self.request.arguments():
change_prereq_assignment_name_position = change_prereq_position_pattern.match(
argument)
if change_prereq_assignment_name_position:
old_position = int(
change_prereq_assignment_name_position.group(1))
old_index = old_position - 1
new_position = int(
self.request.get(
u'prereq_assignment_name_position.{}'.format(
old_position)))
if new_position < 1:
new_position = 1
if new_position > len(
assignment_entity.prereq_assignment_names):
new_position = len(
assignment_entity.prereq_assignment_names)
new_index = new_position - 1
compressed_names = prereq_assignment_names[:
old_index] + prereq_assignment_names[
old_index +
1:]
new_names = compressed_names[:new_index]
new_names.append(prereq_assignment_names[old_index])
new_names += compressed_names[new_index:]
prereq_assignment_names = new_names
for argument in self.request.arguments():
remove_prereq_assignment_name_position = remove_prereq_position_pattern.match(
argument)
if remove_prereq_assignment_name_position:
position = int(
remove_prereq_assignment_name_position.group(1))
del prereq_assignment_names[position - 1]
assignment_entity.prereq_assignment_names = [
name[u'name'] for name in prereq_assignment_names
]
if self.request.get(u'add_prereq_assignment_name'):
assignment_entity.prereq_assignment_names.append(u'')
# Handle variable names
names = list()
for argument in self.request.arguments():
variable_name = variable_pattern.match(argument)
if variable_name:
name = dict()
name[u'position'] = int(variable_name.group(1))
name[u'name'] = self.request.get(argument)
names.append(name)
names.sort(cmp=lambda x, y: cmp(x[u'position'], y[u'position']))
for argument in self.request.arguments():
change_variable_name_position = change_variable_position_pattern.match(
argument)
if change_variable_name_position:
old_position = int(change_variable_name_position.group(1))
old_index = old_position - 1
new_position = int(
self.request.get(
u'variable_name_position.{}'.format(old_position)))
if new_position < 1:
new_position = 1
if new_position > len(assignment_entity.variable_names):
new_position = len(assignment_entity.variable_names)
new_index = new_position - 1
compressed_names = names[:old_index] + names[old_index +
1:]
new_names = compressed_names[:new_index]
new_names.append(names[old_index])
new_names += compressed_names[new_index:]
names = new_names
for argument in self.request.arguments():
remove_variable_name_position = remove_variable_position_pattern.match(
argument)
if remove_variable_name_position:
position = int(remove_variable_name_position.group(1))
del names[position - 1]
assignment_entity.variable_names = [
name[u'name'] for name in names
]
if self.request.get(u'add_variable_name'):
assignment_entity.variable_names.append(u'')
# Handle checklist items
items = list()
for argument in self.request.arguments():
checklist_item = checklist_pattern.match(argument)
if checklist_item:
item = dict()
item[u'position'] = int(checklist_item.group(1))
item[u'item'] = self.request.get(argument)
items.append(item)
items.sort(cmp=lambda x, y: cmp(x[u'position'], y[u'position']))
for argument in self.request.arguments():
change_checklist_item_position = change_checklist_position_pattern.match(
argument)
if change_checklist_item_position:
old_position = int(change_checklist_item_position.group(1))
old_index = old_position - 1
new_position = int(
self.request.get(u'checklist_item_position.{}'.format(
old_position)))
if new_position < 1:
new_position = 1
if new_position > len(assignment_entity.checklist_items):
new_position = len(assignment_entity.checklist_items)
new_index = new_position - 1
compressed_items = items[:old_index] + items[old_index +
1:]
new_items = compressed_items[:new_index]
new_items.append(items[old_index])
new_items += compressed_items[new_index:]
items = new_items
for argument in self.request.arguments():
remove_checklist_item_position = remove_checklist_position_pattern.match(
argument)
if remove_checklist_item_position:
position = int(remove_checklist_item_position.group(1))
del items[position - 1]
assignment_entity.checklist_items = [
item[u'item'] for item in items
]
if self.request.get(u'add_checklist_item'):
assignment_entity.checklist_items.append(u'')
assignment_entity.put()
if self.request.get(u'update') and not error_msg:
self.redirect("/template/assignment?template_id={}".format(
template.key.id()))
return
# Display the webpage
self.render(template, assignment_entity, error_msg)
