def _send_signup_email(request, invitation):
site = find_site(request.context)
mailer = getUtility(IMailDelivery)
info = {}
info['system_name'] = get_setting(site, 'system_name', 'OpenCore')
info['system_email_domain'] = get_setting(site, 'system_email_domain')
info['from_name'] = '%s invitation' % info['system_name']
info['from_email'] = 'invitation@%s' % info['system_email_domain']
info['c_title'] = info['system_name']
info['c_description'] = ""
info['c_href'] = model_url(site, request)
info['mfrom'] = '%s <%s>' % (info['from_name'], info['from_email'])
info['subject'] = 'Please join the %s community' % info['system_name']
body_template = get_template('templates/email_signup.pt')
msg = Message()
msg['From'] = info['mfrom']
msg['To'] = invitation.email
msg['Subject'] = info['subject']
body = body_template(
system_name=info['system_name'],
personal_message=invitation.message,
invitation_url=model_url(site, request, 'signup', invitation.__name__)
)
if isinstance(body, unicode):
body = body.encode("UTF-8")
msg.set_payload(body, "UTF-8")
msg.set_type('text/html')
mailer.send(info['mfrom'], [invitation.email,], msg)
def add_referencemanual_view(context, request):
tags_list=request.POST.getall('tags')
form = AddReferenceManualForm(tags_list=tags_list)
if 'form.cancel' in request.POST:
return HTTPFound(location=model_url(context, request))
if 'form.submitted' in request.POST:
try:
converted = form.validate(request.POST)
# Create the reference manual and store it
creator = authenticated_userid(request)
reference_manual = create_content(IReferenceManual,
converted['title'],
converted['description'],
creator,
)
name = make_unique_name(context, converted['title'])
context[name] = reference_manual
# Save the tags on it.
set_tags(reference_manual, request, converted['tags'])
location = model_url(reference_manual, request)
return HTTPFound(location=location)
except Invalid, e:
fielderrors = e.error_dict
fill_values = form.convert(request.POST)
tags_field = dict(
records = [dict(tag=t) for t in request.POST.getall('tags')]
)
def edit_referencesection_view(context, request):
tags_list = request.POST.getall('tags')
form = EditReferenceSectionForm(tags_list=tags_list)
if 'form.cancel' in request.POST:
return HTTPFound(location=model_url(context, request))
if 'form.submitted' in request.POST:
try:
converted = form.validate(request.POST)
# *will be* modified event
objectEventNotify(ObjectWillBeModifiedEvent(context))
context.title = converted['title']
context.description = converted['description']
# Save the tags on it
set_tags(context, request, converted['tags'])
# Modified
context.modified_by = authenticated_userid(request)
objectEventNotify(ObjectModifiedEvent(context))
location = model_url(context, request)
msg = "?status_message=Reference%20section%20edited"
return HTTPFound(location=location+msg)
except Invalid, e:
fielderrors = e.error_dict
fill_values = form.convert(request.POST)
def report_view(context, request):
client_json_data = {
'grid_data': get_grid_data(context, request),
}
api = TemplateAPI(context, request, context.title)
peopledir = find_peopledirectory(context)
section = context.__parent__
peopledir_tabs = get_tabs(peopledir, request, section.__name__)
mgr = ILetterManager(context)
letter_info = mgr.get_info(request)
kw, qualifiers = get_search_qualifiers(request)
descriptions = get_report_descriptions(context)
print_url = model_url(context, request, 'print.html', **kw)
csv_url = model_url(context, request, 'csv', **kw)
pictures_url = model_url(context, request, 'picture_view.html', **kw)
opensearch_url = model_url(context, request, 'opensearch.xml')
return render_template_to_response(
'templates/people_report.pt',
api=api,
peopledir=peopledir,
peopledir_tabs=peopledir_tabs,
head_data=convert_to_script(client_json_data),
descriptions=descriptions,
letters=letter_info,
print_url=print_url,
csv_url=csv_url,
pictures_url=pictures_url,
qualifiers=qualifiers,
opensearch_url=opensearch_url,
actions=get_actions(context, request),
)
def calendar_setup_view(context, request):
default_category_name = ICalendarCategory.getTaggedValue('default_name')
categories = filter(lambda x: x.__name__ != default_category_name,
_get_calendar_categories(context))
default_layer_name = ICalendarLayer.getTaggedValue('default_name')
layers = filter(lambda x: x.__name__ != default_layer_name,
_get_calendar_layers(context))
fielderrors = {}
fielderrors_target = None
page_title = 'Calendar Setup'
api = TemplateAPI(context, request, page_title)
return render_template_to_response(
'templates/calendar_setup.pt',
back_to_calendar_url=model_url(context, request),
categories_url=model_url(context, request, 'categories.html'),
layers_url=model_url(context, request, 'layers.html'),
formfields=api.formfields,
fielderrors=fielderrors,
fielderrors_target = fielderrors_target,
api=api,
editable_categories = categories,
editable_layers = layers,
all_categories = _get_all_calendar_categories(context, request),
colors = _COLORS,
)
def __init__(self, context, request, page_title=None):
self.context = context
self.request = request
self.snippets = get_template("templates/snippets.pt")
self.snippets.doctype = xhtml
self.userid = authenticated_userid(request)
self.app_url = app_url = request.application_url
self.profile_url = app_url + "/profiles/%s" % self.userid
self.here_url = self.context_url = model_url(context, request)
self.view_url = model_url(context, request, request.view_name)
settings = queryUtility(ISettings)
self.js_devel_mode = settings and getattr(settings, "js_devel_mode", None)
self.static_url = "%s/static/%s" % (app_url, _get_static_rev())
# Provide a setting in the INI to fully control the entire URL
# to the static. This is when the proxy runs a different port
# number, or to "pipeline" resources on a different URL path.
full_static_path = getattr(settings, "full_static_path", False)
if full_static_path:
if "%d" in full_static_path:
full_static_path = full_static_path % _start_time
self.static_url = full_static_path
self.page_title = page_title
self.system_name = get_setting(context, "system_name", "KARL")
self.user_is_admin = "group.KarlAdmin" in effective_principals(request)
site = find_site(context)
self.admin_url = model_url(site, request, "admin.html")
self.site_announcement = getattr(site, "site_announcement", "")
def forbidden(context, request):
site = find_site(context)
environ = request.environ
referrer = environ.get('HTTP_REFERER', '')
if 'repoze.who.identity' in environ:
# the user is authenticated but he is not allowed to access this
# resource
api = TemplateAPI(context, request, 'Forbidden')
response = render_template_to_response(
'templates/forbidden.pt',
api=api,
login_form_url = model_url(site, request, 'login.html'),
homepage_url = model_url(site, request),
)
response.status = '403 Forbidden'
return response
elif '/login.html' in referrer:
url = request.url
# this request came from a user submitting the login form
login_url = model_url(site, request, 'login.html',
query={'reason':'Bad username or password',
'came_from':url})
return HTTPFound(location=login_url)
else:
# the user is not authenticated and did not come in as a result of
# submitting the login form
url = request.url
query = {'came_from':url}
while url.endswith('/'):
url = url[:-1]
if url != request.application_url: # if request isnt for homepage
query['reason'] = 'Not logged in'
login_url = model_url(site, request, 'login.html', query=query)
return HTTPFound(location=login_url)
def get_previous_next(context, request):
# Reference Manual sections have inter-item navigation, which
# means (sigh) that files and pages do as well.
# Only works on resources whose parents are orderable
parent = context.__parent__
ordering = getattr(parent, 'ordering', None)
if ordering is None:
return None, None
# Be a chicken and sync
ordering.sync(parent.keys())
# Find the prev/next names, then flatten some info about them for
# the ZPT
current_name = context.__name__
previous = parent.get(ordering.previous_name(current_name))
next = parent.get(ordering.next_name(current_name))
if previous:
previous = {'title': previous.title,
'href': model_url(previous, request)}
if next:
next = {'title': next.title,
'href': model_url(next, request)}
return previous, next
def lock_info_for_view(context, request, from_time=None):
"""return a structure suitable for displaying in a template"""
if is_locked(context, from_time):
lock = lock_info(context)
userid = lock['userid']
profiles = find_profiles(context)
profile = profiles.get(userid, None)
if profile is not None:
return dict(
is_locked = True,
url = model_url(profile, request),
name = '%s %s' % (profile.firstname,
profile.lastname),
email = profile.email,
)
else:
return dict(
is_locked = True,
url = model_url(profiles, request),
name = 'Unknown',
email = '',
)
else:
return dict(
is_locked = False,
url = None,
name = None,
email = None,
)
def _add_existing_users(context, community, profiles, text, request, status=None):
users = find_users(community)
for profile in profiles:
group_name = community.members_group_name
user_name = profile.__name__
users.add_group(user_name, group_name)
# Generate HTML and text mail messages and send a mail for
# each user added to the community.
community_href = model_url(community, request)
_send_aeu_emails(community, community_href, profiles, text)
# We delivered invitation messages to each user. Redirect to
# Manage Members with a status message.
n = len(profiles)
if n == 1:
msg = 'One member added and email sent.'
else:
fmt = '%s members added and emails sent.'
msg = fmt % len(profiles)
if status:
msg = msg + ' ' + status
if request.POST.get('return_to') is not None:
location = request.POST['return_to']
return render_template_to_response('templates/javascript_redirect.pt',
url=location)
else:
location = model_url(context, request, 'manage.html',
query={'status_message': msg})
return HTTPFound(location=location)
def pages_view(context, request):
page_urls = [(context[p].dublincore['title'],
model_url(context, request, p))
for p in request.context.keys()]
return {'project': PROJECT,
'page_urls': page_urls,
'page_add_url': model_url(context, request, "@@page_add")
}
def edit_page(context, request):
if 'form.submitted' in request.params:
context.data = request.params['body']
return HTTPFound(location = model_url(context, request))
logged_in = authenticated_userid(request)
return dict(page = context, logged_in=logged_in,
save_url = model_url(context, request, 'edit_page'))
def calendar_setup_layers_view(context, request):
form = CalendarLayersForm()
default_layer_name = ICalendarLayer.getTaggedValue('default_name')
layers = filter(lambda x: x.__name__ != default_layer_name,
_get_calendar_layers(context))
layer_titles = [ x.title for x in layers]
layer_names = [ x.__name__ for x in layers ]
default_category_name = ICalendarCategory.getTaggedValue('default_name')
categories = filter(lambda x: x.__name__ != default_category_name,
_get_calendar_categories(context))
if 'form.delete' in request.POST:
layer_name = request.POST['form.delete']
if layer_name == default_layer_name:
message = 'Cannot delete default layer'
elif layer_name and layer_name in layer_names:
title = context[layer_name].title
del context[layer_name]
message = '%s layer removed' % title
else:
message = 'Layer is invalid'
location = model_url(context, request, 'layers.html',
query={'status_message': message})
return HTTPFound(location=location)
fielderrors_target = None
fielderrors = {}
if 'form.submitted' in request.POST:
try:
converted = form.validate(request.POST)
category_paths = list(set(request.POST.getall('category_paths')))
layer_name = generate_name(context)
layer_title = converted['layer_title']
layer_color = converted['layer_color']
if layer_title in layer_titles:
msg = "Name is already used"
raise Invalid(value=layer_title, state=None,
msg=msg, error_list=None,
error_dict={'layer_title': msg})
layer = create_content(ICalendarLayer,
layer_title, layer_color, category_paths)
context[layer_name] = layer
location = model_url(
context, request,
'layers.html',
query={'status_message':'Calendar layer added'})
return HTTPFound(location=location)
except Invalid, e:
fielderrors_target = '__add_layer__'
fielderrors = e.error_dict
def journal_add_view(context, request):
if IJournalEntry.providedBy(context):
entry = context
project = context.__parent__.__parent__
add_form = False
else:
entry = JournalEntry()
project = context
add_form = True
errors = {}
defaults = {}
if 'form.submitted' in request.POST:
try:
# FormEncode validation
defaults = dict(request.POST)
defaults['indicators'] = request.POST.get('indicators')
form_result = entry_schema.to_python(request.POST)
except formencode.validators.Invalid, why:
errors = why.error_dict
else:
session = DBSession()
# Handle image upload
if form_result['image'] is not None:
entry.image = File('image.jpg', form_result['image'].read())
elif form_result['image_action'] == 'delete' and entry.image:
session.delete(entry.image)
entry.date = datetime.now()
entry.text = form_result['text']
entry.user = authenticated_user(request)
# Check whether indicator belongs to this project.
indicator_query = session.query(Indicator)
indicator_query = indicator_query.filter(Project.id == project.id)
indicator_query = indicator_query.join(Project.objectives)
indicator_query = indicator_query.join(Objective.competences)
indicator_query = indicator_query.join(Competence.indicator_sets)
indicator_query = indicator_query.join(IndicatorSet.indicators)
if form_result['indicators']:
indicator_query = indicator_query.filter(
Indicator.id.in_(form_result['indicators']))
indicators = indicator_query.all()
entry.indicators = indicators
if add_form:
project.journal_entries.append(entry)
if ITeacher.providedBy(authenticated_user(request)):
return HTTPFound(location=model_url(
get_root(request)['projects'][project.id], request))
return HTTPFound(
location=model_url(authenticated_user(request), request))
def jquery_livesearch_view(context, request):
# Prefix search is with a wildcard at the end
searchterm = request.params.get("val", None)
if searchterm is None:
# The request forgot to send the key we use to do a search, so
# make a friendly error message. Important for the unit test.
msg = "Client failed to send a 'val' parameter as the searchterm"
return HTTPBadRequest(msg)
else:
searchterm = searchterm + "*"
records = LivesearchResults()
principals = effective_principals(request)
site_path = model_path(context)
records.set_header("", pre='<div class="header"></div>')
records.append_to(
rowclass="showall",
title="Show All",
href=model_url(context, request, "searchresults.html", query={"body": searchterm}),
)
for listitem in get_listitems(IGroupSearchFactory):
utility = listitem["component"]
factory = utility(context, request, searchterm)
if factory is None:
continue
try:
num, docids, resolver = factory()
except ParseError:
continue
groupname = listitem["title"]
records.set_header(groupname, pre='<div class="header">%s</div>' % (groupname,))
results = filter(None, map(resolver, docids))
qs = {"body": searchterm, "kind": groupname}
sr_href = model_url(context, request, "searchresults.html", query=qs)
for result in results:
records.append_to(
rowclass="result", title=getattr(result, "title", "<No Title>"), href=model_url(result, request)
)
if results:
records.append_to(rowclass="showall", title="Show All", href=sr_href)
else:
records.append_to(rowclass="noresult", title="No Result", href=sr_href)
result = JSONEncoder().encode(list(records))
return Response(result, content_type="application/x-json")
def __call__(self):
context, request = self.context, self.request
api = AdminTemplateAPI(context, request, "Admin UI: Send Email")
admin_email = get_setting(context, "admin_email")
system_name = get_setting(context, "system_name")
profiles = find_profiles(context)
admin = profiles[authenticated_userid(request)]
from_emails = [
("self", "%s <%s>" % (admin.title, admin.email)),
("admin", "%s Administrator <%s>" % (system_name, admin_email)),
]
if "send_email" in request.params:
mailer = getUtility(IMailDelivery)
group = request.params["to_group"]
users = find_users(context)
search = ICatalogSearch(context)
count, docids, resolver = search(interfaces=[IProfile])
n = 0
for docid in docids:
profile = resolver(docid)
if getattr(profile, "security_state", None) == "inactive":
continue
userid = profile.__name__
if group and not users.member_of_group(userid, group):
continue
message = Message()
if request.params["from_email"] == "self":
message["From"] = from_emails[0][1]
message_from = admin.email
else:
message["From"] = from_emails[1][1]
message_from = admin_email
message["To"] = "%s <%s>" % (profile.title, profile.email)
message["Subject"] = request.params["subject"]
body = u"<html><body>%s</body></html>" % (request.params["text"])
message.set_payload(body.encode("UTF-8"), "UTF-8")
message.set_type("text/html")
mailer.send([profile.email], message)
n += 1
status_message = "Sent message to %d users." % n
if has_permission(ADMINISTER, context, request):
redirect_to = model_url(context, request, "admin.html", query=dict(status_message=status_message))
else:
redirect_to = model_url(
find_communities(context),
request,
"all_communities.html",
query=dict(status_message=status_message),
)
return HTTPFound(location=redirect_to)
return dict(api=api, menu=_menu_macro(), to_groups=self.to_groups, from_emails=from_emails)
def application_view(context, request):
user = authenticated_user(request)
if user:
if ITeacher.providedBy(user):
return HTTPFound(location=model_url(context, request, "dashboard.html"))
return HTTPFound(location=model_url(user, request))
return HTTPFound(location=model_url(context, request, "login.html"))
def redirector_view(context, request):
where = context.target_url
if not where.startswith('http'):
if where.startswith('/'):
where = basejoin(model_url(context, request), where)
else:
elements = where.split('/')
where = model_url(context.__parent__, request, *elements)
return HTTPFound(location=where)
def change_password_view(context, request):
min_pw_length = get_setting(context, 'min_pw_length')
form = ChangePasswordForm(min_pw_length=min_pw_length)
if 'form.cancel' in request.POST:
return HTTPFound(location=model_url(context, request))
if 'form.submitted' in request.POST:
try:
converted = form.validate(request.POST)
users = find_users(context)
userid = context.__name__
user = users.get_by_id(userid)
# check the old password
# XXX: repoze.who.plugins.zodb.interfaces.IUsers
# really should have a check_password(id, password)
# method. We shouldn't have to use get_sha_password
# directly.
enc = get_sha_password(converted['old_password'])
if enc != user['password']:
raise CustomInvalid({'old_password': '******'})
users.change_password(userid, converted['password'])
# send email
system_name = get_setting(context, 'system_name', 'KARL')
mail = karl.mail.Message()
admin_email = get_setting(context, 'admin_email')
mail["From"] = "%s Administrator <%s>" % (system_name, admin_email)
mail["To"] = "%s <%s>" % (context.title, context.email)
mail["Subject"] = "%s Password Change Notification" % system_name
system_name = get_setting(context, 'system_name', 'KARL')
body = render_template(
"templates/email_change_password.pt",
login=user['login'],
password=converted['password'],
system_name=system_name,
)
if isinstance(body, unicode):
body = body.encode("UTF-8")
mail.set_payload(body, "UTF-8")
mail.set_type("text/html")
recipients = [context.email]
mailer = getUtility(IMailDelivery)
mailer.send(admin_email, recipients, mail)
path = model_url(context, request)
msg = '?status_message=Password%20changed'
return HTTPFound(location=path+msg)
except Invalid, e:
fielderrors = e.error_dict
fill_values = form.convert(request.POST)
def members_view(context, request):
session = DBSession()
all_students = session.query(Student).all()
all_students = [
student for student in all_students if not student in context.students
]
all_teachers = session.query(Teacher).all()
all_teachers = [
teacher for teacher in all_teachers if not teacher in context.teachers
]
if 'form.submitted' in request.POST:
student_id = request.POST.get('student_id', None)
if student_id:
student = session.query(Student).filter_by(id=student_id).first()
if student:
context.students.append(student)
teacher_id = request.POST.get('teacher_id', None)
if teacher_id:
teacher = session.query(Teacher).filter_by(id=teacher_id).first()
if teacher:
context.teachers.append(teacher)
return HTTPFound(location=model_url(context, request, 'members.html'))
# This should be a post request, but it has to be finished today ...
elif 'remove_student' in request.GET:
student_id = request.GET.get('remove_student', None)
if student_id:
student = context.students.filter_by(id=student_id).first()
if student:
context.students.remove(student)
return HTTPFound(location=model_url(context, request, 'members.html'))
elif 'remove_teacher' in request.GET:
teacher_id = request.GET.get('remove_teacher', None)
if teacher_id:
teacher = context.teachers.filter_by(id=teacher_id).first()
if teacher:
context.teachers.remove(teacher)
return HTTPFound(location=model_url(context, request, 'members.html'))
root = get_root(request)
students = []
for student in context.students:
students.append(root['users'][student.id])
teachers = []
for teacher in context.teachers:
teachers.append(root['users'][teacher.id])
return dict(api=TemplateAPI(request),
context=context,
students=students,
all_students=all_students,
teachers=teachers,
all_teachers=all_teachers)
def page_view(context, request):
dc_schema = DublinCoreSchema()
dc_form = Form(dc_schema)
dc_form['subject'].widget.category = None # HACK: display sequence label
return {'project': PROJECT,
'page': context,
'dc_form': dc_form.render(context.dublincore, readonly=True),
'page_edit_url': model_url(context, request, "@@page_edit"),
'page_edit_dc_url': model_url(context, request, "@@page_edit_dc")
}
def status_response(self, msg):
location = model_url(self.parent, self.request)
if IComment.providedBy(self.context):
# for comment replies we need the location of the real container
# like forum topic or profile or community
log.debug('commenting status_response: reply context=%s, grandparent=%s' % (self.context, self.parent.__parent__))
location = model_url(self.parent.__parent__, self.request)
location = '%s?status_message=%s' % (location, urllib.quote(msg))
return HTTPFound(location=location)
def application_view(context, request):
user = authenticated_user(request)
if user:
if ITeacher.providedBy(user):
return HTTPFound(
location=model_url(context, request, 'dashboard.html'))
return HTTPFound(location=model_url(user, request))
return HTTPFound(location=model_url(context, request, 'login.html'))
def journal_add_view(context, request):
if IJournalEntry.providedBy(context):
entry = context
project = context.__parent__.__parent__
add_form = False
else:
entry = JournalEntry()
project = context
add_form = True
errors = {}
defaults = {}
if 'form.submitted' in request.POST:
try:
# FormEncode validation
defaults = dict(request.POST)
defaults['indicators'] = request.POST.get('indicators')
form_result = entry_schema.to_python(request.POST)
except formencode.validators.Invalid, why:
errors=why.error_dict
else:
session = DBSession()
# Handle image upload
if form_result['image'] is not None:
entry.image = File('image.jpg', form_result['image'].read())
elif form_result['image_action'] == 'delete' and entry.image:
session.delete(entry.image)
entry.date = datetime.now()
entry.text = form_result['text']
entry.user = authenticated_user(request)
# Check whether indicator belongs to this project.
indicator_query = session.query(Indicator)
indicator_query = indicator_query.filter(Project.id == project.id)
indicator_query = indicator_query.join(Project.objectives)
indicator_query = indicator_query.join(Objective.competences)
indicator_query = indicator_query.join(Competence.indicator_sets)
indicator_query = indicator_query.join(IndicatorSet.indicators)
if form_result['indicators']:
indicator_query = indicator_query.filter(Indicator.id.in_(form_result['indicators']))
indicators = indicator_query.all()
entry.indicators = indicators
if add_form:
project.journal_entries.append(entry)
if ITeacher.providedBy(authenticated_user(request)):
return HTTPFound(location = model_url(get_root(request)['projects'][project.id], request))
return HTTPFound(location = model_url(authenticated_user(request), request))
def url(self):
if self._url is None:
if IComment.providedBy(self.context):
# show the comment in context of its grandparent.
# (its parent is a comments folder.)
parent = self.context.__parent__.__parent__
self._url = '%s#comment-%s' % (
model_url(parent, self.request), self.context.__name__)
else:
self._url = model_url(self.context, self.request)
return self._url
def show_forum_view(context, request):
page_title = context.title
api = request.api
actions = []
if has_permission('create', context, request):
actions.append(('Add Forum Topic', 'add_forum_topic.html'))
if has_permission('edit', context, request):
actions.append(('Edit', 'edit.html'))
if has_permission('delete', context, request):
actions.append(('Delete', 'delete.html'))
profiles = find_profiles(context)
appdates = getUtility(IAppDates)
topic_batch = get_topic_batch(context, request)
topic_entries = topic_batch['entries']
topics = []
for topic in topic_entries:
D = {}
profile = profiles.get(topic.creator)
posted_by = getattr(profile, 'title', None)
date = appdates(topic.created, 'longform')
D['url'] = model_url(topic, request)
D['title'] = topic.title
D['posted_by'] = posted_by
D['date'] = date
D['number_of_comments'] = len(topic['comments'])
topics.append(D)
# In the intranet side, the backlinks should go to the show_forums
# view (the default)
forums = context.__parent__
backto = {
'href': model_url(forums, request),
'title': forums.title,
}
# Get a layout
layout_provider = get_layout_provider(context, request)
layout = layout_provider('generic')
return render_template_to_response(
'templates/show_forum.pt',
api = api,
actions = actions,
title = context.title,
topics = topics,
batch_info = topic_batch,
backto=backto,
layout=layout,
)
def show_forum_topic_view(context, request):
post_url = model_url(context, request, "comments", "add_comment.html")
page_title = context.title
actions = []
if has_permission('edit', context, request):
actions.append(('Edit', 'edit.html'))
if has_permission('delete', context, request):
actions.append(('Delete', 'delete.html'))
api = request.api
api.page_title = page_title
byline_info = getMultiAdapter((context, request), IBylineInfo)
forum = find_interface(context, IForum)
backto = {
'href': model_url(forum, request),
'title': forum.title,
}
# provide client data for rendering current tags in the tagbox
client_json_data = dict(
tagbox = get_tags_client_data(context, request),
)
# Get a layout
layout_provider = get_layout_provider(context, request)
layout = layout_provider('community')
if support_attachments(context):
attachments = fetch_attachments(context['attachments'], request)
else:
attachments = ()
# enable imagedrawer for adding forum replies (comments)
api.karl_client_data['text'] = dict(
enable_imagedrawer_upload = True,
)
return render_template_to_response(
'templates/show_forum_topic.pt',
api=api,
actions=actions,
comments=comments_to_display(request),
attachments=attachments,
formfields=api.formfields,
post_url=post_url,
byline_info=byline_info,
head_data=convert_to_script(client_json_data),
backto=backto,
layout=layout,
comment_form={},
)
def members_view(context, request):
session = DBSession()
all_students = session.query(Student).all()
all_students = [student for student in all_students if not student in context.students]
all_teachers = session.query(Teacher).all()
all_teachers = [teacher for teacher in all_teachers if not teacher in context.teachers]
if 'form.submitted' in request.POST:
student_id = request.POST.get('student_id', None)
if student_id:
student = session.query(Student).filter_by(id=student_id).first()
if student:
context.students.append(student)
teacher_id = request.POST.get('teacher_id', None)
if teacher_id:
teacher = session.query(Teacher).filter_by(id=teacher_id).first()
if teacher:
context.teachers.append(teacher)
return HTTPFound(location = model_url(context, request, 'members.html'))
# This should be a post request, but it has to be finished today ...
elif 'remove_student' in request.GET:
student_id = request.GET.get('remove_student', None)
if student_id:
student = context.students.filter_by(id=student_id).first()
if student:
context.students.remove(student)
return HTTPFound(location = model_url(context, request, 'members.html'))
elif 'remove_teacher' in request.GET:
teacher_id = request.GET.get('remove_teacher', None)
if teacher_id:
teacher = context.teachers.filter_by(id=teacher_id).first()
if teacher:
context.teachers.remove(teacher)
return HTTPFound(location = model_url(context, request, 'members.html'))
root = get_root(request)
students = []
for student in context.students:
students.append(root['users'][student.id])
teachers = []
for teacher in context.teachers:
teachers.append(root['users'][teacher.id])
return dict(api=TemplateAPI(request),
context=context,
students=students,
all_students=all_students,
teachers=teachers,
all_teachers=all_teachers)
def logout_view(context, request, reason='Logged out'):
site = find_site(context)
site_url = model_url(site, request)
login_url = model_url(site, request, 'login.html', query={
'reason': reason, 'came_from': site_url})
redirect = HTTPFound(location=login_url)
plugins = request.environ.get('repoze.who.plugins', {})
auth_tkt = plugins.get('auth_tkt')
if auth_tkt is not None:
forget_headers = auth_tkt.forget(request.environ, {})
redirect.headers.update(forget_headers)
return redirect
def __call__(self):
context = self.context
request = self.request
page_title = context.title
api = request.api
api.page_title = page_title
appdates = getUtility(IAppDates)
actions = []
if has_permission('create', context, request):
actions = self._admin_actions
forums = list(context.values())
forums.sort(titlesort)
forum_data = []
for forum in forums:
D = {}
D['title'] = forum.title
D['url'] = model_url(forum, request)
D['number_of_topics'] = number_of_topics(forum)
D['number_of_comments'] = number_of_comments(forum, request)
latest = latest_object(forum, request)
_NOW = datetime.datetime.now()
if latest:
D['latest_activity_url'] = model_url(latest, request)
D['latest_activity_link'] = getattr(latest, 'title', None)
D['latest_activity_by'] = getattr(latest, 'creator', None)
modified = getattr(latest, 'modified_date', _NOW)
modified_str = appdates(modified, 'longform')
D['latest_activity_at'] = modified_str
else:
D['latest_activity_url'] = None
D['latest_activity_link'] = None
D['latest_activity_by'] = None
D['latest_activity_at'] = None
forum_data.append(D)
return render_template_to_response(
'templates/show_forums.pt',
api=api,
actions=actions,
forum_data = forum_data,
layout = self.layout
)
def handle_submit(self, converted):
context = self.context
community = self.community
request = self.request
users = find_users(context)
profiles = self.profiles
password = converted['password']
password_confirm = converted['password_confirm']
if password != password_confirm:
msg = 'Mismatched password and confirm'
raise ValidationError(password_confirm=msg, password=msg)
username = converted['username']
if username in profiles:
raise ValidationError(username='******')
community_href = model_url(community, request)
groups = [ community.members_group_name ]
users.add(username, username, password, groups)
plugin = request.environ['repoze.who.plugins']['auth_tkt']
identity = {'repoze.who.userid':username}
remember_headers = plugin.remember(request.environ, identity)
profile = create_content(
IProfile,
firstname=converted['firstname'],
lastname=converted['lastname'],
email=context.email,
phone=converted['phone'],
extension=converted['extension'],
department=converted['department'],
position=converted['position'],
organization=converted['organization'],
location=converted['location'],
country=converted['country'],
website=converted['website'],
languages=converted['languages']
)
profiles[username] = profile
workflow = get_workflow(IProfile, 'security')
if workflow is not None:
workflow.initialize(profile)
handle_photo_upload(profile, converted, thumbnail=True)
del context.__parent__[context.__name__]
url = model_url(community, request,
query={'status_message':'Welcome!'})
_send_ai_email(community, community_href, username, profile)
self.filestore.clear()
return HTTPFound(headers=remember_headers, location=url)
def advanced_folder_view(context, request):
page_title = 'Advanced Settings For ' + context.title
api = TemplateAPI(context, request, page_title)
if 'form.cancel' in request.POST:
return HTTPFound(location=model_url(context, request))
if 'form.submitted' in request.POST:
marker = request.POST.get('marker', False)
if marker == 'reference_manual':
alsoProvides(context, IReferencesFolder)
noLongerProvides(context, INetworkNewsMarker)
noLongerProvides(context, INetworkEventsMarker)
elif marker == 'network_news':
alsoProvides(context, INetworkNewsMarker)
noLongerProvides(context, IReferencesFolder)
noLongerProvides(context, INetworkEventsMarker)
elif marker == 'network_events':
alsoProvides(context, INetworkEventsMarker)
noLongerProvides(context, IReferencesFolder)
noLongerProvides(context, INetworkNewsMarker)
if marker:
location = model_url(context, request, query=
{'status_message': 'Marker changed'})
return HTTPFound(location=location)
# Get a layout
layout_provider = get_layout_provider(context, request)
layout = layout_provider('community')
if IReferencesFolder.providedBy(context):
selected = 'reference_manual'
elif INetworkNewsMarker.providedBy(context):
selected = 'network_news'
elif INetworkEventsMarker.providedBy(context):
selected = 'network_events'
else:
selected = None
return render_template_to_response(
'templates/advanced_folder.pt',
api=api,
actions=[],
formfields=api.formfields,
post_url=model_url(context, request, 'advanced.html'),
layout=layout,
fielderrors={},
selected=selected,
)
def message(self):
if self._message is not None:
return self._message
community = self._community
request = self.request
profile = self.profile
model = self._model
community_href = model_url(community, request)
model_href = model_url(model, request)
manage_preferences_href = model_url(profile, request)
system_name = get_setting(self.context, "system_name", "KARL")
system_email_domain = get_setting(self.context, "system_email_domain")
body_template = get_template(self._template)
from_name = "%s | %s" % (self.creator.title, system_name)
msg = Message()
msg["From"] = "%s <%s>" % (from_name, self.mfrom)
msg["To"] = "%s <%s>" % (community.title, profile.email)
msg["Subject"] = self._subject
body = body_template(
context=self.context,
community=community,
community_href=community_href,
model=model,
model_href=model_href,
manage_preferences_href=manage_preferences_href,
profile=profile,
creator=self.creator,
content_type=self._content_type_name,
digest=self.digest,
alert=self,
)
if self.digest:
# Only interested in body for digest
html = document_fromstring(body)
body_element = html.cssselect('body')[0]
span = etree.Element("span", nsmap=body_element.nsmap)
span[:] = body_element[:] # Copy all body elements to an empty span
body = etree.tostring(span, pretty_print=True)
if isinstance(body, unicode):
body = body.encode('utf-8')
msg.set_payload(body, 'utf-8')
msg.set_type("text/html")
self._message = msg
return msg
def logged_in_view(context, request):
user = authenticated_user(request)
# Direct to the url of the "home" menu item which is user type specific.
home_entry = get_current_registry().queryMultiAdapter((user, request),
IGlobalMenuEntry,
name="home")
if home_entry:
return HTTPFound(location=home_entry.url)
else:
return HTTPFound(location=model_url(
context, request, 'login.html', query={'login_failed': '1'}))
def student_view(context, request):
competence_cloud = student_competence_cloud_view(context, request)
# Redirect if the student is accessed by a teacher (gives a nicer URL).
if authenticated_user(request) != context:
return HTTPFound(location=model_url(context, request, 'stats.html'))
return dict(student=context,
competence_cloud=competence_cloud,
request=request,
comments_view=comments_view,
api=TemplateAPI(request))
def comments_add_view(context, request):
journal_entry = context.__parent__
# Comment to add
if request.POST.get('comment_text', None):
comment = Comment()
comment.journal_entry = journal_entry
comment.user = authenticated_user(request)
comment.text = request.POST['comment_text']
comment.date = datetime.datetime.now()
html = comments_view(context, request)
response = simplejson.dumps(dict(id=model_url(context, request),
html=html))
return Response(response)
def view_pw_reset(context, request):
# Second step: User is visiting reset url
if 'key' in request.params:
key = request.params['key']
if 'form.submitted' in request.params:
try:
# FormEncode validation
schema = PWResetSchema()
form_result = schema.to_python(request.params)
except formencode.validators.Invalid, why:
form = render_template('templates/password_reset.pt',
request=request,
api=TemplateAPI(request))
# FormEncode fills template with error messages
form = htmlfill.render(form,
defaults=request.params,
errors=why.error_dict)
return Response(form)
else:
session = DBSession()
user = session.query(User).filter_by(
email=form_result['email']).one()
if key == user.password_reset_key():
user.password = '******' % sha.new(
form_result['password'].encode('utf-8')).hexdigest()
# Login directly
headers = []
plugins = request.environ.get('repoze.who.plugins', {})
identifier = plugins.get('auth_tkt')
if identifier:
identity = {'repoze.who.userid': form_result['email']}
headers = identifier.remember(request.environ,
identity)
request.environ['repoze.who.userid'] = form_result['email']
return HTTPFound(location=model_url(context, request),
headers=headers)
else:
statusmessage.show(request, u"Retrieve request not valid.",
u"error")
return render_template_to_response('templates/password_reset.pt',
request=request,
api=TemplateAPI(request))
def objective_edit_view(context, request):
session = DBSession()
competences = session.query(Competence).all()
if IObjective.providedBy(context):
add_form = False
objective = context
project = context.project
context = objective.__parent__
else:
objective = Objective()
add_form = True
project = context.__parent__
errors = {}
defaults = {}
if 'form.submitted' in request.POST:
try:
# FormEncode validation
defaults = dict(request.POST)
form_result = objective_schema.to_python(request.POST)
except formencode.validators.Invalid, why:
errors = why.error_dict
else:
# Apply schema fields to the project object
changed = False
competences = []
for competence_id in form_result['competences']:
competence = session.query(Competence).filter_by(
id=competence_id).first()
if competence:
competences.append(competence)
form_result['competences'] = competences
for field_name in objective_schema.fields.keys():
if form_result[field_name] != getattr(objective, field_name):
setattr(objective, field_name, form_result[field_name])
changed = True
# Add onjective if this is the add form
if add_form:
objective.project = project
session.add(objective)
return HTTPFound(location=model_url(context, request))
def indicator_edit_view(context, request):
if IIndicator.providedBy(context):
indicator = context
indicator_set = indicator.indicator_set
add_form = False
else:
indicator = Indicator()
indicator_set = context.__parent__
add_form = True
competences_container = find_interface(context, ICompetences)
errors = {}
defaults = {}
if 'form.submitted' in request.POST:
try:
# FormEncode validation
defaults = dict(request.POST)
form_result = indicator_schema.to_python(request.POST)
except formencode.validators.Invalid, why:
errors = why.error_dict
else:
# Apply schema fields to the project object
field_names = [
p.key for p in class_mapper(Indicator).iterate_properties
]
changed = False
for field_name in field_names:
if field_name in form_result.keys():
if form_result[field_name] != getattr(
indicator, field_name):
setattr(indicator, field_name, form_result[field_name])
changed = True
# Add project if this is the add form
if add_form:
session = DBSession()
indicator.indicator_set = indicator_set
indicator.index = indicator_set.indicators.count() - 1
session.add(indicator)
return HTTPFound(
location=model_url(competences_container, request))
def obj2Data(self, obj, parent_paths=None):
dc = obj.metadata.get('dublin', {})
name = obj.__name__
title = dc.get('title', obj.__name__)
icon_url = '/static/folder.gif'
view = '/view.html'
url = model_url(obj, self.request)
if IFRSFolder.providedBy(obj):
view = ''
else:
url = url[:-1]
if IFRSFile.providedBy(obj):
icon_url = '/static/file.gif'
if IFRSDocument.providedBy(obj):
icon_url = '/static/document.gif'
view = ''
if IFRSImage.providedBy(obj):
icon_url = '/static/image.gif'
data = {
'name': name,
'url': url,
'view': view,
'icon': icon_url,
'title': title,
'children': [],
'flag': ''
}
if not IFRSFolder.providedBy(obj):
data['children'] = None
elif parent_paths is not None:
data['children'] = self.appendChildren(obj, parent_paths)
if obj.vpath == self.context.vpath:
data['flag'] = 'current'
elif obj.vpath + '/index.rst' == self.context.vpath:
for child in data['children']:
if 'index.rst' == data['name']:
return data
data['flag'] = 'current'
return data
def competence_edit_view(context, request):
session = DBSession()
meta_competences = session.query(MetaCompetence).all()
if ICompetence.providedBy(context):
competence = context
context = competence.__parent__
add_form = False
else:
competence = Competence()
add_form = True
errors = {}
defaults = {}
if 'form.submitted' in request.POST:
try:
# FormEncode validation
defaults = dict(request.POST)
form_result = competence_schema.to_python(request.POST)
except formencode.validators.Invalid, why:
errors = why.error_dict
else:
# Apply schema fields to the project object
field_names = [
p.key for p in class_mapper(Competence).iterate_properties
]
changed = False
for field_name in field_names:
if field_name in form_result.keys():
if form_result[field_name] != getattr(
competence, field_name):
setattr(competence, field_name,
form_result[field_name])
changed = True
# Add project if this is the add form
if add_form:
session.add(competence)
return HTTPFound(location=model_url(context, request))
def project_edit_view(context, request):
if IProject.providedBy(context):
project = context
context = project.__parent__
add_form = False
else:
project = Project()
add_form = True
errors = {}
defaults = {}
if 'form.submitted' in request.POST:
try:
# FormEncode validation
defaults = dict(request.POST)
form_result = project_schema.to_python(request.POST)
except formencode.validators.Invalid, why:
errors = why.error_dict
else:
# Apply schema fields to the project object
changed = False
for field_name in project_schema.fields.keys():
if form_result[field_name] != getattr(project, field_name):
setattr(project, field_name, form_result[field_name])
changed = True
# Add project if this is the add form
if add_form:
session = DBSession()
# Add the teacher that created the project to the project.
user = authenticated_user(request)
if ITeacher.providedBy(user):
project.teachers.append(user)
session.add(project)
return HTTPFound(location=model_url(context, request))
def url(self):
return model_url(self.context, self.request, 'stats.html')
def url(self):
return model_url(self.context, self.request, 'projects_info.html')
def url(self):
return model_url(self.context, self.request)
for field_name in field_names:
if field_name in form_result.keys():
if form_result[field_name] != getattr(
indicator_set, field_name):
setattr(indicator_set, field_name,
form_result[field_name])
changed = True
# Add project if this is the add form
if add_form:
session = DBSession()
indicator_set.competence = competence
session.add(indicator_set)
return HTTPFound(
location=model_url(competence.__parent__, request))
elif 'form.cancel' in request.POST:
return HTTPFound(location=model_url(competence.__parent__, request))
else:
if not add_form:
field_names = [
p.key for p in class_mapper(IndicatorSet).iterate_properties
]
for field_name in field_names:
defaults[field_name] = getattr(indicator_set, field_name)
form = render_template('templates/indicator_set_edit.pt',
indicator_set=indicator_set,
competence=competence,
add_form=add_form,
api=TemplateAPI(request))
# FormEncode fills template with default values
def url(self):
return model_url(self.request.root, self.request, 'users')
def url(self):
return model_url(self.context, self.request, 'edit.html')
def url(self):
return model_url(self.user, self.request)
if 'form.submitted' in request.params:
try:
# FormEncode validation
schema = PWResetRequestSchema()
form_result = schema.to_python(request.params)
except formencode.validators.Invalid, why:
form = render_template(
'templates/password_retrieve.pt',
request=request,
api=TemplateAPI(request),
)
# FormEncode fills template with error messages
form = htmlfill.render(form,
defaults=request.params,
errors=why.error_dict)
return Response(form)
else:
session = DBSession()
user = session.query(User).filter_by(
email=form_result['email']).one()
reset_url = model_url(get_root(request), request,
'retrieve_password.html')
user.send_password_reset(reset_url)
statusmessage.show(request, u'Password retrieval e-mail sent.')
return HTTPFound(location=model_url(context, request))
return render_template_to_response('templates/password_retrieve.pt',
request=request,
api=TemplateAPI(request))
# Add student if this is the add form
if add_form:
session = DBSession()
session.add(student)
if not form_result['password']:
reset_url = model_url(get_root(request), request,
'retrieve_password.html')
student.send_password_reset(reset_url)
return HTTPFound(
location=model_url(context, request, str(student.id)))
elif 'form.cancel' in request.POST:
if add_form:
return HTTPFound(location=model_url(context, request))
else:
return HTTPFound(
location=model_url(context, request, str(student.id)))
else:
if not add_form:
field_names = [
p.key for p in class_mapper(Student).iterate_properties
]
for field_name in field_names:
defaults[field_name] = getattr(student, field_name)
defaults['portrait'] = ''
if defaults['date_of_birth']:
defaults['date_of_birth'] = defaults['date_of_birth'].strftime(
'%d/%m/%Y')
def absolute_url(self, request=None):
if request is None:
request = self._request()
return model_url(self, request)
competence = session.query(Competence).filter_by(
id=competence_id).first()
if competence:
competences.append(competence)
form_result['competences'] = competences
for field_name in objective_schema.fields.keys():
if form_result[field_name] != getattr(objective, field_name):
setattr(objective, field_name, form_result[field_name])
changed = True
# Add onjective if this is the add form
if add_form:
objective.project = project
session.add(objective)
return HTTPFound(location=model_url(context, request))
elif 'form.cancel' in request.POST:
return HTTPFound(location=model_url(context, request))
else:
if not add_form:
for field_name in objective_schema.fields.keys():
value = getattr(objective, field_name)
if field_name == 'competences':
values = []
for competence in value:
values.append(competence.id)
value = values
defaults[field_name] = value
form = render_template('templates/objective_edit.pt',
objective=objective,
competences=competences,
def url(self):
return model_url(self.context, self.request, 'objectives')
def url(self):
return model_url(self.context, self.request, 'application.html')
def teacher_edit_view(context, request):
if ITeacher.providedBy(context):
teacher = context
context = teacher.__parent__
add_form = False
else:
teacher = Teacher(id=uuid.uuid4())
add_form = True
errors = {}
defaults = {}
if 'form.submitted' in request.POST:
try:
# FormEncode validation
defaults = dict(request.POST)
state = FormencodeState()
state.user_id = teacher.user_name
if add_form:
form_result = teacher_add_schema.to_python(request.POST, state)
else:
form_result = teacher_schema.to_python(request.POST, state)
except formencode.validators.Invalid, why:
errors=why.error_dict
else:
changed = False
# Convert password to SHA hash
if form_result.get('password', None):
form_result['password'] = '******' % sha.new(form_result['password']).hexdigest()
changed = True
# Handle portrait upload
if form_result['portrait'] is not None:
# Scale image and convert to JPEG
im = Image.open(form_result['portrait'].file)
im.thumbnail((128, 128),Image.ANTIALIAS)
# Convert to RGB if neccessary
if im.mode != "RGB":
im = im.convert("RGB")
outfile = StringIO()
im.save(outfile, "JPEG")
outfile.seek(0)
teacher.portrait = File('portrait.jpg', outfile.read())
changed = True
del form_result['portrait']
# Apply schema fields to the student object
field_names = [ p.key for p in class_mapper(Teacher).iterate_properties ]
for field_name in field_names:
if field_name in form_result.keys():
if form_result[field_name] != getattr(teacher, field_name):
setattr(teacher, field_name, form_result[field_name])
changed = True
# Add student if this is the add form
if add_form:
session = DBSession()
session.add(teacher)
if not form_result['password']:
reset_url = model_url(get_root(request), request, 'retrieve_password.html')
teacher.send_password_reset(reset_url)
return HTTPFound(location = model_url(context, request))
def url(self):
return model_url(self.request.root, self.request, 'competences')
def url(self):
return model_url(self.context, self.request, 'members.html')
def url(self):
return model_url(self.request.root, self.request, 'dashboard.html')
def url(self):
return model_url(self.request.root, self.request, 'projects')
