def handle_submit(self, converted):
try:
context = self.context
request = self.request
key = request.params.get('key')
if not key or len(key) != 40:
e = ResetFailed()
e.page_title = 'Password Reset URL Problem'
raise e
users = find_users(context)
user = users.get_by_login(converted['login'])
if user is None:
# XXX should be part of form validation
raise Exception(login='******')
userid = user.get('id')
if userid is None:
userid = user['login']
profiles = find_profiles(context)
profile = profiles.get(userid)
if profile is None:
# XXX should be part of form validation
raise Exception(login='******')
if key != getattr(profile, 'password_reset_key', None):
e = ResetFailed()
e.page_title = 'Password Reset Confirmation Problem'
raise e
now = datetime.datetime.now()
t = getattr(profile, 'password_reset_time', None)
if t is None or now - t > max_reset_timedelta:
e = ResetFailed()
e.page_title = 'Password Reset Confirmation Key Expired'
raise e
# The key matched. Clear the key and reset the password.
profile.password_reset_key = None
profile.password_reset_time = None
password = converted['password'].encode('UTF-8')
users.change_password(userid, password)
page_title = 'Password Reset Complete'
api = request.api
api.page_title = page_title
return render_template_to_response(
'templates/reset_complete.pt',
api=api,
login=converted['login'],
password=converted['password'],
)
except ResetFailed, e:
api = request.api
api.page_title = e.page_title
return render_template_to_response('templates/reset_failed.pt',
api=api)
def __call__(self, environ, start_response):
req = Request(environ)
try:
resp = req.get_response(self.app)
except:
# General failures get wrapped into a General KARL Error
static_url = req.relative_url(self._static_url, to_application=True)
home_url = req.relative_url(self._home_url, to_application=True)
if self._errorlog_url is None:
errorlog_url = None
else:
errorlog_url = req.relative_url(
self._errorlog_url, to_application=True
)
traceback_info = format_exc()
resp = render_template_to_response(
'karl.views:templates/wsgi_errormsg.pt',
error_message='General Error',
error_text=GENERAL_MESSAGE %
{'system_name': self._system_name},
static_url=static_url,
errorlog_url=errorlog_url,
home_url=home_url,
traceback_info=traceback_info,
)
resp.status = 500
return resp(environ, start_response)
status = resp.status_int
if status in (404, 500):
static_url = req.relative_url(self._static_url, to_application=True)
home_url = req.relative_url(self._home_url, to_application=True)
if self._errorlog_url is None:
errorlog_url = None
else:
errorlog_url = req.relative_url(
self._errorlog_url, to_application=True
)
error_text = NOTFOUND_MESSAGE if status == 404 else GENERAL_MESSAGE
error_text %= {'system_name': self._system_name}
resp = render_template_to_response(
'karl.views:templates/wsgi_errormsg.pt',
error_message='Not Found',
static_url=static_url,
error_text=error_text,
home_url=home_url,
errorlog_url=errorlog_url,
traceback_info=None,
)
resp.status = status
return resp(environ, start_response)
return resp(environ, start_response)
def handle_submit(self, converted):
try:
context = self.context
request = self.request
key = request.params.get("key")
if not key or len(key) != 40:
e = ResetFailed()
e.page_title = "Password Reset URL Problem"
raise e
users = find_users(context)
user = users.get_by_login(converted["login"])
if user is None:
raise ValidationError(login="******")
userid = user.get("id")
if userid is None:
userid = user["login"]
profiles = find_profiles(context)
profile = profiles.get(userid)
if profile is None:
raise ValidationError(login="******")
if key != getattr(profile, "password_reset_key", None):
e = ResetFailed()
e.page_title = "Password Reset Confirmation Problem"
raise e
now = datetime.datetime.now()
t = getattr(profile, "password_reset_time", None)
if t is None or now - t > max_reset_timedelta:
e = ResetFailed()
e.page_title = "Password Reset Confirmation Key Expired"
raise e
# The key matched. Clear the key and reset the password.
profile.password_reset_key = None
profile.password_reset_time = None
password = converted["password"].encode("UTF-8")
users.change_password(userid, password)
page_title = "Password Reset Complete"
api = TemplateAPI(context, request, page_title)
return render_template_to_response(
"templates/reset_complete.pt", api=api, login=converted["login"], password=converted["password"]
)
except ResetFailed, e:
api = TemplateAPI(context, request, e.page_title)
return render_template_to_response("templates/reset_failed.pt", api=api)
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 stats(context, request):
me = sys.argv[0]
me = os.path.abspath(me)
sandbox = os.path.dirname(os.path.dirname(me))
outfile_path = os.path.join(sandbox, 'var/stats/', 'stats.csv')
f = open(outfile_path, 'r')
lines = f.readlines()
resp_out = ""
line_arrays = []
for line in lines:
resp_out = resp_out + line + "<br/>"
line2 = line
myarr = line2.split(",")
line_arrays.append(myarr)
page_title = 'Admin Statistics'
api = TemplateAPI(context, request, page_title)
return render_template_to_response(
'templates/stats.pt',
api = api,
stats = resp_out,
comms = line_arrays,
)
return Response(resp_out)
def delete_profile_view(context, request):
confirm = request.params.get('confirm')
if confirm:
parent = context.__parent__
name = context.__name__
find_users(context).remove(name)
del parent[name]
if authenticated_userid(request) == name:
return logout_view(context, request, reason='User removed')
query = {'status_message': 'Deleted profile: %s' % name}
location = model_url(parent, request, query=query)
return HTTPFound(location=location)
page_title = 'Delete Profile for %s %s' % (context.firstname,
context.lastname)
api = TemplateAPI(context, request, page_title)
# Get a layout
return render_template_to_response(
'templates/delete_profile.pt',
api=api,
)
def login_view(context, request):
system_name = get_setting(context, 'system_name', 'KARL')
page_title = '' # Per #366377, don't say what screen
api = TemplateAPI(context, request, page_title)
came_from = request.params.get('came_from', request.url)
if came_from.endswith('login.html'):
came_from = came_from[:-len('login.html')]
elif came_from.endswith('logout.html'):
came_from = came_from[:-len('logout.html')]
api.status_message = status_message=request.params.get('reason', None)
response = render_template_to_response(
'templates/login.pt',
api=api,
came_from=came_from,
nothing='',
app_url=request.application_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, {})
response.headers.update(forget_headers)
return response
def stats(context, request):
"""
This appears to no longer be in use. If we can't confirm someone is using
it after some period of time we shoudl probably get rid of it.
--rossi 5/5/2011
"""
me = sys.argv[0]
me = os.path.abspath(me)
sandbox = os.path.dirname(os.path.dirname(me))
outfile_path = os.path.join(sandbox, 'var/stats/', 'stats.csv')
if not os.path.exists(outfile_path):
raise NotFound
f = open(outfile_path, 'r')
lines = f.readlines()
resp_out = ""
line_arrays = []
for line in lines:
resp_out = resp_out + line + "<br/>"
line2 = line
myarr = line2.split(",")
line_arrays.append(myarr)
page_title = 'Admin Statistics'
api = TemplateAPI(context, request, page_title)
return render_template_to_response(
'templates/stats.pt',
api = api,
stats = resp_out,
comms = line_arrays,
)
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 show_profiles_view(context, request):
system_name = get_setting(context, "system_name", "KARL")
page_title = "%s Profiles" % system_name
api = TemplateAPI(context, request, page_title)
# Grab the data for the two listings, main communities and portlet
search = ICatalogSearch(context)
query = dict(sort_index="title", interfaces=[IProfile], limit=5)
titlestartswith = request.params.get("titlestartswith")
if titlestartswith:
query["titlestartswith"] = (titlestartswith, titlestartswith)
num, docids, resolver = search(**query)
profiles = []
for docid in docids:
model = resolver(docid)
if model is None:
continue
profiles.append(model)
mgr = ILetterManager(context)
letter_info = mgr.get_info(request)
return render_template_to_response("templates/profiles.pt", api=api, profiles=profiles, letters=letter_info)
def handle_submit(self, validated):
context = self.context
request = self.request
name = make_unique_name(context, validated['title'])
creator = authenticated_userid(request)
text = safe_html(validated['description'])
topic = create_content(IForumTopic,
validated['title'],
text,
creator,
)
if text:
topic.description = extract_description(text)
else:
topic.description = validated['title']
context[name] = topic
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(topic, request)
return HTTPFound(location=location)
def blog_post_view(context, request):
result = {}
obj = context
dc = obj.metadata.get('dublin',{})
result['title'] = dc.get('title', obj.__name__)
result['description'] = dc.get('description', '')
result['url'] = obj.__name__
result['created'] = dc.get('created', '')
result['creator'] = dc.get('creators', [])[0]
pachs = request.url.split('/')
img_url = '/'.join(pachs[0:len(pachs)-2]) + '/img/'
result['body'] = IHTMLRenderer(obj).html().replace('src="img/', 'src="%s' % img_url)
tabs = render_tabs(context,request)
settings = queryUtility(ISettings)
idcomments_acct = str(getattr(settings, 'idcomments_acct', ''))
return render_template_to_response('templates/blogpost.pt',
title = dc.get('title', context.__name__),
result = result,
tabs = tabs,
post_created = getDisplayTime(result['created']),
idcomments_acct = idcomments_acct,
)
def syslog_view(context, request):
syslog_path = get_setting(context, 'syslog_view')
instances = get_setting(context, 'syslog_view_instances', ['karl'])
filter_instance = request.params.get('instance', '_any')
if filter_instance == '_any':
filter_instances = instances
else:
filter_instances = [filter_instance]
entries = []
with codecs.open(syslog_path, encoding='utf-8',
errors='replace') as syslog:
for line in syslog:
line = _decode(line)
try:
month, day, time, host, instance, message = line.split(None, 5)
except ValueError:
# Ignore lines that don't fit the format
continue
if instance not in filter_instances:
continue
entries.append(line)
entries.reverse() # Show more recent entries first
return render_template_to_response(
'templates/admin/syslog.pt',
api=AdminTemplateAPI(context, request),
menu=_menu_macro(),
instances=instances,
instance=filter_instance,
entries=entries,
)
def viewall_referencemanual_view(context, request):
backto = {
'href': model_url(context.__parent__, request),
'title': context.__parent__.title,
}
page_title = context.title
api = TemplateAPI(context, request, page_title)
# Get a layout
layout_provider = get_layout_provider(context, request)
layout = layout_provider('intranet')
# provide client data for rendering current tags in the tagbox
client_json_data = dict(
tagbox = get_tags_client_data(context, request),
)
return render_template_to_response(
'templates/viewall_referencemanual.pt',
api=api,
actions=[],
head_data=convert_to_script(client_json_data),
sections=_get_viewall(context, request, api),
backto=backto,
layout=layout,
)
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 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 retail_view(context, request):
page_title = context.title
api = TemplateAPI(context, request, page_title)
middle_portlet_html = _get_portlet_html(context, request,
context.middle_portlets)
right_portlet_html = _get_portlet_html(context, request,
context.right_portlets)
current_intranet = api.current_intranet
feature = getattr(find_intranets(current_intranet), 'feature', u'')
# Rendering this separately gives us a chance later to think about
# some kind of caching.
body = render_template(
'templates/intranethome_body.pt',
current_intranet=current_intranet,
feature=feature,
middle_portlet_html=middle_portlet_html,
right_portlet_html=right_portlet_html,
)
return render_template_to_response(
'templates/intranet_homepage.pt',
api=api,
body=body,
)
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 logs_view(context, request):
log_paths = get_setting(context, 'logs_view')
if len(log_paths) == 1:
# Only one log file, just view that
log = log_paths[0]
else:
# Make user pick a log file
log = request.params.get('log', None)
# Don't let users view arbitrary files on the filesystem
if log not in log_paths:
log = None
if log is not None and os.path.exists(log):
lines = codecs.open(log, encoding='utf-8',
errors='replace').readlines()
else:
lines = []
return render_template_to_response(
'templates/admin/log.pt',
api=AdminTemplateAPI(context, request),
menu=_menu_macro(),
logs=log_paths,
log=log,
lines=lines,
)
def blog_post_view(context, request):
result = {}
obj = context
dc = obj.metadata.get('dublin', {})
result['title'] = dc.get('title', obj.__name__)
result['description'] = dc.get('description', '')
result['url'] = obj.__name__
result['created'] = dc.get('created', '')
result['creator'] = dc.get('creators', [])[0]
pachs = request.url.split('/')
img_url = '/'.join(pachs[0:len(pachs) - 2]) + '/img/'
result['body'] = IHTMLRenderer(obj).html().replace('src="img/',
'src="%s' % img_url)
tabs = render_tabs(context, request)
settings = queryUtility(ISettings)
idcomments_acct = str(getattr(settings, 'idcomments_acct', ''))
return render_template_to_response(
'templates/blogpost.pt',
title=dc.get('title', context.__name__),
result=result,
tabs=tabs,
post_created=getDisplayTime(result['created']),
idcomments_acct=idcomments_acct,
)
def _show_calendar_view(context, request, make_presenter):
year, month, day = _date_requested(context, request)
focus_datetime = datetime.datetime(year, month, day)
now_datetime = _now()
# make the calendar presenter for this view
url_for = _make_calendar_presenter_url_func(context, request)
calendar = make_presenter(focus_datetime,
now_datetime,
url_for)
# find events and paint them on the calendar
selected_layer = _calendar_filter(context, request)
events = _get_catalog_events(context, request,
first_moment=calendar.first_moment,
last_moment=calendar.last_moment,
layer_name=selected_layer)
calendar.paint_events(events)
layers = _get_calendar_layers(context)
setup_url = _calendar_setup_url(context, request)
# render
api = TemplateAPI(context, request, calendar.title)
return render_template_to_response(
calendar.template_filename,
api=api,
setup_url=setup_url,
calendar=calendar,
selected_layer = selected_layer,
layers = layers,
quote = quote,
may_create = has_permission(CREATE, context, request),
)
def opensearch_view(context, request):
api = TemplateAPI(context, request, 'KARL People OpenSearch')
return render_template_to_response(
'templates/opensearch.xml',
api=api,
report=context,
url=model_url(context, request),
)
def not_found(context, request):
api = request.api
api.page_title = "Page Not Found!"
response = render_template_to_response("templates/404.pt", api=api)
response.status = "404 Not Found"
return response
def directory_view(context, request):
"""directory view
Show a list of packages or files in a directory.
"""
return render_template_to_response(
'templates/page.pt', project='pkgindex',
items=[(name, model_path(item)) for (name, item) in context.items()])
def reset_sent_view(context, request):
page_title = 'Password Reset Instructions Sent'
api = TemplateAPI(context, request, page_title)
return render_template_to_response(
'templates/reset_sent.pt',
api=api,
email=request.params.get('email'),
)
def image_view(context, request):
dc = context.metadata.get('dublin', {})
tabs = render_tabs(context,request)
return render_template_to_response('templates/image.pt',
title = dc.get('title', context.__name__),
description = dc.get('description', ''),
url=context.__name__,
tabs = tabs,
)
def __call__(self):
key = self.request.params.get("key")
if not key or len(key) != 40:
api = TemplateAPI(self.context, self.request, "Password Reset URL Problem")
return render_template_to_response("templates/reset_failed.pt", api=api)
snippets = get_template("forms/templates/snippets.pt")
snippets.doctype = xhtml
blurb_macro = snippets.macros["reset_confirm_blurb"]
api = TemplateAPI(self.context, self.request, "Reset Password")
return {"api": api, "blurb_macro": blurb_macro}
def image_view(context, request):
dc = context.metadata.get('dublin', {})
tabs = render_tabs(context, request)
return render_template_to_response(
'templates/image.pt',
title=dc.get('title', context.__name__),
description=dc.get('description', ''),
url=context.__name__,
tabs=tabs,
)
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)
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(message_from, [profile.email], message)
n += 1
status_message = "Sent message to %d users." % n
redirect_to = model_url(context, request, 'admin.html',
query=dict(status_message=status_message))
return HTTPFound(location=redirect_to)
return render_template_to_response(
'templates/admin/email_users.pt',
api=api,
menu=_menu_macro(),
to_groups = self.to_groups,
from_emails=from_emails,
)
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 print_view(context, request):
dumper = text_dump(context, request)
header = dumper.next()
api = TemplateAPI(context, request, context.title)
return render_template_to_response(
'templates/people_print.pt',
api=api,
header=header,
rows=dumper,
)
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 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 document_view(context, request):
html = IHTMLRenderer(context).html()
html_cols = render_cols(context, request)
settings = queryUtility(ISettings)
site_title = getattr(settings, 'site_title', '').decode('utf-8')
dc = context.metadata.get('dublin', {})
tabs = render_tabs(context, request)
return render_template_to_response(
'templates/document.pt',
title=dc.get('title', context.__name__),
description=dc.get('description', ''),
site_title=site_title,
html=html,
tabs=tabs,
html_cols=html_cols,
)
def folder_view(context, request):
if not request.url.endswith('/'):
response = HTTPFound(location=request.url + '/')
return response
defaults = ('index.html', 'index.rst')
for name in defaults:
try:
index = context[name]
except KeyError:
continue
return document_view(index, request)
contents = []
for obj in context.values(True, True):
dc = obj.metadata.get('dublin', {})
if hasattr(obj, '__getitem__'):
url = obj.__name__ + '/'
else:
url = obj.__name__
contents.append({
'name': obj.__name__,
'title': dc.get('title', ''),
'url': url,
'description': dc.get('description', '')
})
dc = context.metadata.get('dublin', {})
tabs = render_tabs(context, request)
html_cols = render_cols(context, request)
return render_template_to_response(
'templates/contents.pt',
title=dc.get('title', context.__name__),
description=dc.get('description', ''),
contents=contents,
html_cols=html_cols,
tabs=tabs,
)
def render(name,
request,
context=None,
status_int=None,
view=None,
section=None,
**kw):
if os.path.sep != "/":
name = name.replace("/", os.path.sep)
template = os.path.join("templates", name)
response = render_template_to_response(
template,
request=request,
context=context,
view=view,
section=section,
layout=get_template(os.path.join("templates", "layout.pt")),
**kw)
if status_int is not None:
response.status_int = status_int
return response
def blog_view(context, request):
batch_start = int(request.params.get('b_start', 0))
posts = []
blog_subpaths = context.get_recent_file_subpaths()
if batch_start >= len(blog_subpaths):
return HTTPFound(location=request.url.split('?b_start')[0])
for subpath in blog_subpaths:
obj = context.get_obj_by_subpath(subpath)
if obj != None:
url = '/'.join(obj.vpath.split('/')[2:])
dc = obj.metadata.get('dublin', {})
raw_html = IHTMLRenderer(obj).html().decode('utf-8')
converted_html = raw_html.replace('src="img/',\
'src="%s/%s/../img/' %(request.application_url, url))
posts.append({
'title': dc.get('title', obj.__name__),
'description': dc.get('description', ''),
'url': '/'.join(url.split('/')[1:]),
'created': getDisplayTime(dc.get('created', '')),
'creator': dc.get('creators', [])[0],
'body': converted_html[:500] + ' ......',
})
posts = Batch(posts, start=batch_start, size=5)
dc = context.metadata.get('dublin', {})
tabs = render_tabs(context, request)
html_cols = render_cols(context, request)
batch = render_batch(context, request)
return render_template_to_response(
'templates/blog.pt',
title=dc.get('title', context.__name__),
result=posts,
tabs=tabs,
batch=batch,
html_cols=html_cols,
)
def rss_view(context, request):
return render_template_to_response(
'templates/rss.pt',
request=request,
)
def my_view(context, request):
return render_template_to_response('templates/mytemplate.pt',
project='myproject')
def view_login(request):
if 'failed' in request.params:
failed = True
else:
failed = False
return render_template_to_response('templates/login.pt', request=request, login_failed=failed)
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))
def contact_view(context, request):
params = request.params
reply_str = ''
sender_fullname = params.get('sender_fullname', '')
sender_from_address = params.get('sender_from_address', '')
company_name = params.get('company_name', '')
company_website = params.get('company_website', '')
company_tel = params.get('company_tel', '')
subject = params.get('subject', '')
message = params.get('message', '')
# if sender_from_address!='' and company_name!=''\
# and company_tel!='' and subject!='' and message!='':
if sender_from_address != '' and subject != '' and message != '':
body = """%s 消息回馈:
回馈人信息：
NAME: %s
EMAIL: %s
COMPANY NAME: %s
COMPANY WEBSITE: %s
COMPANY TEL: %s
SUBJECT: %s
CONTENT:
%s
""" % (request.application_url, sender_fullname, \
sender_from_address, company_name, company_website, \
company_tel, subject, message)
settings = queryUtility(ISettings)
smtp_host = getattr(settings, 'smtp_host', '')
from_addr = getattr(settings, 'email_from', '')
user_name = getattr(settings, 'user_name', '')
user_passwd = getattr(settings, 'user_passwd', '')
to_addr = getattr(settings, 'email_to', '')
"""邮件参数
smtp_host = smtp.***.com
email_from = usr1@***.com
email_to = usr2@***.com
user_name = 'usr1'
user_passwd = '123*'
"""
try:
"""
msg = MIMEText.MIMEText(body,_subtype='plain',_charset='utf-8')
msg['subject'] = Header.Header(subject,'utf-8')
msg['from'] = from_addr
msg['to'] = to_addr
"""
msg = 'to: %s\r\nFrom: %s\r\nSubject: %s \r\n\r\n %s\r\n' \
%(to_addr, from_addr, subject, body)
server = smtplib.SMTP(smtp_host, 25)
server.ehlo()
server.starttls()
server.ehlo()
server.login(user_name, user_passwd)
server.sendmail(from_addr, to_addr, msg)
server.close()
reply_str = '信息已经发出，谢谢。'
sender_fullname = ''
sender_from_address = ''
company_name = ''
company_website = ''
company_tel = ''
subject = ''
message = ''
except:
reply_str = '邮件收发设置信息错误。请稍后重试，或通过其他方式反馈。'
else:
reply_str = '必填项信息不足，请补全。'
return render_template_to_response(
'templates/contact.pt',
reply_str=reply_str.decode('utf-8'),
sender_fullname=sender_fullname.decode('utf-8'),
sender_from_address=sender_from_address.decode('utf-8'),
company_name=company_name.decode('utf-8'),
company_website=company_website.decode('utf-8'),
company_tel=company_tel.decode('utf-8'),
subject=subject.decode('utf-8'),
message=message.decode('utf-8'),
)
