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, }