def user_delete(context, request):
principals = get_principals()
if 'name' in request.params and request.params['name']:
user_or_group = request.params['name']
principal = principals.search(name=user_or_group).first()
if principal is None:
request.session.flash(_(u'User was not found.'), 'error')
else:
is_group = user_or_group.startswith("group:")
principal_type = _(u"Group") if is_group else _(u"User")
# We already coming from the confirmation page.
if 'delete' in request.POST:
principals.__delitem__(principal.name)
notify(UserDeleted(principal, request))
request.session.flash(
_(u'${principal_type} ${title} was deleted.',
mapping=dict(principal_type=principal_type,
title=principal.title)), 'info')
location = "%s/@@setup-users" % request.application_url
return HTTPFound(location=location)
api = template_api(
context, request,
page_title=_(u"Delete ${principal_type} ${title}",
mapping=dict(principal_type=principal_type,
title=principal.title)),
principal_type=principal_type,
principal=principal)
return {'api': api, }
else:
request.session.flash(_(u'No name was given.'), 'error')
return {'api': template_api(context, request), }
def user_delete(context, request):
principals = get_principals()
if 'name' in request.params and request.params['name']:
user_or_group = request.params['name']
principal = principals.search(name=user_or_group).first()
if principal is None:
request.session.flash(_('User was not found.'), 'error')
else:
is_group = user_or_group.startswith("group:")
principal_type = _("Group") if is_group else _("User")
# We already coming from the confirmation page.
if 'delete' in request.POST:
principals.__delitem__(principal.name)
notify(UserDeleted(principal, request))
request.session.flash(
_('${principal_type} ${title} was deleted.',
mapping=dict(principal_type=principal_type,
title=principal.title)), 'info')
location = '{0}/@@setup-users'.format(request.application_url)
return HTTPFound(location=location)
api = template_api(
context, request,
page_title=_("Delete ${principal_type} ${title}",
mapping=dict(principal_type=principal_type,
title=principal.title)),
principal_type=principal_type,
principal=principal)
return {'api': api, }
else:
request.session.flash(_('No name was given.'), 'error')
return {'api': template_api(context, request), }
def __call__(self):
user_or_group = self.request.params['name']
principal = get_principals()[user_or_group]
is_group = user_or_group.startswith("group:")
principal_type = _(u"Group") if is_group else _(u"User")
api = template_api(
self.context, self.request,
page_title=_(u"Edit ${principal_type} ${title}",
mapping=dict(principal_type=principal_type,
title=self.context.title)),
cp_links=CONTROL_PANEL_LINKS,
principal=principal)
form_view = self.GroupManageFormView if is_group \
else self.UserManageFormView
form = form_view(principal, self.request)()
if self.request.is_response(form):
return form
return {
'api': api,
'form': form['form'],
}
def view(self):
session = DBSession()
query = (session.query(TodoItem)
.filter(TodoItem.parent_id == self.context.id)
.order_by(TodoItem.todostate)
.order_by(TodoItem.modification_date.desc())
)
items = query.all()
page = self.request.params.get('page', 1)
settings = todos_settings()
if settings['use_batching']:
items = Batch.fromPagenumber(items,
pagesize=settings['pagesize'],
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': get_renderer('templates/macros.pt').implementation(),
'items': items,
'settings': settings,
}
def user_manage(context, request):
user_or_group = request.params['name']
principal = get_principals()[user_or_group]
is_group = user_or_group.startswith("group:")
principal_type = _(u"Group") if is_group else _(u"User")
api = template_api(
context,
request,
page_title=_(u"Edit ${principal_type} - ${title}",
mapping=dict(principal_type=principal_type,
title=context.title)),
cp_links=CONTROL_PANEL_LINKS,
principal=principal,
)
form_view = GroupManageFormView if is_group else UserManageFormView
form = form_view(principal, request)()
if request.is_response(form):
return form
return {
'api': api,
'form': form['form'],
}
def disqus_comments_view(context, request):
settings = get_settings_util()
available = settings.get('kotti_disqus-disqus_available_types', [])
available += get_settings()['kotti_disqus.extra_types'].split()
resolver = DottedNameResolver(None)
types = tuple(resolver.resolve(typ) for typ in available)
if not isinstance(context, types):
raise PredicateMismatch()
api = template_api(context, request)
disqus_url = ''
disqus_shortname = settings['kotti_disqus-disqus_shortname']
base_url = settings['kotti_disqus-disqus_base_url'].strip('/')
if base_url:
disqus_url = base_url + api.url(context)[len(request.application_url):]
else:
disqus_url = api.url(context)
return {
'disqus_shortname': disqus_shortname,
'disqus_url': disqus_url,
}
def view_front_page(context, request):
home_url = get_home_url(request.user)
if home_url and not request.user.groups:
return HTTPFound(location=home_url)
return {
'api': template_api(context, request),
}
def __call__(self):
user_or_group = self.request.params["name"]
principal = get_principals()[user_or_group]
is_group = user_or_group.startswith("group:")
principal_type = _("Group") if is_group else _("User")
api = template_api(
self.context,
self.request,
page_title=_(
"Edit ${principal_type} ${title}",
mapping=dict(principal_type=principal_type,
title=self.context.title),
),
cp_links=CONTROL_PANEL_LINKS,
principal=principal,
)
form_view = self.GroupManageFormView if is_group else self.UserManageFormView
form = form_view(principal, self.request)()
if self.request.is_response(form):
return form
return {"api": api, "form": form["form"]}
def user_manage(context, request):
username = request.params["name"]
principal = get_principals()[username]
api = template_api(
context,
request,
page_title=u"Edit User - %s" % context.title,
cp_links=CONTROL_PANEL_LINKS,
principal=principal,
)
def edit_principal(context, request, appstruct):
_massage_groups_in(appstruct)
for key, value in appstruct.items():
setattr(context, key, value)
request.session.flash(u"Your changes have been saved.", "success")
return HTTPFound(location=request.url)
uschema = user_schema()
del uschema["name"]
del uschema["password"]
user_form = Form(uschema, buttons=("save", "cancel"))
user_fc = FormController(
user_form, appstruct=lambda p: _massage_groups_out(p.__dict__.copy()), edit_item=edit_principal
)
form = user_fc(principal, request)
if request.is_response(form):
return form
return {"api": api, "form": form}
def view(self):
session = DBSession()
query = session.query(SoftwareProject).filter(
SoftwareProject.parent_id == self.context.id)
items = query.all()
# [TODO] Are these calls too expensive?
[item.refresh_pypi() for item in items]
[item.refresh_github() for item in items]
[item.refresh_bitbucket() for item in items]
if self.context.sort_order_is_ascending:
items = sorted(items, key=lambda x: x.date)
else:
items = sorted(items, key=lambda x: x.date, reverse=True)
page = self.request.params.get('page', 1)
settings = collection_settings()
if settings['use_batching']:
items = Batch.fromPagenumber(items,
pagesize=settings['pagesize'],
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': get_renderer('templates/macros.pt').implementation(),
'items': items,
'settings': settings,
}
def share_node(context, request):
# Allow roles_form_handler to do processing on 'apply':
changed = roles_form_handler(
context, request, SHARING_ROLES, list_groups_raw)
if changed:
for (principal_name, context, groups) in changed:
set_groups(principal_name, context, groups)
return HTTPFound(location=request.url)
existing = map_principals_with_local_roles(context)
def with_roles(entry):
all_groups = entry[1][0]
return [g for g in all_groups if g.startswith('role:')]
existing = filter(with_roles, existing)
seen = set([entry[0].name for entry in existing])
# Allow search to take place and add some entries:
entries = existing + search_principals(request, context, ignore=seen)
available_roles = [ROLES[role_name] for role_name in SHARING_ROLES]
return {
'api': template_api(context, request),
'entries': entries,
'available_roles': available_roles,
}
def view(self):
session = DBSession()
query = session.query(Category).filter(
Category.parent_id == self.context.id)
items = query.all()
todos_data = {}
for state in todo_states:
todos_data[state] = 0
todos_data['total'] = 0
modification_dates_and_items = []
for item in items:
if item.children:
done_count = 0
for todo in item.children:
todos_data[todo.todostate] += 1
if todo.todostate == 'done':
done_count += 1
todos_data['total'] += len(item.children)
sorted_todoitems = sorted(item.children,
key=lambda x: x.modification_date,
reverse=True)
modification_dates_and_items.append(
(sorted_todoitems[0].modification_date,
sorted_todoitems[0],
done_count,
item))
else:
modification_dates_and_items.append(
(item.modification_date, item, 0, item))
items = sorted(modification_dates_and_items)
page = self.request.params.get('page', 1)
settings = todos_settings()
if settings['use_batching']:
items = Batch.fromPagenumber(items,
pagesize=settings['pagesize'],
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': get_renderer('templates/macros.pt').implementation(),
'items': items,
'todos_data': todos_data,
'data_keys': todo_states + ['total'],
'settings': settings,
}
def main(context, request):
api = template_api(
context, request,
cp_links=CONTROL_PANEL_LINKS,
)
api.page_title = _(u"Site Setup - ${title}",
mapping=dict(title=api.site_title))
return {'api': api}
def view_jobstep(context, request):
jobtype = get_context_data(context, 'jobflow', ['jobtype'])
attr_names = _JOBTYPE_PARAMS.get(jobtype)
return {
'api': template_api(context, request),
'attr_names': attr_names,
'resource_models': [JobStep],
}
def view_jobservice(context, request):
return {
'api': template_api(context, request),
'bootstraps': False,
'is_runnable': False,
'resource': get_resource(context),
'resource_models': [EMRJobResource, JobService, Bootstrap],
}
def view_jobflow(context, request):
return {
'api': template_api(context, request),
'bootstraps': get_bootstraps(context),
'is_runnable': is_runnable_jobflow(context),
'resource': get_resource(context),
'resource_models': [JobFlow],
}
def view_blog(context, request):
session = DBSession()
query = session.query(BlogEntry).filter(BlogEntry.parent_id == context.id)
blogentries = query.all()
return {
'api': template_api(context, request),
'blogentries': blogentries,
}
def view(self):
settings = todos_settings()
return {
'api': template_api(self.context, self.request),
'macros': get_renderer('templates/macros.pt').implementation(),
'settings': settings,
}
def render_local_navigation(context, request):
from kotti.views.util import template_api
api = template_api(context, request)
parent, children = api.list_children_go_up()
children = [c for c in children if c.in_navigation]
if parent != api.root and children:
return render('kotti:templates/view/local-navigation.pt',
dict(parent=parent, children=children, api=api),
request)
def main(context, request):
api = template_api(
context, request,
cp_links=CONTROL_PANEL_LINKS,
)
api.page_title=u"Site Setup - %s" % api.site_title
return {'api': api}
def __call__(self):
api = template_api(self.context,
self.request,
cp_links=CONTROL_PANEL_LINKS)
api.page_title = _("User Management")
principals = get_principals()
def groups_lister(principal_name, context):
return principals[principal_name].groups
# Handling the user/roles matrix:
changed = roles_form_handler(self.context, self.request,
USER_MANAGEMENT_ROLES, groups_lister)
if changed:
changed_names = []
for (principal_name, context, groups) in changed:
principal = principals[principal_name]
principal.groups = list(groups)
changed_names.append(principal_name)
location = (self.request.url.split("?")[0] + "?" +
urlencode({"extra": ",".join(changed_names)}))
return HTTPFound(location=location)
extra = self.request.params.get("extra") or ()
if isinstance(extra, str):
extra = extra.split(",")
search_entries = search_principals(self.request, extra=extra)
available_roles = [
ROLES[role_name] for role_name in USER_MANAGEMENT_ROLES
]
# Add forms:
user_addform = self.UserAddFormView(self.context, self.request)()
if self.request.is_response(user_addform):
return user_addform
group_addform = self.GroupAddFormView(self.context, self.request)()
if self.request.is_response(group_addform):
return group_addform
if self.request.params.get("add_user"):
active_tab = "add_user"
elif self.request.params.get("add_group"):
active_tab = "add_group"
else:
active_tab = "search"
return {
"api": api,
"entries": search_entries,
"available_roles": available_roles,
"user_addform": user_addform["form"],
"group_addform": group_addform["form"],
"active_tab": active_tab,
}
def __call__(self):
api = template_api(self.context,
self.request,
cp_links=CONTROL_PANEL_LINKS)
api.page_title = _(u"User Management")
principals = get_principals()
def groups_lister(principal_name, context):
return principals[principal_name].groups
# Handling the user/roles matrix:
changed = roles_form_handler(self.context, self.request,
USER_MANAGEMENT_ROLES, groups_lister)
if changed:
changed_names = []
for (principal_name, context, groups) in changed:
principal = principals[principal_name]
principal.groups = list(groups)
changed_names.append(principal_name)
location = self.request.url.split('?')[0] + '?' + urlencode(
{'extra': ','.join(changed_names)})
return HTTPFound(location=location)
extra = self.request.params.get('extra') or ()
if isinstance(extra, string_types):
extra = extra.split(',')
search_entries = search_principals(self.request, extra=extra)
available_roles = [
ROLES[role_name] for role_name in USER_MANAGEMENT_ROLES
]
# Add forms:
user_addform = self.UserAddFormView(self.context, self.request)()
if self.request.is_response(user_addform):
return user_addform
group_addform = self.GroupAddFormView(self.context, self.request)()
if self.request.is_response(group_addform):
return group_addform
if self.request.params.get('add_user'):
active_tab = 'add_user'
elif self.request.params.get('add_group'):
active_tab = 'add_group'
else:
active_tab = 'search'
return {
'api': api,
'entries': search_entries,
'available_roles': available_roles,
'user_addform': user_addform['form'],
'group_addform': group_addform['form'],
'active_tab': active_tab,
}
def __call__(self):
api = template_api(self.context, self.request, cp_links=CONTROL_PANEL_LINKS)
api.page_title = _("User Management")
principals = get_principals()
def groups_lister(principal_name, context):
return principals[principal_name].groups
# Handling the user/roles matrix:
changed = roles_form_handler(
self.context, self.request, USER_MANAGEMENT_ROLES, groups_lister
)
if changed:
changed_names = []
for (principal_name, context, groups) in changed:
principal = principals[principal_name]
principal.groups = list(groups)
changed_names.append(principal_name)
location = (
self.request.url.split("?")[0]
+ "?"
+ urlencode({"extra": ",".join(changed_names)})
)
return HTTPFound(location=location)
extra = self.request.params.get("extra") or ()
if isinstance(extra, string_types):
extra = extra.split(",")
search_entries = search_principals(self.request, extra=extra)
available_roles = [ROLES[role_name] for role_name in USER_MANAGEMENT_ROLES]
# Add forms:
user_addform = self.UserAddFormView(self.context, self.request)()
if self.request.is_response(user_addform):
return user_addform
group_addform = self.GroupAddFormView(self.context, self.request)()
if self.request.is_response(group_addform):
return group_addform
if self.request.params.get("add_user"):
active_tab = "add_user"
elif self.request.params.get("add_group"):
active_tab = "add_group"
else:
active_tab = "search"
return {
"api": api,
"entries": search_entries,
"available_roles": available_roles,
"user_addform": user_addform["form"],
"group_addform": group_addform["form"],
"active_tab": active_tab,
}
def user_delete(context, request):
principals = get_principals()
if "name" in request.params and request.params["name"]:
user_or_group = request.params["name"]
principal = principals.search(name=user_or_group).first()
if principal is None:
request.session.flash(_("User was not found."), "error")
else:
is_group = user_or_group.startswith("group:")
principal_type = _("Group") if is_group else _("User")
# We already coming from the confirmation page.
if "delete" in request.POST:
principals.__delitem__(principal.name)
notify(UserDeleted(principal, request))
request.session.flash(
_(
"${principal_type} ${title} was deleted.",
mapping=dict(principal_type=principal_type,
title=principal.title),
),
"info",
)
location = f"{request.application_url}/@@setup-users"
return HTTPFound(location=location)
api = template_api(
context,
request,
page_title=_(
"Delete ${principal_type} ${title}",
mapping=dict(principal_type=principal_type,
title=principal.title),
),
principal_type=principal_type,
principal=principal,
)
return {"api": api}
else:
request.session.flash(_("No name was given."), "error")
return {"api": template_api(context, request)}
def view_signup(context, request):
user_addform = SeaUnicornisUserAddFormView(context, request)()
if request.is_response(user_addform):
principal = get_principals().get(request.params[u'name'])
notify(UserAdded(principal, request))
return user_addform
return {
'api': template_api(context, request),
'user_addform': user_addform['form'],
}
def user_delete(context, request):
principals = get_principals()
if "name" in request.params and request.params["name"]:
user_or_group = request.params["name"]
principal = principals.search(name=user_or_group).first()
if principal is None:
request.session.flash(_("User was not found."), "error")
else:
is_group = user_or_group.startswith("group:")
principal_type = _("Group") if is_group else _("User")
# We already coming from the confirmation page.
if "delete" in request.POST:
principals.__delitem__(principal.name)
notify(UserDeleted(principal, request))
request.session.flash(
_(
"${principal_type} ${title} was deleted.",
mapping=dict(
principal_type=principal_type, title=principal.title
),
),
"info",
)
location = "{0}/@@setup-users".format(request.application_url)
return HTTPFound(location=location)
api = template_api(
context,
request,
page_title=_(
"Delete ${principal_type} ${title}",
mapping=dict(principal_type=principal_type, title=principal.title),
),
principal_type=principal_type,
principal=principal,
)
return {"api": api}
else:
request.session.flash(_("No name was given."), "error")
return {"api": template_api(context, request)}
def frontpage_view(context, request):
session = DBSession()
query = session.query(BlogEntry).order_by(BlogEntry.date.desc())
items = query.all()[:3]
items = [
item for item in items if has_permission('view', item, request)
]
return {
'api': template_api(context, request),
'items': items,
}
def __call__(self):
api = template_api(self.context, self.request,
cp_links=CONTROL_PANEL_LINKS)
api.page_title = _(u"User Management")
principals = get_principals()
def groups_lister(principal_name, context):
return principals[principal_name].groups
# Handling the user/roles matrix:
changed = roles_form_handler(
self.context, self.request, USER_MANAGEMENT_ROLES, groups_lister)
if changed:
changed_names = []
for (principal_name, context, groups) in changed:
principal = principals[principal_name]
principal.groups = list(groups)
changed_names.append(principal_name)
location = self.request.url.split('?')[0] + '?' + urlencode(
{'extra': ','.join(changed_names)})
return HTTPFound(location=location)
extra = self.request.params.get('extra') or ()
if extra:
extra = extra.split(',')
search_entries = search_principals(self.request, extra=extra)
available_roles = [ROLES[role_name]
for role_name in USER_MANAGEMENT_ROLES]
# Add forms:
user_addform = self.UserAddFormView(self.context, self.request)()
if self.request.is_response(user_addform):
return user_addform
group_addform = self.GroupAddFormView(self.context, self.request)()
if self.request.is_response(group_addform):
return group_addform
if self.request.params.get('add_user'):
active_tab = 'add_user'
elif self.request.params.get('add_group'):
active_tab = 'add_group'
else:
active_tab = 'search'
return {
'api': api,
'entries': search_entries,
'available_roles': available_roles,
'user_addform': user_addform['form'],
'group_addform': group_addform['form'],
'active_tab': active_tab,
}
def preferences(context, request):
api = template_api(context, request)
api.page_title = u"My preferences - %s" % api.site_title
user = api.user
uschema = user_schema(PrincipalBasic())
user_form = Form(uschema, buttons=("save", "cancel"))
user_fc = FormController(user_form)
form = user_fc(user, request)
if request.is_response(form):
return form
return {"api": api, "form": form}
def view_site_gallery(context, request):
sites = DBSession.query(Site)\
.filter(Site.parent_id == context.id)\
.all()
sites = [s for s in sites if has_permission('view', s, request)]
return dict(
api=template_api(context, request),
sites=sites,
)
def inline(self):
"""
Inline view for StaticPanel
:return:
:rtype: dict
"""
return {
'api': template_api(self.context, self.request), # this bounds context and request variables to the api in the template
'example_text': self.context.example_text, # this can be called directly in the template as example_text
}
def view(self):
"""
Default view for panels
:return:
:rtype: dict
"""
return {
'api': template_api(self.context, self.request), # this bounds context and request variables to the api in the template
'example_text': self.context.example_text, # this can be called directly in the template as example_text
}
def view_test(context, request):
class FormSchema(colander.MappingSchema):
class Tests(colander.SequenceSchema):
test = colander.SchemaNode(colander.String())
tests = Tests(
validator=colander.Length(2, 4),
title="At Least 2 At Most 4 Tests",
widget=SequenceWidget(min_len=2, max_len=4),
)
return {"form": Form(FormSchema()).render(), "api": template_api(context, request)}
def set_password(context, request, success_msg=_(u"You have reset your password.")):
""" Set password view. Displays the set password form and handles its form
submission.
:param context: Current context
:type context: :class:`kotti.resources.Content`
:param request: Current request
:type request: :class:`kotti.request.Request`
:param success_msg: Message to display on successful submission handling
:type success_msg: str or TranslationString
:result: Redirect response or dictionary passed to the template for
rendering.
:rtype: pyramid.httpexceptions.HTTPFound or dict
"""
form = Form(SetPasswordSchema(), buttons=(Button("submit", _(u"Set password")),))
rendered_form = None
if "submit" in request.POST:
try:
appstruct = form.validate(request.POST.items())
except ValidationFailure as e:
rendered_form = e.render()
else:
token = appstruct["token"]
email = appstruct["email"]
user = _find_user(email)
if user is not None and validate_token(user, token) and token == user.confirm_token and user.active:
password = appstruct["password"]
user.password = get_principals().hash_password(password)
user.confirm_token = None
headers = remember(request, user.name)
user.last_login_date = datetime.now()
location = appstruct["continue_to"] or resource_url(context, request)
request.session.flash(success_msg, "success")
return HTTPFound(location=location, headers=headers)
else:
request.session.flash(_(u"Your password reset token may have expired."), "error")
if rendered_form is None:
rendered_form = form.render(request.params)
api = template_api(
context, request, page_title=_(u"Reset your password - ${title}.", mapping=dict(title=context.title))
)
return {"api": api, "form": rendered_form}
def register(context, request):
schema = RegisterSchema().bind(request=request)
form = Form(schema, buttons=(Button('register', _(u'Register')), ))
rendered_form = None
if 'register' in request.POST:
try:
appstruct = form.validate(request.POST.items())
except ValidationFailure as e:
request.session.flash(_(u"There was an error."), 'error')
rendered_form = e.render()
else:
settings = get_settings()
appstruct['groups'] = u''
appstruct['roles'] = u''
register_groups = settings['kotti.register.group']
if register_groups:
appstruct['groups'] = [register_groups]
register_roles = settings['kotti.register.role']
if register_roles:
appstruct['roles'] = {'role:' + register_roles}
appstruct['send_email'] = True
form = UserAddFormView(context, request)
form.add_user_success(appstruct)
success_msg = _(
'Congratulations! You are successfully registered. '
'You should be receiving an email with a link to set your '
'password. Doing so will activate your account.')
request.session.flash(success_msg, 'success')
name = appstruct['name']
notify(UserSelfRegistered(get_principals()[name], request))
return HTTPFound(location=request.application_url)
if rendered_form is None:
rendered_form = form.render(request.params)
api = template_api(
context,
request,
page_title=_(u"Register - ${title}",
mapping=dict(title=context.title)),
)
return {
'api': api,
'form': rendered_form,
}
def register(context, request):
schema = RegisterSchema().bind(request=request)
form = Form(schema, buttons=(Button('register', _('Register')),))
rendered_form = None
if 'register' in request.POST:
try:
appstruct = form.validate(request.POST.items())
except ValidationFailure as e:
request.session.flash(_("There was an error."), 'error')
rendered_form = e.render()
else:
settings = get_settings()
appstruct['groups'] = ''
appstruct['roles'] = ''
register_groups = settings['kotti.register.group']
if register_groups:
appstruct['groups'] = [register_groups]
register_roles = settings['kotti.register.role']
if register_roles:
appstruct['roles'] = {'role:' + register_roles}
appstruct['send_email'] = True
form = UserAddFormView(context, request)
form.add_user_success(appstruct)
success_msg = _(
'Congratulations! You are successfully registered. '
'You should be receiving an email with a link to set your '
'password. Doing so will activate your account.'
)
request.session.flash(success_msg, 'success')
name = appstruct['name']
notify(UserSelfRegistered(get_principals()[name], request))
return HTTPFound(location=request.application_url)
if rendered_form is None:
rendered_form = form.render(request.params)
api = template_api(
context, request,
page_title=_("Register - ${title}",
mapping=dict(title=context.title)),
)
return {
'api': api,
'form': rendered_form,
}
def generic_edit(context, request, schema, form_factory=Form, **kwargs):
api = template_api(context, request)
api.first_heading=u'<h1>Edit <em>%s</em></h1>' % context.title
api.page_title = u'Edit %s - %s' % (context.title, api.site_title)
form = form_factory(schema, buttons=('save', 'cancel'), action=request.url)
rendered = FormController(form, **kwargs)(context, request)
if request.is_response(rendered):
return rendered
return {
'api': api,
'form': rendered,
}
def view_calendar(context, request):
kotti_calendar_resources.need()
locale_name = get_locale_name(request)
if locale_name in fullcalendar_locales:
fullcalendar_locales[locale_name].need()
else: # pragma: no cover (safety belt only, should never happen)
fullcalendar_locales["en"].need()
session = DBSession()
now = datetime.datetime.now()
query = session.query(Event).filter(Event.parent_id == context.id)
future = or_(Event.start > now, Event.end > now)
upcoming = query.filter(future).order_by(Event.start).all()
past = query.filter(Event.start < now).order_by(desc(Event.start)).all()
upcoming = [event for event in upcoming if
has_permission('view', event, request)]
past = [event for event in past if
has_permission('view', event, request)]
fmt = '%Y-%m-%d %H:%M:%S'
fullcalendar_events = []
for event in (upcoming + past):
json_event = {
'title': event.title,
'url': resource_url(event, request),
'start': event.start.strftime(fmt),
'allDay': event.all_day,
}
if event.end:
json_event['end'] = event.end.strftime(fmt)
fullcalendar_events.append(json_event)
fullcalendar_options = {
'header': {
'left': 'prev,next today',
'center': 'title',
'right': 'month,agendaWeek,agendaDay'
},
'eventSources': context.feeds,
'weekends': context.weekends,
'events': fullcalendar_events,
}
return {
'api': template_api(context, request),
'upcoming_events': upcoming,
'past_events': past,
'fullcalendar_options': json.dumps(fullcalendar_options),
}
def users_manage(context, request):
api = template_api(
context,
request,
cp_links=CONTROL_PANEL_LINKS,
)
api.page_title = _(u"User Management - ${title}",
mapping=dict(title=api.site_title))
principals = get_principals()
def groups_lister(principal_name, context):
return principals[principal_name].groups
# Handling the user/roles matrix:
changed = roles_form_handler(context, request, USER_MANAGEMENT_ROLES,
groups_lister)
if changed:
changed_names = []
for (principal_name, context, groups) in changed:
principal = principals[principal_name]
principal.groups = list(groups)
changed_names.append(principal_name)
location = request.url.split('?')[0] + '?' + urlencode(
{'extra': ','.join(changed_names)})
return HTTPFound(location=location)
extra = request.params.get('extra') or ()
if extra:
extra = extra.split(',')
search_entries = search_principals(request, extra=extra)
available_roles = [ROLES[role_name] for role_name in USER_MANAGEMENT_ROLES]
# Add forms:
user_addform = UserAddFormView(context, request)()
if request.is_response(user_addform):
return user_addform
group_addform = GroupAddFormView(context, request)()
if request.is_response(group_addform):
return group_addform
return {
'api': api,
'entries': search_entries,
'available_roles': available_roles,
'user_addform': user_addform['form'],
'group_addform': group_addform['form'],
}
def preferences(context, request):
api = template_api(context, request)
api.page_title = _(u"My preferences - ${title}",
mapping=dict(title=api.site_title))
user = request.user
form = UserEditFormView(user, request)()
if request.is_response(form):
return form
return {
'api': api,
'form': form['form'],
'macro': api.macro('kotti:templates/site-setup/master.pt'),
}
def register(context, request):
schema = RegisterSchema().bind(request=request)
form = Form(schema, buttons=(Button("register", _("Register")),))
rendered_form = None
if "register" in request.POST:
try:
appstruct = form.validate(request.POST.items())
except ValidationFailure as e:
request.session.flash(_("There was an error."), "error")
rendered_form = e.render()
else:
settings = get_settings()
appstruct["groups"] = ""
appstruct["roles"] = ""
register_groups = settings["kotti.register.group"]
if register_groups:
appstruct["groups"] = [register_groups]
register_roles = settings["kotti.register.role"]
if register_roles:
appstruct["roles"] = {"role:" + register_roles}
appstruct["send_email"] = True
form = UserAddFormView(context, request)
form.add_user_success(appstruct)
success_msg = _(
"Congratulations! You are successfully registered. "
"You should be receiving an email with a link to set your "
"password. Doing so will activate your account."
)
request.session.flash(success_msg, "success")
name = appstruct["name"]
notify(UserSelfRegistered(get_principals()[name], request))
return HTTPFound(location=request.application_url)
if rendered_form is None:
rendered_form = form.render(request.params)
api = template_api(
context,
request,
page_title=_("Register - ${title}", mapping=dict(title=context.title)),
)
return {"api": api, "form": rendered_form}
def view(self):
""" Default view for :class:`kotti_calendar.resources.Calendar`
:result: Dictionary needed to render the template.
:rtype: dict
"""
kotti_calendar_resources.need()
lang_all_js.need()
return {
'api': template_api(self.context, self.request),
'upcoming_events': self.upcoming_events,
'past_events': self.past_events,
'fullcalendar_options': json.dumps(self.fullcalendar_options),
'event_url': self.event_url,
}
def __call__(self):
user = self.request.user
if user is None:
raise Forbidden()
api = template_api(self.context, self.request)
api.page_title = _(u"My preferences - ${title}",
mapping=dict(title=api.site_title))
form = self.PreferencesFormView(user, self.request)()
if self.request.is_response(form):
return form
return {
'api': api,
'form': form['form'],
'macro': api.macro('kotti:templates/site-setup/master.pt'),
}
def __call__(self):
user = self.request.user
if user is None:
raise Forbidden()
api = template_api(self.context, self.request)
api.page_title = _("My preferences - ${title}",
mapping=dict(title=api.site_title))
form = self.PreferencesFormView(user, self.request)()
if self.request.is_response(form):
return form
return {
"api": api,
"form": form["form"],
"macro": api.macro("kotti:templates/site-setup/master.pt"),
}
def user_manage(context, request):
username = request.params['name']
principal = get_principals()[username]
api = template_api(
context, request,
page_title=_(u"Edit User - ${title}",
mapping=dict(title=context.title)),
cp_links=CONTROL_PANEL_LINKS,
principal=principal,
)
form = UserManageFormView(principal, request)()
if request.is_response(form):
return form
return {
'api': api,
'form': form['form'],
}
def view_blog(self):
macros = get_renderer('templates/macros.pt').implementation()
query = DBSession.query(BlogEntry)
query = query.filter(BlogEntry.parent_id == self.context.id)
query = query.order_by(BlogEntry.date.desc())
items = query.all()
items = [
item for item in items
if has_permission('view', item, self.request)
]
page = self.request.params.get('page', 1)
use_pagination = get_setting('use_pagination')
if use_pagination:
items = Batch.fromPagenumber(items,
pagesize=get_setting('pagesize'),
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': macros,
'items': items,
'use_pagination': use_pagination,
'link_headline': get_setting('link_headline'),
}
def view_content_type(context, request):
return {
'api': template_api(context, request), # this bounds context and request variables to the api in the template
}
FileData(),
title=_('Attachment'),
widget=FileUploadWidget(tmpstore),
validator=file_size_limit,
missing=None,
)
_LOCALE_ = colander.SchemaNode(colander.String(),
widget=HiddenWidget(),
default=locale_name)
schema = SubmissionSchema(after_bind=maybe_show_attachment)
schema = schema.bind(maybe_show_attachment=context.show_attachment)
form = Form(schema, buttons=[Button('submit', _('Submit'))])
appstruct = None
rendered_form = None
if 'submit' in request.POST:
controls = request.POST.items()
try:
appstruct = form.validate(controls)
mail_submission(context, request, appstruct)
except ValidationFailure, e:
appstruct = None
rendered_form = e.render()
else:
rendered_form = form.render()
return {
'form': rendered_form,
'appstruct': appstruct,
'api': template_api(context, request),
}
form.add_user_success(appstruct)
success_msg = _(
'Congratulations! You are successfully registered. '
'You should be receiving an email with a link to set your '
'password. Doing so will activate your account.')
request.session.flash(success_msg, 'success')
name = appstruct['name']
notify(UserSelfRegistered(get_principals()[name], request))
return HTTPFound(location=request.application_url)
if rendered_form is None:
rendered_form = form.render(request.params)
api = template_api(
context,
request,
page_title=_(u"Register - ${title}",
mapping=dict(title=context.title)),
)
return {
'api': api,
'form': rendered_form,
}
@view_config(name='login', renderer='kotti:templates/login.pt')
def login(context, request):
"""
Login view. Renders either the login or password forgot form templates or
handles their form submission and redirects to came_from on success.
def set_password(context,
request,
success_msg=_("You have reset your password.")):
""" Set password view. Displays the set password form and handles its form
submission.
:param context: Current context
:type context: :class:`kotti.resources.Content`
:param request: Current request
:type request: :class:`kotti.request.Request`
:param success_msg: Message to display on successful submission handling
:type success_msg: str or TranslationString
:result: Redirect response or dictionary passed to the template for
rendering.
:rtype: pyramid.httpexceptions.HTTPFound or dict
"""
form = Form(SetPasswordSchema(),
buttons=(Button('submit', _('Set password')), ))
rendered_form = None
if 'submit' in request.POST:
try:
appstruct = form.validate(list(request.POST.items()))
except ValidationFailure as e:
rendered_form = e.render()
else:
token = appstruct['token']
email = appstruct['email']
user = _find_user(email)
if (user is not None and validate_token(user, token)
and token == user.confirm_token and user.active):
password = appstruct['password']
user.password = get_principals().hash_password(password)
user.confirm_token = None
headers = remember(request, user.name)
user.last_login_date = datetime.now()
location = (appstruct['continue_to']
or resource_url(context, request))
request.session.flash(success_msg, 'success')
return HTTPFound(location=location, headers=headers)
else:
request.session.flash(
_("Your password reset token may have expired."), 'error')
if rendered_form is None:
rendered_form = form.render(request.params)
api = template_api(
context,
request,
page_title=_("Reset your password - ${title}.",
mapping=dict(title=context.title)),
)
return {
'api': api,
'form': rendered_form,
}
