def widget_options(project, request):
"""
Renders the options panel for a single widget
"""
session = DBSession()
form_id = request.matchdict.get('form_id', None)
form = session.query(Form).filter(Form.project_id==project.id).filter(Form.id==form_id).first()
widget_id = request.matchdict.get('widget_id', None)
widget = session.query(Widget).filter(Widget.form==form).filter(Widget.id==widget_id).first()
widget_controller = widget_controller_factory(widget)
if request.method == 'POST':
widget_controller.process_options(request)
return dict(
id=widget.id,
type=widget.widget_type,
options_html=widget_controller.options(request),
widget_html=widget_controller.render(None, request),
data=widget_controller.data(),
)
def widget_sort_order(project, request):
"""
Reorder widgets by passing a list of widget
ids named sort_order in the request
"""
session = DBSession()
form_id = request.matchdict.get('form_id', None)
form = session.query(Form).filter(Form.project_id==project.id).filter(Form.id==form_id).first()
if request.method == 'POST':
session = DBSession()
sort_order = request.params.getall('sort_order[]')
positions = {}
for idx, widget_id in enumerate(sort_order):
positions[int(widget_id)] = idx
for widget in form.widgets:
# get the sort order for this widget
# if it's not included in the submitted values
# return the next position and add it back into
# the submitted values
sort_order = positions.get(widget.id, len(positions))
positions[widget.id] = sort_order
widget.sort_order = sort_order
session.add(widget)
return {}
def feedback(project, request):
session = DBSession()
item_id = request.matchdict.get('item_id',None)
items = project.get_items_for_user(request.user)
pending_items = [i for i in items if not i.submitted]
completed_items = [i for i in items if i.submitted]
if item_id:
item = project.get_item_for_user(request.user, item_id)
elif pending_items:
item = pending_items[0]
else:
item = None
if item is not None:
item = project.get_item(item.id)
feedback = session.query(FeedbackRecord).filter(FeedbackRecord.user==request.user).filter(FeedbackRecord.item==item).first()
else:
feedback = None
item_controller = FormController(project.item_form)
feedback_controller = FormController(project.feedback_form)
if request.method == 'POST' and item:
feedback_controller.validate_from_request(request)
if feedback_controller.errors:
request.session.flash('There was a problem with your feedback', 'errors')
else:
if not feedback:
feedback = FeedbackRecord(project, request.user, item)
session.add(feedback)
feedback.update_submitted()
feedback_controller.populate_record_from_request(feedback, request)
request.session.flash('Feedback on %s submitted' % item.title, 'messages')
# Once feedback is submitted, load the next
# record from the top of the list
if request.params.get('submit','') == 'save_and_next':
return HTTPFound(
location=route_url('project:feedback', request, project_id=project.id)
)
else:
return HTTPFound(
location=route_url('project:feedback:item', request, project_id=project.id, item_id=item.id)
)
return dict(
pending_items=pending_items,
completed_items=completed_items,
item=item,
item_values=item_controller.render_values(request, item),
form_widgets=feedback_controller.render_widgets(request, feedback),
project=project,
responsive_layout=True,
)
def delete(self):
"""
Delete the widget
"""
session = DBSession()
session.delete(self.widget)
def record(project, request):
form_controller = FormController(project.item_form)
record_id = request.matchdict.get("record_id", None)
if record_id is not None:
record = project.get_item(record_id)
else:
record = None
if record and not record.reviewed:
record.reviewed = True
if request.method == "POST":
title = request.params.get("title", "").strip()
submit = request.params.get("submit", "")
if not title and submit.find("finish") >= 0:
return HTTPFound(location=route_url("project:feedback_form", request, project_id=project.id))
elif not title:
request.session.flash("%s Name or Title is required!" % project.item_name, "errors")
elif title:
form_controller = FormController(project.item_form)
form_controller.validate_from_request(request)
if form_controller.errors:
request.session.flash("There was a problem with your submission", "errors")
else:
request.session.flash("%s saved!" % title, "messages")
if record is None:
record = ItemRecord(project, title)
record.title = title
form_controller.populate_record_from_request(record, request)
session = DBSession()
session.add(record)
session.flush()
if submit.find("add") >= 0:
route = "project:record:add"
elif submit.find("finish") >= 0:
route = "project:feedback_form"
else:
route = "project:record"
return HTTPFound(location=route_url(route, request, project_id=project.id, record_id=record.id))
return dict(
project=project,
menu=project_menu(project, request, "records"),
form_widgets=form_controller.render_widgets(request, record),
record=record,
)
def get_temp_user():
session = DBSession()
user = User()
session.add(user)
session.flush()
return user
def record_collect_thanks(request):
session = DBSession()
collect_code = request.matchdict['collect_code']
project = session.query(Project).filter(Project.collect_code == collect_code).first()
return dict(
project=project
)
def signup(request):
user = request.user
if user and not user.is_temporary():
raise StandardError, "You may not signup while logged in"
came_from = request.params.get('came_from', request.referer)
login_url = route_url('auth:login', request)
signup_url = route_url('auth:signup', request)
home_url = route_url('home', request)
if came_from in [login_url, signup_url, home_url]:
came_from = route_url('project:list', request)
name = request.params.get('name','')
email = request.params.get('email','')
password = request.params.get('password','')
password_confirm = request.params.get('password_confirm','')
if request.method == 'POST':
if not (name and email and password and password_confirm):
request.session.flash('Oops! Please complete all fields', 'signup_errors')
elif get_user(email=email):
request.session.flash('The e-mail address %s is already in use' % email, 'signup_errors')
elif password != password_confirm:
request.session.flash('Your passwords did not match', 'signup_errors')
else:
if user and user.is_temporary():
# user is logged in with a temporary account
# update the account information to transfer the current
# project
user.set_name(name)
user.set_email(email)
user.set_password(password)
location = came_from
else:
user = User(email, name, password)
location = came_from
session = DBSession()
session.add(user)
session.flush()
headers = remember(request, user.id)
return HTTPFound(
location=location,
headers=headers
)
return dict(
name=name,
email=email,
came_from=came_from
)
def process_type_options(self, request):
choices = request.params.getall('choices')
label = request.params.get('label',None)
self.widget.set_choices(choices)
self.widget.label = label
session = DBSession()
session.add(self.widget)
def populate_record_from_request(self, record, request):
session = DBSession()
value = session.query(MultipleChoiceValue).filter(Value.record==record).filter(Value.widget==self.widget).first()
if not value:
value = MultipleChoiceValue(record, self.widget)
value.set_value(request.params.get(self.field_id(), ''))
session.add(value)
def main():
conf = appconfig('config:/home/cspot/webapps/cspot/cspot/development.ini', name='main')
engine = engine_from_config(conf, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
Base.metadata.bind.echo = True
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
def get_users(self):
"""
Return user.id, user.name, user.email, user_role.role
"""
session = DBSession()
roles = session.query(User.name, User.email, User.id, User.last_login, User.temporary, ProjectUserRole.role).join(ProjectUserRole.user).filter(ProjectUserRole.project==self)
return roles
def populate_record_from_request(self, record, request):
session = DBSession()
value = (
session.query(ParagraphTextValue).filter(Value.record == record).filter(Value.widget == self.widget).first()
)
if not value:
value = ParagraphTextValue(record, self.widget)
value.set_value(request.params.get(self.field_id(), ""))
session.add(value)
def get_user(user_id=None, email=None, password_reset_key=None):
session = DBSession()
if user_id:
return session.query(User).filter(User.id==user_id).first()
elif email:
return session.query(User).filter(User.email==email.strip().lower()).first()
elif password_reset_key:
return session.query(User).filter(User.password_reset_key==password_reset_key).first()
else:
return None
def get_user_roles(self, user):
"""
Return the role names for a user in the context
of this project. Used by the authorization policy
via role_finder
"""
session = DBSession()
roles = session.query(ProjectUserRole).filter(ProjectUserRole.project==self).filter(ProjectUserRole.user==user)
return [r.role for r in roles.all()]
def project_factory(request):
"""
Generate a project from the project_id in the url
"""
session = DBSession()
project_id = request.matchdict.get('project_id', None)
if project_id:
return session.query(Project).filter(Project.id==project_id).first()
else:
return None
def user_factory(request):
"""
Generate a user from a profile url
"""
session = DBSession()
user_id = request.matchdict.get('user_id', None)
if user_id:
return session.query(User).filter(User.id==user_id).first()
else:
return request.user
def __init__(self, name, item_name, item_plural):
self.name = name
self.item_name = item_name
self.item_plural = item_plural
self.item_label = u"%s Name or Title" % item_name
self.collect_code = str(uuid4())
self.creation_date = datetime.now()
session = DBSession()
session.add(ItemForm(self))
session.add(FeedbackForm(self))
def project_delete(project, request):
if request.method != 'POST' or \
request.session.get_csrf_token() != request.POST['csrf_token']:
return HTTPFound(
location=route_url('project:settings',request,project_id=project.id)
)
else:
session = DBSession()
session.delete(project)
request.session.flash('%s deleted' % project.name, 'mesages')
return HTTPFound(
location=route_url('project:list',request)
)
def file_download(project, request):
"""
Download a file from a widget
"""
session = DBSession()
record_id = request.matchdict["record_id"]
widget_id = request.matchdict["widget_id"]
filename = request.matchdict["filename"]
record = session.query(Record).filter(Record.project_id == project.id).filter(Record.id == record_id).first()
widget = session.query(Widget).filter(Widget.id == widget_id).first()
widget_controller = widget_controller_factory(widget)
value = record.get_widget_value(widget)
return widget_controller.download(value, filename, request)
def widget_delete(project, request):
"""
Delete a widget from the current form
"""
session = DBSession()
form_id = request.matchdict.get('form_id', None)
form = session.query(Form).filter(Form.project_id==project.id).filter(Form.id==form_id).first()
widget_id = request.matchdict.get('widget_id', None)
widget = session.query(Widget).filter(Widget.form==form).filter(Widget.id==widget_id).first()
session = DBSession()
widget_controller = widget_controller_factory(widget)
widget_controller.delete()
return dict(
id=widget.id,
)
def populate_record_from_request(self, record, request):
session = DBSession()
value = session.query(FileUploadValue).filter(FileUploadValue.record==record).filter(FileUploadValue.widget==self.widget).first()
if value:
# Update the filenames based on the filenames
# included in the request
# XXX we should remove the files as well
old_filenames = value.get_filenames()
new_filenames = request.POST.getall(self.field_id() + '_filenames')
# remove any filename that wasn't already part
# of the value
for filename in new_filenames:
if filename not in old_filenames:
new_filenames.remove(filename)
value.set_filenames(new_filenames)
if self.field_id() in request.POST:
for file_upload in request.POST.getall(self.field_id()):
if hasattr(file_upload, 'filename'):
if not value:
value = FileUploadValue(record, self.widget)
session.add(value)
session.flush()
filename = file_upload.filename
file = file_upload.file
value.add_file(filename, file)
def widget_add(project, request):
"""
Adds a widget given a widget_type to the current
form
"""
session = DBSession()
form_id = request.matchdict.get('form_id', None)
form = session.query(Form).filter(Form.project_id==project.id).filter(Form.id==form_id).first()
widget_type = request.params.get('widget_type', None)
widget_model = widget_factory(widget_type)
widget = widget_model(form, 'Untitled')
session.add(widget)
session.flush()
widget_controller = widget_controller_factory(widget)
return dict(
id=widget.id,
type=widget_type,
widget_html=widget_controller.render(None, request),
data=widget_controller.data(),
)
def main():
conf = appconfig('config:/home/cspot/webapps/cspot/cspot/production.ini', name='main')
engine = engine_from_config(conf, 'sqlalchemy.')
DBSession.configure(bind=engine)
session = DBSession()
conn = session.connection()
# conn.execute('alter table projects add reviewed')
files = conn.execute("select id, filename from `values` where type = 'file'")
for id, filename in files.fetchall():
if filename:
files = [filename]
else:
files = []
conn.execute("update `values` set text_value = %s where id = %s", simplejson.dumps(files), id)
print id, files
mark_changed(session)
transaction.commit()
def remove_user(self, user):
"""
Remove a user from the project
"""
session = DBSession()
roles = session.query(ProjectUserRole).filter(ProjectUserRole.project==self).filter(ProjectUserRole.user==user)
for role in roles.all():
session.delete(role)
session.flush()
def record_collect(request):
session = DBSession()
collect_code = request.matchdict['collect_code']
project = session.query(Project).filter(Project.collect_code == collect_code).first()
form_controller = FormController(project.item_form)
if request.method == 'POST':
title = request.params.get('title', '').strip()
submit = request.params.get('submit','')
if not title and submit.find('finish') >= 0:
return HTTPFound(
location=route_url('project:collect', request, project_id=project.id)
)
elif not title:
request.session.flash('%s Name or Title is required!' % project.item_name, 'errors')
elif title:
form_controller = FormController(project.item_form)
form_controller.validate_from_request(request)
if form_controller.errors:
request.session.flash('There was a problem with your submission', 'errors')
else:
record = ItemRecord(project, title)
record.title = title
record.reviewed = False
form_controller.populate_record_from_request(record, request)
session.add(record)
session.flush()
return HTTPFound(
location=route_url('project:collect:thanks', request, collect_code=project.collect_code)
)
return dict(
project=project,
form_widgets=form_controller.render_widgets(request, None)
)
def get_users_by_role(self, role):
session = DBSession()
roles = session.query(ProjectUserRole).filter(ProjectUserRole.project==self).filter(ProjectUserRole.role==role)
return [r.user for r in roles]
def get_widget_value(self, widget):
session = DBSession()
return session.query(Value).filter(Value.record==self).filter(Value.widget==widget).first()
def projects_add(request):
"""
Add a project owned by the current user
if a user is not logged in create a temporary user
and associate the project with that user
"""
session = DBSession()
title = request.params.get('title','')
template_id = request.params.get('template_id', '')
item_plural = request.params.get('item_plural','').capitalize()
templates = session.query(Project).filter(Project.template==True).all()
if request.method == 'POST':
if request.user and request.user.projects_remaining() <= 0:
# Cannot add a project if you own more than
# your plan allows for.
return HTTPFound(
location=route_url('project:add', request)
)
if template_id != 'other':
template = session.query(Project).filter(Project.template==True).filter(Project.id==template_id).first()
else:
template = None
if not title:
request.session.flash('Oops! Please complete all fields to continue', 'errors')
elif template:
# Create a new project from a template
if not request.user:
user = get_temp_user()
headers = remember(request, user.id)
else:
user = request.user
headers = None
project = Project(title, 'item', 'items')
project.add_user(user, 'owner')
template.copy_to(project)
for widget in template.item_form.widgets:
widget_class = widget_factory(widget.widget_type)
new_widget = widget_class(project.item_form, 'widget')
widget.copy_to(new_widget)
for widget in template.feedback_form.widgets:
widget_class = widget_factory(widget.widget_type)
new_widget = widget_class(project.feedback_form, 'widget')
widget.copy_to(new_widget)
session.add(project)
session.flush()
return HTTPFound(
location=route_url('project:records', request, project_id=project.id),
headers=headers
)
elif item_plural:
# Create a custom project from an item name
item_name = plural_to_singular(item_plural)
if not request.user:
user = get_temp_user()
headers = remember(request, user.id)
else:
user = request.user
headers = None
project = Project(title, item_name, item_plural)
project.add_user(user, 'owner')
documents_field = FileUploadWidget(project.item_form, 'Documents')
rate_question = MultipleChoiceWidget(project.feedback_form, 'Rate this %s' % (project.item_name))
rate_question.set_choices(['Very Good', 'Good', 'Average', 'Poor', 'Very Poor'])
comments_question = ParagraphTextWidget(project.feedback_form, 'Comments')
session.add(project)
session.flush()
return HTTPFound(
location=route_url('project:records', request, project_id=project.id),
headers=headers
)
return dict(
title=title,
item_plural=item_plural,
templates=templates,
)
def process_type_options(self, request):
label = request.params.get('label',None)
self.widget.label = label
session = DBSession()
session.add(self.widget)
