def edit_team(context, request): logged_in = authenticated_userid(request) schema = TeamSchema().bind(request=request) form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } params = parse(controls) context.title = params["title"] context.description = params["description"] leader = params["leader"] context.leader = leader members = params["members"] # Add the leader if they didn't add themselves if leader and leader not in members: members.append(leader) context.members = members # TODO: use find by interface here voting_booth = context.__parent__.__parent__ return HTTPFound(location=request.resource_url(voting_booth))
def add_voting_booth(context, request): logged_in = authenticated_userid(request) schema = VotingBoothSchema() form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } values = parse(request.params.items()) start, end = _process_dates(values) voting_booth = VotingBooth(title=values["title"], start=start, end=end, categories=values["categories"]) voting_booth.__parent__ = context # maybe this should be done in the team add view? team_folder = TeamFolder() team_folder.__parent__ = voting_booth team_folder.__name__ = "teams" voting_booth["teams"] = team_folder context.add_booth(voting_booth) return HTTPFound(location=request.resource_url(voting_booth))
def vote_view(context, request): logged_in = authenticated_userid(request) schema = BallotSchema().clone() _add_category_schema(context, request, schema) form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: # Put the team names back in place cstruct = e.cstruct for vote in cstruct["votes"]: team_id = vote["team_hidden"] team_obj = context["teams"][team_id] team_title = team_obj.title team_descrip = team_obj.description vote["team_title"] = team_title vote["team_members"] = ", ".join(team_obj.member_names()) vote["team_description"] = team_descrip return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } results = parse(request.params.items())["votes"] context.results[logged_in] = results context._p_changed = True return HTTPFound(location=request.resource_url(context))
def add_profile(context, request): logged_in = authenticated_userid(request) schema = ProfileAddSchema() form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } params = parse(controls) first_name = params["first_name"] last_name = params["last_name"] username = params["username"] email = params["email"] password = params["password"]["value"] # Create the profile profile = Profile(first_name=first_name, last_name=last_name, username=username, email=email) # Add the profile object profile.__parent__ = context["profiles"] profile.__name__ = username context["profiles"].add_profile(profile) # Add the user object user_folder = context["users"] user_folder.add(username, username, password) return HTTPFound(location=request.resource_url(context.__parent__))
def register(request): schema = RegisterForm() myform = Form(schema, buttons=('submit',)) userid = authenticated_userid(request) username = False if userid: user = User.by_id(userid) if user: username = user.name fields = { "layout": site_layout(), "page_title": "Register", "message": "", "url": request.application_url + '/register', "logged_in": username, } if username: fields['form'] = "You are already logged in. Please log out and try again." return fields if 'submit' in request.POST: controls = request.POST.items() try: myform.validate(controls) except ValidationFailure, e: fields['form'] = e.render() return fields #passed validation user = User() user.name = request.POST['username'] user.email = request.POST['email'] user.setpass(request.POST['password']) DBSession.add(user) fields['form'] = request.POST['username'] return fields
def add_team(context, request): logged_in = authenticated_userid(request) schema = TeamSchema().bind(request=request) form = Form(schema, buttons=("submit",)) css_resources, js_resources = _form_resources(form) if "submit" in request.POST: controls = request.POST.items() try: form.validate(controls) except (ValidationFailure,), e: return { "form": e.render(), "css_resources": css_resources, "js_resources": js_resources, "logged_in": logged_in, } params = parse(controls) leader = params["leader"] members = params["members"] # Add the leader if they didn't add themselves if leader and leader not in members: members.append(leader) team = Team(title=params["title"], description=params["description"], members=members, leader=leader) team.__parent__ = context context.add_team(team) return HTTPFound(location=request.resource_url(context.__parent__))
def view(self): title = "View Issue" issue_id = self.matchdict['id'] db = self.request.db issue = db.query(IssuesModel).filter_by(id=issue_id).first() add_issue_comment_schema = AddIssueCommentSchema() add_issue_comment_button = Button(name="comment_submit", title="Add Comment") add_issue_comment_form = Form(add_issue_comment_schema, buttons=[add_issue_comment_button]) add_issue_comment_form['body'].title = False add_tag_schema = AddTagSchema() add_tag_form = Form(add_tag_schema, css_class='add_tag_form') add_tag_form['tags'].title = False if 'comment_submit' in self.request.POST: controls = self.request.POST.items() try: captured = add_issue_comment_form.validate(controls) except ValidationFailure as e: return {'add_issue_comment_form':e.render(), 'add_tag_form':add_tag_form.render(), 'here':self.here, 'issue':issue, 'title':title} db = self.request.db issue_comment = IssueCommentsModel(body=captured['body'], created=datetime.now(), change_time=datetime.now()) issue.comments.append(issue_comment) db.flush() return HTTPFound(location="/issues/view/" + str(issue.id)) elif 'tags' in self.request.POST: controls = self.request.POST.items() try: captured = add_tag_form.validate(controls) except ValidationFailure as e: return {'add_tag_form':e.render(), 'add_issue_comment_form':add_issue_comment_form.render(), 'here':self.here, 'issue':issue, 'title':title} db = self.request.db tags = self.separateTags(captured['tags']) for tag in tags: issue.tags.append(TagsModel(name=tag)) db.flush() return HTTPFound(location="/issues/view/" + str(issue.id)) return {'title':title, 'here':self.here, 'issue':issue, 'add_tag_form':add_tag_form.render(), 'add_issue_comment_form':add_issue_comment_form.render()}
def view_login(self): authed_user = None # TODO deferred validator doesn't work! # @colander.deferred # @staticmethod def validate_auth(form, values): nonlocal authed_user login = values.get('login') password = values.get('password') """:type : User""" user = User.by_any(login) # TODO check # -cdunklau- : d9k_ so i'm thinking you just need to do # form['login'].error = colander.Invalid(form['login'], 'Unknown login') # and then raise deform.ValidationFailure(form, form.cstruct, None) or something if not user: raise exception_for_schema_field(form, 'login', 'Пользователь не найден') if not user.active: raise exception_for_schema_field(form, 'login', 'Аккаунт пользователя заблокирован') if user.password_hash is None: if user.email is None: raise exception_for_schema_field(form, 'password', 'Вход по паролю отключен. Почта не была привязана к аккаунту') raise exception_for_schema_field(form, 'password', 'Вход по паролю отключен') if not user.check_password(password): raise exception_for_schema_field(form, 'password', 'Неверный пароль') if not user.email_checked: raise exception_for_schema_field(form, 'login', 'Email пользователя не подтверждён. Проверьте почтовый ящик') # TODO показывать email "в звёздочках" authed_user = user login_form = Form( LoginSchema(validator=validate_auth).bind(), buttons=[Button(name='login_form_submit', title='Вход')], # css_class='no-red-stars' ) login_form.css_class += ' no-red-stars' if 'login_form_submit' in self.request.params: controls = self.request.POST.items() try: login_form.validate(controls) except deform.ValidationFailure as e: return dict(rendered_login_form=e.render()) if authed_user is not None: self.request.session.invalidate() headers = security.remember(self.request, authed_user.id) index = self.request.route_url('admin_index' if authed_user.is_admin() else 'index') return HTTPFound(location=index, headers=headers) return dict(rendered_login_form=login_form.render())
def view(request): available_projects = request.registry.settings['projects'] selected_project = get_selected_project(request) error_id = request.matchdict['id'] try: error = Error.objects(project=selected_project['id']).with_id(error_id) except: return HTTPNotFound() comment_schema = CommentsSchema() comment_form = Form(comment_schema, buttons=('submit',), formid="comment_form") tag_schema = TagSchema() tag_form = Form(tag_schema, buttons=('submit',), formid="tag_form") if 'submit' in request.POST: form_id = request.POST['__formid__'] controls = request.POST.items() if form_id == 'comment_form': try: values = comment_form.validate(controls) error.comments.append(Comment( author=request.user, content=values['comment'], created=int(time()) )) error.save() url = request.route_url('error_view', project=selected_project['id'], id=error_id) return HTTPFound(location=url) except ValidationFailure, e: comment_form_render = e.render() elif form_id == 'tag_form': try: values = tag_form.validate(controls) # build a list of comma seperated, non empty tags tags = [t.strip() for t in values['tag'].split(',') if t.strip() != ''] changed = False for tag in tags: if tag not in error.tags: error.tags.append(tag) changed = True Tag.create(tag).save() if changed: error.save() url = request.route_url('error_view', project=selected_project['id'], id=error_id) return HTTPFound(location=url) except ValidationFailure, e: tag_form_render = e.render()
def account_view(self): """This is the settings form for the user. The first time a user logs in, they are taken here so we can get their first and last name. """ # Special case when the db was blown away if self.user_id is not None and self.user is None: return self.logout() section_name = 'account' schema = SettingsSchema() form = Form(schema, buttons=('submit',)) css_resources, js_resources = self.form_resources(form) if 'submit' in self.request.POST: controls = self.request.POST.items() try: form.validate(controls) except ValidationFailure as e: msg = 'There was an error saving your settings.' self.request.session.flash(msg, queue='error') return { 'form': e.render(), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, } values = parse(self.request.params.items()) # Update the user with transaction.manager: self.user.first_name = values.get('first_name', u'') self.user.last_name = values.get('last_name', u'') self.user.time_zone = values.get('time_zone', u'US/Eastern') DBSession.add(self.user) self.request.session.flash( 'Settings updated successfully', queue='success', ) return HTTPFound('/list') # Get existing values if self.user is not None: appstruct = dict( first_name=self.user.first_name, last_name=self.user.last_name, time_zone=self.user.time_zone, ) else: appstruct = {} return { 'form': form.render(appstruct), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, }
def account_view(self): """This is the settings form for the user. The first time a user logs in, they are taken here so we can get their first and last name. """ # Special case when the db was blown away if self.user_id is not None and self.user is None: return self.logout() section_name = 'account' schema = SettingsSchema() form = Form(schema, buttons=('submit', )) css_resources, js_resources = self.form_resources(form) if 'submit' in self.request.POST: controls = self.request.POST.items() try: form.validate(controls) except ValidationFailure as e: msg = 'There was an error saving your settings.' self.request.session.flash(msg, queue='error') return { 'form': e.render(), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, } values = parse(self.request.params.items()) # Update the user with transaction.manager: self.user.first_name = values.get('first_name', u'') self.user.last_name = values.get('last_name', u'') self.user.time_zone = values.get('time_zone', u'US/Eastern') DBSession.add(self.user) self.request.session.flash( 'Settings updated successfully', queue='success', ) return HTTPFound('/list') # Get existing values if self.user is not None: appstruct = dict( first_name=self.user.first_name, last_name=self.user.last_name, time_zone=self.user.time_zone, ) else: appstruct = {} return { 'form': form.render(appstruct), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, }
def form_view(request): schema = EditMenuItems() myform = Form(schema, buttons=('submit',)) reqt = myform.get_widget_resources(myform.get_widget_requirements()) if 'submit' in request.POST: controls = request.POST.items() try: myform.validate(controls) except ValidationFailure as e: return {'form':e.render()} return {'form':'OK'} return {'form': myform.render(), 'project': 'poop', 'css': reqt['css'], 'js': reqt['js']}
def register_view(context, request): form = Form(Signup(), buttons=('register', )) rendered_form = form.render(null) if 'register' in request.POST: try: appstruct = form.validate(request.POST.items()) except ValidationFailure, e: rendered_form = e.render() else: pending = request.registry.queryAdapter(context, IRegistrations, name='pending') if pending is None: #pragma NO COVERAGE pending = PendingRegistrations(context) email = appstruct['email'] token = getRandomToken(request) pending.set(email, token=token) from_addr = request.registry.settings['cartouche.from_addr'] delivery = request.registry.queryUtility(IMailDelivery, default=localhost_mta) confirmation_url = view_url(context, request, 'confirmation_url', 'confirm_registration.html', email=email) body = REGISTRATION_EMAIL % { 'token': token, 'confirmation_url': confirmation_url } message = Message() message['Subject'] = 'Site registration confirmation' message.set_payload(body) delivery.send(from_addr, [email], message) return HTTPFound(location=confirmation_url)
def qr_label(self): """ Process form parameters, create a qr code or return an empty form. """ form = Form(StickerSchema(), buttons=("submit", )) if "submit" in self.request.POST: #log.info("submit: %s", self.request.POST) controls = self.request.POST.items() try: appstruct = form.validate(controls) rendered_form = form.render(appstruct) self.write_optional_uploads(appstruct) self.check_background_size(appstruct) self.build_qr_label(appstruct) return {"form": rendered_form, "appstruct": appstruct} except ValidationFailure as exc: #log.exception(exc) log.info("Validation failure") return {'form': exc.render()} return {"form": form.render()}
def admin_user_edit(request): def default_values(schema, user): for field in schema.children: if field.name in user and field.name != 'password': field.default = user[field.name] user = User.objects.with_id(request.matchdict['user']) schema = UserFormSchema(validator=user_form_validator(user)) default_values(schema, user) form = Form(schema, buttons=('submit',)) form_render = None if 'submit' in request.POST: controls = request.POST.items() try: values = form.validate(controls) user.update(values) user.save() default_values(schema, user) except ValidationFailure, e: form_render = e.render()
class Three(Layouts): def __init__(self, context, request): super(Three, self).__init__(context, request) schema = GuestBookSchema().bind() button = Button(name="submit", title="Submit") self.form = Form(schema, buttons=(button,)) @view_config(request_method="GET") def get(self): return { 'form': self.form.render(), 'js': self.form.get_widget_resources()['js'], 'css': self.form.get_widget_resources()['css'], 'comments': comments, } @view_config(request_method="POST", request_param="submit") def post(self): controls = self.request.POST.items() try: appstruct = self.form.validate(controls) except ValidationFailure as e: return { 'form': e.render(), 'js': self.form.get_widget_resources()['js'], 'css': self.form.get_widget_resources()['css'], 'comments': comments, } # So, obviously, in real life this would go in a database, # but I CBA, so I'm using a global value as my DB comments.append(appstruct) return {'form':'', 'comments':comments}
def password_form(self): # if admin is changing password for another user no verification of current password is needed if self.context != self.api.user_profile and self.api.context_has_permission( MANAGE_SERVER, self.api.root): schema = createSchema('ChangePasswordAdminSchema') else: schema = createSchema('ChangePasswordSchema') add_csrf_token(self.context, self.request, schema) schema = schema.bind(context=self.context, request=self.request, api=self.api) form = Form(schema, buttons=(button_update, button_cancel)) self.api.register_form_resources(form) post = self.request.POST if 'update' in post: controls = post.items() try: #appstruct is deforms convention. It will be the submitted data in a dict. appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response self.context.set_password(appstruct['password']) msg = _(u"Password changed") self.api.flash_messages.add(msg) url = resource_url(self.context, self.request) return HTTPFound(location=url)
def pbblspop(self): session = self.request.session request = self.request resource = None url = request.resource_url(resource) datas = sipkd_init(request, self.context) if session['logged'] == 0: return HTTPFound(location='/') datas.update(osLSpop.BlankRow()) schema = osLSpopValid() myform = Form(schema, buttons=('btn_save', )) if 'btn_save' in self.request.POST: controls = self.request.POST.items() data2 = dict((x, y) for x, y in controls) datas.update(data2) datas['form_visible'] = '1' datas['readonly'] = 'readonly' try: appstruct = myform.validate(controls) osDOPBng.edit(datas) except ValidationFailure, e: return dict(datas=datas, url=url) data2 = cls.BlankRow() datas.update(data2) datas['form_visible'] = '0' datas['readonly'] = ''
def my_view(request): request.response.headers.update({ 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Methods': 'POST,GET,DELETE,PUT,OPTIONS', 'Access-Control-Allow-Headers': 'Origin, Content-Type, Accept, Authorization', 'Access-Control-Allow-Credentials': 'true', 'Access-Control-Max-Age': '1728000', }) schema = Drill() drillform = Form(schema, buttons=('submit',)) if 'submit' in request.POST: controls = request.POST.items() try: appstruct = drillform.validate(controls) cmdrname = appstruct.pop("client_name", "InvalidClient") system = appstruct.pop("system", "InvalidSystem") platform = appstruct.pop("platform", "InvalidPlatform") o2status = appstruct.pop("o2status", "OK") channel = appstruct.pop("channel", "InvalidChannel") overseer = appstruct.pop("overseer", "InvalidSeer") message = f"Incoming Client: {cmdrname} - System: {system} - Platform: {platform} - O2: {o2status} - Language: English (en-US)" send(channel, message, "No short for you!", request) logging.info(f"Client announcement for Overseer {overseer} made in {channel}. Client: {cmdrname}") except ValidationFailure as e: logging.error(f"Validation failed for a call to the drill client announcer!") return {'form': e.render()} return {'form': 'Completed!', 'appstruct': appstruct} else: rendered_form = drillform.render() return dict(form=rendered_form)
def generate_thumbnails(self): """ Display the form on get, on submission, save the uploaded pdf to the "serial" directory, and return the form populated along with the generated thumbnails. """ form = Form(PDFUploadSchema(), buttons=("submit", )) if "submit" in self.request.POST: log.info("submit: %s", self.request.POST) controls = self.request.POST.items() try: appstruct = form.validate(controls) rendered_form = form.render(appstruct) self.write_upload_files(appstruct) self.write_thumbnails(appstruct) return {"form": rendered_form, "appstruct": appstruct} except ValidationFailure as exc: log.info("Validation failure") return {'form': exc.render()} return {"form": form.render()}
def login(request): schema = UserLoginSchema(validator=user_login_validator) form = Form(schema, buttons=('submit', )) userid = authenticated_userid(request) if userid: return HTTPFound(location='/') if 'submit' in request.POST: controls = request.POST.items() try: values = form.validate(controls) try: user = User.objects.get(email=values['email']) user.tzoffset = values['tzoffset'] user.save() except DoesNotExist: return HTTPNotFound() headers = remember(request, str(user.id), max_age=10000000000) return HTTPFound(location='/', headers=headers) except ValidationFailure: form_render = form.render() else: form_render = form.render() params = {'form': Markup(form_render)} return render_to_response('user/login.html', params)
def add_permission(self): if ISiteRoot.providedBy(self.context): self.response['title'] = _(u"Add permission") post = self.request.POST if 'cancel' in post: url = resource_url(self.context, self.request) return HTTPFound(location=url) schema = createSchema('SinglePermissionSchema') add_csrf_token(self.context, self.request, schema) schema = schema.bind(context=self.context, request=self.request, api=self.api) form = Form(schema, buttons=(button_add, button_cancel)) self.api.register_form_resources(form) if IMeeting.providedBy(self.context): self.response['tabs'] = self.api.render_single_view_component( self.context, self.request, 'tabs', 'manage_tickets') if 'add' in post: controls = post.items() try: appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response #Set permissions self.context.set_groups(appstruct['userid'], appstruct['groups'], event=True) msg = _(u"Added permssion for user ${userid}", mapping={'userid': appstruct['userid']}) self.api.flash_messages.add(msg) url = resource_url(self.context, self.request) return HTTPFound(location=url)
def group_form(self): if IMeeting.providedBy(self.context): self.response['title'] = _(u"Edit permissions") else: self.response['title'] = _(u"Root permissions") post = self.request.POST if 'cancel' in post: url = resource_url(self.context, self.request) return HTTPFound(location=url) schema = createSchema('PermissionsSchema') add_csrf_token(self.context, self.request, schema) schema = schema.bind(context=self.context, request=self.request, api=self.api) form = Form(schema, buttons=('save', 'cancel')) self.api.register_form_resources(form) if 'save' in post: controls = post.items() try: appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response #Set permissions self.context.set_security(appstruct['userids_and_groups']) url = resource_url(self.context, self.request) return HTTPFound(location=url)
def index(request): search_form = Form(SearchSchema(validator=search_at_least_one_validator), buttons=('submit', )) response_data = {'search_form': search_form, 'data': {}} post = request.POST # if form was not sent, return if 'submit' not in post: return response_data # validate form, return if invalid controls = request.POST.items() try: data = search_form.validate(controls) response_data['data'] = data except ValidationFailure: return response_data # if we are here, form is valid. Get events! search_api = SearchApiV2(SEARCH_API_V2_KEY) response_data['events'] = search_api \ .country(data.get('country')) \ .city(data.get('city')) \ .topic('running') \ .get() return response_data
def login(request): schema = UserLoginSchema(validator=user_login_validator) form = Form(schema, buttons=('submit',)) userid = authenticated_userid(request) if userid: return HTTPFound(location='/') if 'submit' in request.POST: controls = request.POST.items() try: values = form.validate(controls) try: user = User.objects.get(email=values['email']) user.tzoffset = values['tzoffset'] user.save() except DoesNotExist: return HTTPNotFound() headers = remember(request, str(user.id), max_age=10000000000) return HTTPFound(location='/', headers=headers) except ValidationFailure: form_render = form.render() else: form_render = form.render() params = { 'form': Markup(form_render) } return render_to_response('user/login.html', params)
def edit(self): user = self.request.context dashboard_user = user if user.ona_user is not None: dashboard_user = dashboard_user.ona_user form = Form(UserForm().bind(request=self.request, user=dashboard_user), buttons=('Save', Button(name='cancel', type='button')), appstruct=user.appstruct) if self.request.method == 'POST': data = self.request.POST.items() try: values = form.validate(data) except ValidationFailure: pass else: dashboard_user.update(values) self.request.session.flash(_("Your changes have been saved"), 'success') return HTTPFound( self.request.route_url('admin', traverse=(dashboard_user.id, 'edit'))) period = get_period_from_request(self.request) return {'form': form, 'user': dashboard_user, 'period': period}
def set_password(context, request, success_msg=u"You've reset your password successfully."): form = Form(SetPasswordSchema(), buttons=('submit',)) rendered_form = None if 'submit' in request.POST: try: appstruct = form.validate(request.POST.items()) except ValidationFailure, e: request.session.flash(u"There was an error.", 'error') 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): password = appstruct['password'] user.password = get_principals().hash_password(password) user.confirm_token = None headers = remember(request, user.name) 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')
def register(self): form = Form(RegistrationForm().bind(request=self.request), buttons=('Save', )) if self.request.method == 'POST': data = self.request.POST.items() try: values = form.validate(data) except ValidationFailure: self.request.session.flash( _(u"Please fix the highlighted errors below"), "error") else: try: new_user = User() new_user.update(values) self.request.session.flash( _(u"Success! {} user created".format( new_user.profile.username)), 'success') return HTTPFound( self.request.route_url('admin', traverse=(new_user.id, 'edit'))) except IntegrityError: transaction.abort() self.request.session.flash(_("Username already in use"), "error") return {'form': form, 'period': get_period_from_request(self.request)}
def add_form(self): post = self.request.POST if 'cancel' in post: self.api.flash_messages.add(_(u"Canceled")) url = resource_url(self.context, self.request) return HTTPFound(location=url) schema = createSchema('AddUserSchema') add_csrf_token(self.context, self.request, schema) schema = schema.bind(context=self.context, request=self.request, api = self.api) form = Form(schema, buttons=(button_add, button_cancel)) self.api.register_form_resources(form) if 'add' in post: controls = post.items() try: #appstruct is deforms convention. It will be the submitted data in a dict. appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response #Userid and name should be consistent name = appstruct['userid'] del appstruct['userid'] #creators takes care of setting the role owner as well as adding it to creators attr. obj = createContent('User', creators=[name], **appstruct) self.context[name] = obj self.api.flash_messages.add(_(u"Successfully added")) url = resource_url(self.context, self.request) return HTTPFound(location=url)
def set_password(context, request, success_msg=_(u"You've reset your password successfully.")): form = Form(SetPasswordSchema(), buttons=(Button('submit', _(u'Submit')), )) rendered_form = None if 'submit' in request.POST: try: appstruct = form.validate(request.POST.items()) except ValidationFailure, e: request.session.flash(_(u"There was an error."), 'error') 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): password = appstruct['password'] user.password = get_principals().hash_password(password) user.confirm_token = None headers = remember(request, user.name) 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')
def page_edit(request): page_id = request.matchdict['page_id'] page = request.context.page if not page: ## TODO: setup notfound view raise NotFound("No such part {0}".format(page_id)) logged_in = authenticated_userid(request) api = get_template('ravel:templates/main.pt') schema = request.context.schema form = Form(schema, buttons=('submit',)) form['body'].widget = widget.TextAreaWidget(rows=10, cols=60) if request.method == "POST": controls = request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure, e: return { 'api' : api, 'description' : 'Edit ' + page['title'], 'form': e.render(), 'logged_in' : logged_in, 'title' : 'Edit ' + page['title'], } appstruct['_id'] = page['_id'] appstruct['url_id'] = page_id oid = request.context.collection.save(appstruct, safe=True) logging.info("page_edit saved {0}".format(oid)) return HTTPFound(location=route_url('page_view', request, page_id=page_id))
def view_login(request): if authenticated_userid(request): return HTTPFound(location=request.route_url('home')) schema = Login(validator=login_validator) form = Form(schema, buttons=('login', )) if 'login' in request.POST: controls = request.POST.items() identity = request.POST.get('username') user = schema.user = User.get_by_identity(identity) try: c = form.validate(controls) except ValidationFailure, e: request.session['login failed'] = e.render() return HTTPFound(location=request.route_url('login')) ##################################################### request.session['tahun'] = datetime.now().year request.session['tanggal'] = datetime.today() request.session['tanggal_to'] = datetime.today() request.session['unit_id'] = 0 request.session['unit_kd'] = "" request.session['unit_nm'] = "" request.session['rekening_kd'] = "" request.session['rekening_nm'] = "" request.session['rekening_id'] = "" headers = get_login_headers(request, user) return HTTPFound(location=request.route_url('home'), headers=headers)
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, 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'] = set(['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 receive an email with a link to set your ' 'password momentarily.') request.session.flash(success_msg, 'success') return HTTPFound(location=request.application_url)
def profile_edit_view(self): schema = ProfileEditSchema() profile_edit_form = Form( schema.bind(), buttons=[ Button(name='profile_edit_form_submit', title='Изменить') ], ) if 'profile_edit_form_submit' in self.request.params: controls = self.request.POST.items() try: data = profile_edit_form.validate(controls) except deform.ValidationFailure as e: return dict(rendered_profile_edit_form=e.render()) name = data.get('name') if name: self.user.name = name try: with transaction.manager: DBSession.add(self.user) except DBAPIError: return Response(conn_err_msg, content_type='text/plain', status_int=500) #TODO name validator appstruct = dictalchemy.utils.asdict(self.user, include=['name']) return dict( rendered_profile_edit_form=profile_edit_form.render(appstruct))
def user_edit_submit(self): user = self.context.user controls = self.request.POST.items() schema = MagicUserEdit().bind(request=self.request) f = Form(schema, action=self.request.current_route_url(), button=('submit',)) try: appstruct = f.validate(controls) current_groups = set([x.id for x in user.groups]) selected_groups = set([x['group_id'] for x in appstruct['groups']]) new_groups = selected_groups - current_groups rem_groups = current_groups - selected_groups for g in new_groups: group = m.Group.find_group_by_id(g) user.groups.append(group) if len(rem_groups): for g in user.groups: if g.id in rem_groups: user.groups.remove(g) user.validated = appstruct['validated'] self.request.session.flash('User {} has been modified.'.format(user.disp_uname), queue='magic') return HTTPSeeOther(location = self.request.route_url('defcne.magic', traverse=('u'))) except ValidationFailure, e: return { 'form': e.render(), 'page_title': 'Editing user: {}'.format(user.disp_uname), }
def variant(self): question_name = self.request.GET.get('question_name', None) globalquestions = self.root['questions'] if question_name not in globalquestions: self.add_flash_message(_(u"Invalid question name.")) url = self.request.resource_url(self.context) return HTTPFound(location=url) question = globalquestions[question_name] schema = createSchema(question.schemas['translate']) schema.title = _(u"Edit question variant for this organisation") schema = schema.bind(context = question, request = self.request) # add default locale description = question.get_original_title() descriptions = question.get_question_text() self.trans_util.add_translation_schema(schema['question_text'], self.trans_util.default_locale_name, description=description) self.trans_util.add_translations_schema(schema['question_text'], self.context, descriptions=descriptions, only_with_description=True) form = Form(schema, action = self.request.url, buttons=(self.buttons['save'], self.buttons['cancel'])) self.response['form_resources'] = form.get_widget_resources() if 'save' in self.request.POST: controls = self.request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response for (lang, value) in appstruct['question_text'].items(): self.context.set_variant(question_name, lang, value) url = self.request.resource_url(self.context, 'variants') return HTTPFound(location = url)
def login_view(request): """ Login view """ log.debug("# Login page") form = Form(authSchema, buttons=(Button(name="submit", title="Valider", type='submit'),)) nextpage = request.params.get('nextpage') or request.route_url('index') app_struct = {'nextpage':nextpage} myform = form.render(app_struct) fail_message = None if 'submit' in request.params: log.debug(" + Validating authentication") controls = request.params.items() try: datas = form.validate(controls) except ValidationFailure, err: log.debug("Erreur d'authentification") myform = err.render() request.session.flash(_(request, u"Authentication error"), "error") return {'title':"Login page", 'form':myform,} log.debug(" + Validation ok, redirecting") log.debug(" -> {0}".format(nextpage)) login = datas['login'] # Storing the datas in the session remember(request, login) return HTTPFound(location=nextpage)
def preferences(request): schema = UserPreferencesSchema() button1 = Button('submit', _('Save changes')) button1.css_class = 'btn-primary' form = Form(schema, buttons=(button1, )) user = request.user if 'submit' in request.POST: controls = request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure as e: return {'form': e.render()} user.update_preferences(appstruct) Session.add(user) request.session.flash( _('The changes were saved successfully'), 'success', ) return HTTPFound(location=request.route_path('user_preferences')) return { 'form': form.render({ 'allow_google_analytics': user.allow_google_analytics, 'send_passwords_periodically': user.send_passwords_periodically, }) }
def register_view(context, request): form = Form(Signup(), buttons=('register',)) rendered_form = form.render(null) if 'register' in request.POST: try: appstruct = form.validate(request.POST.items()) except ValidationFailure, e: rendered_form = e.render() else: pending = request.registry.queryAdapter(context, IRegistrations, name='pending') if pending is None: #pragma NO COVERAGE pending = PendingRegistrations(context) email = appstruct['email'] token = getRandomToken(request) pending.set(email, token=token) from_addr = request.registry.settings['cartouche.from_addr'] delivery = request.registry.queryUtility(IMailDelivery, default=localhost_mta) confirmation_url = view_url(context, request, 'confirmation_url', 'confirm_registration.html', email=email) body = REGISTRATION_EMAIL % {'token': token, 'confirmation_url': confirmation_url} message = Message() message['Subject'] = 'Site registration confirmation' message.set_payload(body) delivery.send(from_addr, [email], message) return HTTPFound(location=confirmation_url)
def login_form_process(self): """Process login form. Render form if attempt_authorize was failed and redirect to root '/' of site. Return form in 'form' key. @todo redirect to request_from url @todo process csrf value""" schema = AuthSchema() form = Form(schema, buttons=('submit', )) if 'submit' in self.request.POST: controls = self.request.POST.items() values = None try: appstruct = form.validate(controls) except ValidationFailure, e: return render_to_response('templates/auth_form.jinja2', {'form': e.render()}) # make here call of attempt_login if self.user_helper.attempt_authorize(appstruct['login'], appstruct['password']): remember(self.request, appsctruct['login']) return HTTPFound("/") else: return render_to_response( 'templates/auth_form.jinja2', {'form': form.render(appstruct=appstruct)}) return HTTPFound('/')
def calibration_report(self): """ Process form paramters, create a pdf calibration report form and generate a thumbnail view. """ form = Form(ReportSchema(), buttons=("submit",)) if "submit" in self.request.POST: #log.info("submit: %s", self.request.POST) controls = self.request.POST.items() try: appstruct = form.validate(controls) rendered_form = form.render(appstruct) report = self.populate_data(appstruct) self.makedir_write_files(appstruct) pdf = WasatchSinglePage(filename=report.filename, report=report) pdf.write_thumbnail() return {"form":rendered_form, "appstruct":appstruct} except ValidationFailure as exc: #log.exception(exc) log.info("Validation failure") return {'form':exc.render()} return {"form":form.render()}
def generate_thumbnails(self): """ Display the form on get, on submission, save the uploaded pdf to the "serial" directory, and return the form populated along with the generated thumbnails. """ form = Form(PDFUploadSchema(), buttons=("submit",)) if "submit" in self.request.POST: log.info("submit: %s", self.request.POST) controls = self.request.POST.items() try: appstruct = form.validate(controls) rendered_form = form.render(appstruct) self.write_upload_files(appstruct) self.write_thumbnails(appstruct) return {"form":rendered_form, "appstruct":appstruct} except ValidationFailure as exc: log.info("Validation failure") return {'form':exc.render()} return {"form":form.render()}
def post(self): controls = self.request.POST.items() form = Form(SignupForm()) data = form.validate(controls) name = data.get("name") mail = data.get("email") if DBSession.query(User).get(name): raise DuplicateUserName() if DBSession.query(User).filter_by(mail=mail).count() > 0: raise DuplicateEmail() user = User(name=name) password = user.generate_password() user.mail = mail DBSession.add(user) msg = WelcomeMessage() msg.send(self.request, user, password) self.flash("info", "Your account has been created and your " "initial password was sent to %s" % (mail)) return self.redirect("login")
def edit(request): geo_form_schema = _get_schema(request) renderer = _get_renderer(geo_form_schema.templates_admin) form = Form( geo_form_schema.schema_admin, buttons=('submit',), renderer=renderer) _populate_widgets(form.schema, DBSession, request) if 'submit' in request.POST: form_data = request.POST.items() try: obj_dict = form.validate(form_data) except ValidationFailure, e: rendered = e.render() else: obj = geo_form_schema.schema_admin.objectify(obj_dict) obj = DBSession.merge(obj) DBSession.flush() # FIXME create a fresh form, otherwise the IDs of objects in # relationships will not be rendered # see https://github.com/Pylons/deform/issues/236 form = Form( geo_form_schema.schema_admin, buttons=('submit',), renderer=renderer) rendered = form.render(geo_form_schema.schema_admin.dictify(obj), request=request)
def login(request): schema = UserLoginSchema(validator=user_login_validator) form = Form(schema, buttons=("submit",)) userid = authenticated_userid(request) if userid: return HTTPFound(location="/") if "submit" in request.POST: controls = request.POST.items() try: values = form.validate(controls) try: user = User.objects.get(email=values["email"]) except DoesNotExist: return HTTPNotFound() headers = remember(request, str(user.id)) return HTTPFound(location="/", headers=headers) except ValidationFailure: form_render = form.render() else: form_render = form.render() params = {"form": Markup(form_render)} return render_to_response("user/login.html", params)
def recover_account_view(context, request): form = Form(RecoverAccount(), buttons=('recover',)) rendered_form = form.render(null) confirmed = request.registry.queryAdapter(context, IRegistrations, name='confirmed') if confirmed is None: #pragma NO COVERAGE confirmed = ConfirmedRegistrations(context) login_url = view_url(context, request, 'login_url', 'login.html') registry = request.registry message = request.GET.get('message') if 'recover' in request.POST: try: appstruct = form.validate(request.POST.items()) except ValidationFailure, e: #pragma NO COVER rendered_form = e.render() else: email = appstruct['email'] record = confirmed.get_by_email(email) if record is not None: from_addr = registry.settings['cartouche.from_addr'] login = record.login body = RECOVERY_EMAIL % {'login': login, 'login_url': login_url} delivery = registry.queryUtility(IMailDelivery, default=localhost_mta) email_message = Message() email_message['Subject'] = 'Account recovery' email_message.set_payload(body) delivery.send(from_addr, [email], email_message) #else: # DO NOT report lookup errors return HTTPFound(location=login_url)
def update_user(self): template_vars = {'menu_active': 'update_user'} form = Form(Registration().bind(request=self.request), buttons=('submit',), action=self.request.route_url('update_user')) if 'submit' in self.request.POST: # detect that the submit button was clicked controls = self.request.POST.items() # get the form controls try: form_data = form.validate(controls) # call validate except ValidationFailure as e: # catch the exception template_vars['form'] = form.render() # re-render the form with an exception return template_vars # if user is logged, we update his profile. Else we create a new user. userid = authenticated_userid(self.request) if userid: user = User.by_id(userid) # WARNING: only update authorized values else: del(form_data['csrf']) user = User(**form_data) DBSession.add(user) url = self.request.route_url('home') return HTTPFound(location=url) template_vars['form'] = form.render() return template_vars
def login_view(context, request): whence = request.registry.queryUtility(ICameFromURL) if whence is not None: came_from = whence(request) else: came_from = resource_url(context, request) form = Form(Login(), buttons=('login',)) rendered_form = form.render({'came_from': came_from}) message = request.GET.get('message') if 'login' in request.POST: try: appstruct = form.validate(request.POST.items()) except ValidationFailure, e: rendered_form = e.render() message = 'Please supply required values' else: credentials = {'login': appstruct['login_name'], 'password': appstruct['password'], } api = get_api(request.environ) identity, headers = api.login(credentials) if identity is not None: came_from = appstruct.get('came_from') if came_from is None: came_from = resource_url(context, request) return HTTPFound(location=came_from, headers=headers) message = 'Login failed'
def view_login(request): if authenticated_userid(request): return HTTPFound(location=request.route_url('forbidden')) login_url = request.resource_url(request.context,'login') referrer = request.url if referrer == login_url: referrer = '/' came_from = request.params.get('came_from', referrer) schema = Login(validator=login_validator) form = Form(schema, buttons=('login',)) if 'login' in request.POST: controls = request.POST.items() identity = request.POST.get('username') user = schema.user = User.get_by_identity(identity) try: c = form.validate(controls) except ValidationFailure, e: request.session['login failed'] = e.render() return HTTPFound(location=came_from) #location.request.route_url('login') headers = get_login_headers(request, user) return HTTPFound(location=came_from, # request.route_url(came_from), headers=headers)
def apbd_ref1_form(self): request = self.request session = request.session resource = None url = request.resource_url(resource) datas = sipkd_init(self.request, self.context) datas.update(self.BlankRow()) if session['logged'] <> 1: return HTTPFound(location='/logout') fields = self.request.matchdict datas.update(self.BlankRow()) if 'id' in fields: datas['form_visible'] = 1 datas['id'] = fields['id'] datas.update(osRefRekening.row2dict( osRefRekening.get_by_id(datas))) schema = osfRekeningValid() myform = Form(schema, buttons=('submit', )) if 'btn_save' in self.request.POST: controls = self.request.POST.items() data2 = dict((x, y) for x, y in controls) datas.update(data2) #datas['message']='Berhasil' try: appstruct = myform.validate(controls) datas.update(appstruct) osKelurahan.edit(datas) except ValidationFailure, e: return dict(datas=datas) data2 = self.BlankRow() datas.update(data2)
def post(self): controls = self.request.POST.items() form = Form(SignupForm()) data = form.validate(controls) name = data.get("name") mail = data.get("email") if DBSession.query(User).get(name): raise DuplicateUserName() if DBSession.query(User).filter_by(mail=mail).count() > 0: raise DuplicateEmail() user = User(name=name) password = user.generate_password() user.mail = mail DBSession.add(user) msg = WelcomeMessage() msg.send(self.request, user, password) self.flash( "info", "Your account has been created and your " "initial password was sent to %s" % (mail)) return self.redirect("login")
def edit(self): location = self.request.context form = Form( LocationForm().bind( request=self.request, location=location), buttons=('Save', Button(name='cancel', type='button')), appstruct=location.appstruct) if self.request.method == 'POST': data = self.request.POST.items() try: values = form.validate(data) except ValidationFailure: pass else: location.update(**values) self.request.session.flash( _("Your changes have been saved"), 'success') return HTTPFound( self.request.route_url( 'locations', traverse=(location.id, 'edit'))) return { 'form': form, 'location': location, 'period': self.period }
def pbbdspop(self): session = self.request.session if session['logged']<>1: return HTTPFound(location='/logout') request = self.request resource = None url=request.resource_url(resource) datas= osSpop.BlankRow() datas['wp_pekerjaan']=osLookup.get_wp_pekerjaan() datas['wp_status']=osLookup.get_wp_status() if self.request.session['sa']==1: datas['opts']=osApps.get_rows() opts = osApps.get_rows() else: pass schema = osSpopValid() myform = Form(schema, buttons=('submit',)) if 'btn_save' in self.request.POST: controls = self.request.POST.items() try: appstruct = myform.validate(controls) except ValidationFailure, e: return {'form':e.render(), 'values': False} # Process the valid form data, do some work data2=dict((x, y) for x, y in controls) datas.update(data2) print datas
def pbb_ref_kecamatan(self): session = self.request.session request = self.request resource = None url = request.resource_url(resource) datas = sipkd_init(self.request, self.context) datas.update(self.BlankRow()) fields = self.request.matchdict if len(fields['kode']) > 5: kode = osKecamatan.kode_split(fields['kode']) datas.update(osKecamatan.row2dict(osKecamatan.get_by_kode(kode))) schema = osfKecamatanValid() myform = Form(schema, buttons=('submit', )) if 'btn_save' in self.request.POST: controls = self.request.POST.items() data2 = dict((x, y) for x, y in controls) datas.update(data2) #datas['message']='Berhasil' try: appstruct = myform.validate(controls) datas.update(appstruct) osKecamatan.edit(datas) except ValidationFailure, e: return dict(datas=datas) data2 = self.BlankRow() datas.update(data2)
def request_password(self): schema = createSchema('RequestNewPasswordSchema').bind(context=self.context, request=self.request) form = Form(schema, buttons=(button_request, button_cancel)) self.api.register_form_resources(form) #Handle submitted information if 'request' in self.request.POST: controls = self.request.POST.items() try: #appstruct is deforms convention. It will be the submitted data in a dict. appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response userid_or_email = appstruct['userid_or_email'] #userid here can be either an email address or a login name if '@' in userid_or_email: #assume email user = self.context['users'].get_user_by_email(userid_or_email) else: user = self.context['users'].get(userid_or_email) if IUser.providedBy(user): user.new_request_password_token(self.request) self.api.flash_messages.add(_('Email sent.')) url = resource_url(self.api.root, self.request) return HTTPFound(location = url) self.api.flash_messages.add(_('Username or email not found.'), type='error')
def removeListing(self): """Deal with the listing removal page. The user is asked to give the reason they are removing the listing, then it is removed. """ listing_id = self.request.matchdict.get('listing_id', None) if listing_id: listing = self.jobs_lib.getListingById(listing_id) if listing.user_id != self.request.authenticated_userid: return HTTPForbidden() myform = Form(removeSchema, buttons=('Remove Listing',)) if self.request.method == 'POST': check_csrf_token(self.request) controls = self.request.POST.items() # get the form controls try: appstruct = myform.validate(controls) # call validate except deform.ValidationFailure as e: # catch the exception return {'form':e.render()} # re-render the form with an exception user = self.jobs_lib.getUserById(self.request.authenticated_userid) if not listing.removal_reason: self.jobs_lib.removeListing(user, listing, appstruct['removal_reason']) self.request.override_renderer = 'generic_message.mako' return dict(heading="Listing Removed", messageList=["Your listing will no longer appear on the site.", "Thank you for using %s." % self.request.registry.settings['jobs.sitename']]) else: appstruct = dict(csrf_token=self.request.session.get_csrf_token()) return dict(form=myform.render(appstruct))
def password_form(self): # if admin is changing password for another user no verification of current password is needed if self.context != self.api.user_profile and self.api.context_has_permission(MANAGE_SERVER, self.api.root): schema = createSchema('ChangePasswordAdminSchema') else: schema = createSchema('ChangePasswordSchema') add_csrf_token(self.context, self.request, schema) schema = schema.bind(context=self.context, request=self.request, api = self.api) form = Form(schema, buttons=(button_update, button_cancel)) self.api.register_form_resources(form) post = self.request.POST if 'update' in post: controls = post.items() try: #appstruct is deforms convention. It will be the submitted data in a dict. appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response self.context.set_password(appstruct['password']) msg = _(u"Password changed") self.api.flash_messages.add(msg) url = resource_url(self.context, self.request) return HTTPFound(location=url)
def view_edit_manage_connected_profiles(self): schema = createSchema('ManageConnectedProfilesSchema').bind( context=self.context, request=self.request) form = Form(schema, buttons=(button_delete, button_cancel)) self.api.register_form_resources(form) #Handle submitted information if 'delete' in self.request.POST: controls = self.request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response domains = appstruct['auth_domains'] if domains: for domain in domains: del self.context.auth_domains[domain] msg = _(u"Removing information for: ${domains}", mapping={'domains': ", ".join(domains)}) self.api.flash_messages.add(msg) else: self.api.flash_messages.add(_(u"Nothing updated")) url = resource_url(self.context, self.request) return HTTPFound(location=url)