def test_html5(): result = htmlfill.render('<input type="number" name="quantity">', {'quantity': '10'}) assert result == '<input type="number" name="quantity" value="10">' try: result = htmlfill.render('<input type="unknown" name="quantity">', {'quantity': '10'}) except AssertionError, e: assert "I don't know about this kind of <input>: unknown at 1:0" in str(e)
def my_account(self): """ GET /_admin/my_account Displays info about my account """ # url('my_account') c.active = 'profile' self.__load_data() c.perm_user = AuthUser(user_id=self.authuser.user_id) c.ip_addr = self.ip_addr managed_fields = auth_modules.get_managed_fields(c.user) def_user_perms = User.get_default_user().AuthUser.permissions['global'] if 'hg.register.none' in def_user_perms: managed_fields.extend(['username', 'firstname', 'lastname', 'email']) c.readonly = lambda n: 'readonly' if n in managed_fields else None defaults = c.user.get_dict() update = False if request.POST: _form = UserForm(edit=True, old_data={'user_id': self.authuser.user_id, 'email': self.authuser.email})() form_result = {} try: post_data = dict(request.POST) post_data['new_password'] = '' post_data['password_confirmation'] = '' form_result = _form.to_python(post_data) # skip updating those attrs for my account skip_attrs = ['admin', 'active', 'extern_type', 'extern_name', 'new_password', 'password_confirmation', ] + managed_fields UserModel().update(self.authuser.user_id, form_result, skip_attrs=skip_attrs) h.flash(_('Your account was updated successfully'), category='success') Session().commit() update = True except formencode.Invalid as errors: return htmlfill.render( render('admin/my_account/my_account.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) except Exception: log.error(traceback.format_exc()) h.flash(_('Error occurred during update of user %s') \ % form_result.get('username'), category='error') if update: raise HTTPFound(location='my_account') return htmlfill.render( render('admin/my_account/my_account.html'), defaults=defaults, encoding="UTF-8", force_defaults=False)
def settings_global(self): """GET /admin/settings/global: All items in the collection""" # url('admin_settings_global') c.active = 'global' if request.POST: application_form = ApplicationSettingsForm()() try: form_result = application_form.to_python(dict(request.POST)) except formencode.Invalid as errors: return htmlfill.render( render('admin/settings/settings.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) try: sett1 = Setting.create_or_update('title', form_result['title']) Session().add(sett1) sett2 = Setting.create_or_update('realm', form_result['realm']) Session().add(sett2) sett3 = Setting.create_or_update('ga_code', form_result['ga_code']) Session().add(sett3) sett4 = Setting.create_or_update('captcha_public_key', form_result['captcha_public_key']) Session().add(sett4) sett5 = Setting.create_or_update('captcha_private_key', form_result['captcha_private_key']) Session().add(sett5) Session().commit() set_app_settings(config) h.flash(_('Updated application settings'), category='success') except Exception: log.error(traceback.format_exc()) h.flash(_('Error occurred while updating ' 'application settings'), category='error') raise HTTPFound(location=url('admin_settings_global')) defaults = Setting.get_app_settings() defaults.update(self._get_hg_ui_settings()) return htmlfill.render( render('admin/settings/settings.html'), defaults=defaults, encoding="UTF-8", force_defaults=False)
def test_escape_defaults(): rarr = unichr(name2codepoint['rarr']) assert (htmlfill.render('<input type="submit" value="next>→">', {}, {}) == '<input type="submit" value="next>%s">' % rarr) assert (htmlfill.render('<input type="submit" value="1&2">', {}, {}) == '<input type="submit" value="1&2">') assert (htmlfill.render('<input type="submit" value="Japan - 日本 Nihon" />', {}, {}) == u'<input type="submit" value="Japan - 日本 Nihon" />')
def test_html5(): result = htmlfill.render('<input type="number" name="quantity">', {"quantity": "10"}) assert result == '<input type="number" name="quantity" value="10">' try: result = htmlfill.render('<input type="unknown" name="quantity">', {"quantity": "10"}) except AssertionError as e: assert "I don't know about this kind of <input>: unknown at 1:0" in str(e) result = htmlfill.render('<input type="unknown" name="quantity">', {"quantity": "10"}, text_as_default=True) assert result == '<input type="unknown" name="quantity" value="10">'
def settings_visual(self): """GET /admin/settings/visual: All items in the collection""" # url('admin_settings_visual') c.active = 'visual' if request.POST: application_form = ApplicationVisualisationForm()() try: form_result = application_form.to_python(dict(request.POST)) except formencode.Invalid as errors: return htmlfill.render( render('admin/settings/settings.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) try: settings = [ ('show_public_icon', 'show_public_icon', 'bool'), ('show_private_icon', 'show_private_icon', 'bool'), ('stylify_metatags', 'stylify_metatags', 'bool'), ('repository_fields', 'repository_fields', 'bool'), ('dashboard_items', 'dashboard_items', 'int'), ('admin_grid_items', 'admin_grid_items', 'int'), ('show_version', 'show_version', 'bool'), ('use_gravatar', 'use_gravatar', 'bool'), ('gravatar_url', 'gravatar_url', 'unicode'), ('clone_uri_tmpl', 'clone_uri_tmpl', 'unicode'), ] for setting, form_key, type_ in settings: sett = Setting.create_or_update(setting, form_result[form_key], type_) Session().add(sett) Session().commit() set_app_settings(config) h.flash(_('Updated visualisation settings'), category='success') except Exception: log.error(traceback.format_exc()) h.flash(_('Error occurred during updating ' 'visualisation settings'), category='error') raise HTTPFound(location=url('admin_settings_visual')) defaults = Setting.get_app_settings() defaults.update(self._get_hg_ui_settings()) return htmlfill.render( render('admin/settings/settings.html'), defaults=defaults, encoding="UTF-8", force_defaults=False)
def test_trailing_error(): assert (htmlfill.render('<input type="text" name="email">', errors={'email': 'error'}, prefix_error=False) == '<input type="text" name="email" class="error" value=""><!-- for: email -->\n<span class="error-message">error</span><br />\n') assert (htmlfill.render('<textarea name="content"></textarea>', errors={'content': 'error'}, prefix_error=False) == '<textarea name="content" class="error"></textarea><!-- for: content -->\n<span class="error-message">error</span><br />\n') assert (htmlfill.render('<select name="type"><option value="foo">foo</option></select>', errors={'type': 'error'}, prefix_error=False) == '<select name="type" class="error"><option value="foo">foo</option></select><!-- for: type -->\n<span class="error-message">error</span><br />\n')
def test_mix_str_and_unicode(): html = '<input type="text" name="cheese">' uhtml = unicode(html) cheese = dict(cheese='Käse') ucheese = dict(cheese=u'Käse') expected = u'<input type="text" name="cheese" value="Käse">' rendered = htmlfill.render(html, defaults=cheese, encoding='utf-8') assert expected == rendered rendered = htmlfill.render(html, defaults=ucheese, encoding='utf-8') assert expected == rendered rendered = htmlfill.render(uhtml, defaults=cheese, encoding='utf-8') assert expected == rendered rendered = htmlfill.render(uhtml, defaults=ucheese, encoding='utf-8') assert expected == rendered
def test_mix_str_and_unicode(): html = '<input type="text" name="cheese">' uhtml = six.text_type(html) cheese = dict(cheese="Käse") ucheese = dict(cheese="Käse") expected = '<input type="text" name="cheese" value="Käse">' rendered = htmlfill.render(html, defaults=cheese, encoding="utf-8") assert expected == rendered rendered = htmlfill.render(html, defaults=ucheese, encoding="utf-8") assert expected == rendered rendered = htmlfill.render(uhtml, defaults=cheese, encoding="utf-8") assert expected == rendered rendered = htmlfill.render(uhtml, defaults=ucheese, encoding="utf-8") assert expected == rendered
def test_password(): assert (htmlfill.render('<input name="password" type="password" value="">', defaults={'password': '******'}) == '<input name="password" type="password" value="secure passwd">') assert (htmlfill.render('<input name="password" type="password" value="">', defaults={'password': '******'}, skip_passwords=True) == '<input name="password" type="password" value="">') assert (htmlfill.render('<input name="password" type="password">', defaults={'password': '******'}) == '<input name="password" type="password" value="secure passwd">') assert (htmlfill.render('<input name="password" type="password">', defaults={'password': '******'}, skip_passwords=True) == '<input name="password" type="password">')
def register_teacher(self, location): # bounce existing users to different action if c.user is not None: redirect(location.url(action='register_teacher_existing')) if not hasattr(self, 'form_result'): return htmlfill.render(self._register_teacher_form()) email = self.form_result['email'] if User.get(email, location): h.flash(_('The email you entered is registered in Ututi. ' 'Please login to proceed.')) destination = location.url(action='register_teacher_existing') redirect(url(controller='home', action='login', email=email, came_from=destination)) # lookup/create registration entry and send confirmation code to user registration = UserRegistration.create_or_update(location, email) registration.teacher = True meta.Session.commit() registration.send_confirmation_email() # show confirmation page c.email = email return render('registration/email_approval.mako')
def register(self): user_model = UserModel() c.auto_active = False for perm in user_model.get_by_username('default', cache=False).user_perms: if perm.permission.permission_name == 'hg.register.auto_activate': c.auto_active = True break if request.POST: register_form = RegisterForm()() try: form_result = register_form.to_python(dict(request.POST)) form_result['active'] = c.auto_active user_model.create_registration(form_result) h.flash(_('You have successfully registered into rhodecode'), category='success') return redirect(url('login_home')) except formencode.Invalid, errors: return htmlfill.render( render('/register.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8")
def edit(self, id): # We need to recheck auth in here so we can pass in the id if not h.auth.authorized(h.auth.Or(h.auth.is_same_zkpylons_funding_submitter(id), h.auth.has_organiser_role)): # Raise a no_auth error h.auth.no_role() if not h.auth.authorized(h.auth.has_organiser_role): if c.funding_editing == 'closed': return render("funding/editing_closed.mako") elif c.funding_editing == 'not_open': return render("funding/editing_not_open.mako") c.funding = Funding.find_by_id(id) defaults = {} defaults.update(h.object_to_defaults(c.funding, 'funding')) # This is horrible, don't know a better way to do it if c.funding.type: defaults['funding.type'] = defaults['funding.funding_type_id'] if c.funding.male: defaults['funding.male'] = 1 else: defaults['funding.male'] = 0 form = render('/funding/edit.mako') return htmlfill.render(form, defaults)
def edit(self, id, format='html'): """GET /permissions/id/edit: Form to edit an existing item""" #url('edit_permission', id=ID) c.perms_choices = self.perms_choices c.register_choices = self.register_choices c.create_choices = self.create_choices if id == 'default': default_user = UserModel().get_by_username('default') defaults = {'_method': 'put', 'anonymous': default_user.active} for p in default_user.user_perms: if p.permission.permission_name.startswith('repository.'): defaults['default_perm'] = p.permission.permission_name if p.permission.permission_name.startswith('hg.register.'): defaults['default_register'] = p.permission.permission_name if p.permission.permission_name.startswith('hg.create.'): defaults['default_create'] = p.permission.permission_name return htmlfill.render( render('admin/permissions/permissions.html'), defaults=defaults, encoding="UTF-8", force_defaults=True,) else: return redirect(url('admin_home'))
def edit(self, id): c.travel = Travel.find_by_id(id) defaults = h.object_to_defaults(c.travel, "travel") form = render("/travel/edit.mako") return htmlfill.render(form, defaults)
def update(self, id): """PUT /defaults/id: Update an existing item""" # Forms posted to this method should contain a hidden field: # <input type="hidden" name="_method" value="PUT" /> # Or using helpers: # h.form(url('default', id=ID), # method='put') # url('default', id=ID) _form = DefaultsForm()() try: form_result = _form.to_python(dict(request.POST)) for k, v in form_result.iteritems(): setting = RhodeCodeSetting.get_by_name_or_create(k) setting.app_settings_value = v Session().add(setting) Session().commit() h.flash(_('Default settings updated successfully'), category='success') except formencode.Invalid, errors: defaults = errors.value return htmlfill.render( render('admin/defaults/defaults.html'), defaults=defaults, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8")
def edit(self, id): # A person can only volunteer once c.form = "edit" c.volunteer = Volunteer.find_by_id(id) defaults = h.object_to_defaults(c.volunteer, "volunteer") form = render("/volunteer/edit.mako") return htmlfill.render(form, defaults)
def update(self, id): """PUT /permissions/id: Update an existing item""" # Forms posted to this method should contain a hidden field: # <input type="hidden" name="_method" value="PUT" /> # Or using helpers: # h.form(url('permission', id=ID), # method='put') # url('permission', id=ID) permission_model = PermissionModel() _form = DefaultPermissionsForm([x[0] for x in self.perms_choices], [x[0] for x in self.register_choices], [x[0] for x in self.create_choices])() try: form_result = _form.to_python(dict(request.POST)) form_result.update({'perm_user_name': id}) permission_model.update(form_result) h.flash(_('Default permissions updated successfully'), category='success') except formencode.Invalid, errors: c.perms_choices = self.perms_choices c.register_choices = self.register_choices c.create_choices = self.create_choices defaults = errors.value return htmlfill.render( render('admin/permissions/permissions.html'), defaults=defaults, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8")
def edit(self, id): c.location = Location.find_by_id(id) defaults = h.object_to_defaults(c.location, 'location') form = render('/location/edit.mako') return htmlfill.render(form, defaults)
def wall_settings(self): defaults = { 'events': list(set(Event.event_types()) - \ set(c.user.ignored_events_list)) } return htmlfill.render(self._wall_settings_form(), defaults=defaults)
def create(self): users_group_form = UserGroupForm()() try: form_result = users_group_form.to_python(dict(request.POST)) ug = UserGroupModel().create(name=form_result['users_group_name'], description=form_result['user_group_description'], owner=request.authuser.user_id, active=form_result['users_group_active']) gr = form_result['users_group_name'] action_logger(request.authuser, 'admin_created_users_group:%s' % gr, None, request.ip_addr) h.flash(h.literal(_('Created user group %s') % h.link_to(h.escape(gr), url('edit_users_group', id=ug.users_group_id))), category='success') Session().commit() except formencode.Invalid as errors: return htmlfill.render( render('admin/user_groups/user_group_add.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) except Exception: log.error(traceback.format_exc()) h.flash(_('Error occurred during creation of user group %s') \ % request.POST.get('users_group_name'), category='error') raise HTTPFound(location=url('users_groups'))
def edit(self, id): # A person can only volunteer once c.form = 'edit' c.volunteer = Volunteer.find_by_id(id) defaults = h.object_to_defaults(c.volunteer, 'volunteer') form = render('/volunteer/edit.mako') return htmlfill.render(form, defaults)
def home_page(context, request): tpl = 'finlin:templates/home_page.pt' tpl_vars = { 'save_url': request.path_url} if 'form.submitted' in request.params: schema = HomepageForm() try: params = schema.to_python(request.params, request) except formencode.Invalid, e: html = htmlfill.render( render(tpl, tpl_vars, request), defaults=e.value, errors=e.error_dict) return Response(html) else: import smtplib from_me = '*****@*****.**' to = '*****@*****.**' header = 'To:' + to + '\n' + 'From: ' + from_me + '\n' + 'Subject:Homepage email \n' msg = header + '\n email: ' + params['email'] + '\n\n' smtpObj = smtplib.SMTP('localhost') smtpObj.sendmail(from_me, to, msg) request.session.flash('Thank you!') return HTTPFound(location = resource_url( context, request))
def edit(self, id=None): user = h.checkuser(id) h.requirerights(user_is=id) qdivs = meta.Session.query(model.Division).filter_by(deleted=False) divisions = qdivs.all() c.divisions = [[None, u"-- нет --"]] for i in divisions: c.divisions.append([i.id, i.title]) values = { 'login': user.login, 'name': user.name, 'surname': user.surname, 'patronymic': user.patronymic, 'email': user.email, 'phone': user.phone, 'creator': user.creator, 'performer': user.performer, 'appointer': user.appointer, 'responsible': user.responsible, 'chief': user.chief, 'admin': user.admin, 'operator': user.operator, 'div_id': user.div_id } c.curdiv = [user.div_id] return htmlfill.render(render("/users/edit.html"), values)
def my_account_update(self): """PUT /_admin/my_account_update: Update an existing item""" # Forms posted to this method should contain a hidden field: # <input type="hidden" name="_method" value="PUT" /> # Or using helpers: # h.form(url('admin_settings_my_account_update'), # method='put') # url('admin_settings_my_account_update', id=ID) user_model = UserModel() uid = self.rhodecode_user.user_id _form = UserForm(edit=True, old_data={'user_id': uid, 'email': self.rhodecode_user.email})() form_result = {} try: form_result = _form.to_python(dict(request.POST)) user_model.update_my_account(uid, form_result) h.flash(_('Your account was updated successfully'), category='success') Session.commit() except formencode.Invalid, errors: c.user = User.get(self.rhodecode_user.user_id) all_repos = self.sa.query(Repository)\ .filter(Repository.user_id == c.user.user_id)\ .order_by(func.lower(Repository.repo_name))\ .all() c.user_repos = ScmModel().get_repos(all_repos) return htmlfill.render( render('admin/users/user_edit_my_account.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8")
def login(self): # Here below email get parameter may be used for convenience # i.e. when redirecting from sign-up form. # POST and GET params are accepted for external javascript logins # to work via JSONP (see _js_login above). username = request.params.get('username') or request.params.get('email') password = request.params.get('password') location = request.params.get('location') location = int(location) if location else None remember = bool(request.params.get('remember')) if 'js' in request.params: return self._js_login(username, password, location, remember) errors = None if username and password: # form was posted errors = self._try_sign_in(username, password, location, remember) if errors is None: redirect(c.came_from or url(controller='profile', action='home')) # show the form, possibly with errors. return htmlfill.render(render('login.mako'), errors=errors, error_formatters=u_error_formatters, defaults={'username': username, 'location': location, 'came_from': c.came_from})
def register(self): name = request.POST.get('name') email = request.POST.get('email') location_id = request.POST.get('location_id') accept_terms = request.POST.get('accept_terms') person = request.POST.get('person') c.universities = self._universities(limit=12) c.all_universities = self._universities() # checks if email, name, person are not empty if not email or not name or not person or accept_terms != '1': redirect(url('frontpage')) # redirect to login if user is already registered if User.get_all(email): redirect(url(controller='home', action='login', email=email)) # otherwise we validate the form properly try: self.form_result = RegistrationForm().to_python(request.POST) except validators.Invalid, e: return htmlfill.render(self._sign_up_form(), defaults=request.POST, errors=e.error_dict, error_formatters=u_error_formatters)
def submit(self): c.post = h.post.get(int(request.params.get('post_id'))) c.posts = None if h.forms.validate(h.forms.CommentForm()): # save comment comment = h.comment.new() for k, v in c.form_result.items(): setattr(comment, k, v) # some checks and defaults if len(comment.author) == 0: comment.author = 'anonymous' comment.posted = h.timehelpers.now() comment.body = h.html_escape(comment.body) comment.body = comment.body.replace('\n','<br>') comment.body = comment.body.replace('\t',' ') comment.body = comment.body.replace(' ',' ') # save to db h.comment.save(comment) # flash message session['flash'] = 'Comment successfully saved.' session.save() # notify author h.mailer.send_mail('*****@*****.**', h.auth.get_user_mail(c.post.author), 'New comment for: '+c.post.subject, render('/messages/mail_new_comment.mako', extra_vars={'user':h.auth.get_user_name(id=c.post.author), 'post_subject':c.post.subject, 'site_name':h.config.get('site_title'), 'post_url':h.config.get('site_url')+url(controller='blog', action='view', id=c.post.id, subject=h.urlify(c.post.subject))})) # redirect to post redirect(url(controller='blog', action='view', id=request.params.get('post_id'), subject=h.urlify(c.post.subject)), code=303) else: session['flash'] = 'Erros in the submitted form, please correct and try again.' session.save() html = render('/blog/view.mako', extra_vars={'page_id':1, 'post_count':1}) return htmlfill.render(html,defaults=c.form_result,errors=c.form_errors)
def new(self): if c.cfp_status == 'closed': if not h.auth.authorized(h.auth.Or(h.auth.has_organiser_role, h.auth.has_late_submitter_role)): return render("proposal/closed.mako") elif c.cfp_status == 'not_open': return render("proposal/not_open.mako") c.person = h.signed_in_person() h.check_for_incomplete_profile(c.person) defaults = { 'proposal.type': 1, 'proposal.video_release': 1, 'proposal.slides_release': 1, 'proposal.travel_assistance' : 1, 'proposal.accommodation_assistance' : 1, 'person.name': c.person.firstname + " " + c.person.lastname, 'person.mobile': c.person.mobile, 'person.experience': c.person.experience, 'person.bio': c.person.bio, 'person.url': c.person.url, } defaults['person_to_edit'] = c.person.id defaults['name'] = c.person.firstname + " " + c.person.lastname form = render("proposal/new.mako") return htmlfill.render(form, defaults)
def my_account(self): """ GET /_admin/my_account Displays info about my account """ # url('admin_settings_my_account') c.user = User.get(self.rhodecode_user.user_id) all_repos = self.sa.query(Repository)\ .filter(Repository.user_id == c.user.user_id)\ .order_by(func.lower(Repository.repo_name)).all() c.user_repos = ScmModel().get_repos(all_repos) if c.user.username == 'default': h.flash(_("You can't edit this user since it's" " crucial for entire application"), category='warning') return redirect(url('users')) defaults = c.user.get_dict() return htmlfill.render( render('admin/users/user_edit_my_account.html'), defaults=defaults, encoding="UTF-8", force_defaults=False )
def new(self): # Do we allow account creation? if lca_info['account_creation']: """Create a new person form. """ if h.signed_in_person(): h.flash("You're already logged in") redirect_to('home') defaults = { 'person.country': 'AUSTRALIA', } if h.lca_rego['personal_info']['home_address'] == 'no': defaults['person.address1'] = 'not available' defaults['person.city'] = 'not available' defaults['person.postcode'] = 'not available' c.social_networks = SocialNetwork.find_all() form = render('/person/new.mako') return htmlfill.render(form, defaults) else: return render('/not_allowed.mako')
def new(self): if len(c.db_content_types) is 0: h.flash( "Configuration Error: Please make sure at least one content type exists.", 'error') if DbContentType.find_by_name("News", abort_404=False) is None: h.flash( "Configuration Error: Please make sure the 'News' content type exists for full functionality.", 'error') if DbContentType.find_by_name("In the press", abort_404=False) is None: h.flash( "Configuration Error: Please make sure the 'In the press' content type exists for full functionality.", 'error') c.db_content = DbContent() defaults = h.object_to_defaults(c.db_content, 'db_content') if request.GET.has_key('url'): defaults['db_content.type'] = find_by_name('Page', abort_404=False) if request.GET['url'].startswith('/'): defaults['db_content.url'] = str(request.GET['url'])[1:] else: defaults['db_content.url'] = request.GET['url'] form = render('/db_content/new.mako') return htmlfill.render(form, defaults)
def edit(self, id): # We need to recheck auth in here so we can pass in the id if not h.auth.authorized(h.auth.Or(h.auth.is_same_zkpylons_submitter(id), h.auth.has_organiser_role)): # Raise a no_auth error h.auth.no_role() if not h.auth.authorized(h.auth.has_organiser_role): if c.proposal_editing == 'closed' and not h.auth.authorized(h.auth.has_late_submitter_role): return render("proposal/editing_closed.mako") elif c.proposal_editing == 'not_open': return render("proposal/editing_not_open.mako") c.proposal = Proposal.find_by_id(id) c.person = c.proposal.people[0] for person in c.proposal.people: if h.signed_in_person() == person: c.person = person defaults = h.object_to_defaults(c.proposal, 'proposal') defaults.update(h.object_to_defaults(c.person, 'person')) defaults['person.name'] = c.person.firstname + " " + c.person.lastname # This is horrible, don't know a better way to do it if c.proposal.type: defaults['proposal.type'] = defaults['proposal.proposal_type_id'] if c.proposal.travel_assistance: defaults['proposal.travel_assistance'] = defaults['proposal.travel_assistance_type_id'] if c.proposal.accommodation_assistance: defaults['proposal.accommodation_assistance'] = defaults['proposal.accommodation_assistance_type_id'] if c.proposal.audience: defaults['proposal.audience'] = defaults['proposal.target_audience_id'] defaults['person_to_edit'] = c.person.id defaults['name'] = c.person.firstname + " " + c.person.lastname c.miniconf = (c.proposal.type.name == 'Miniconf') form = render('/proposal/edit.mako') return htmlfill.render(form, defaults)
def update(self, id): user_model = UserModel() user = user_model.get(id) _form = UserForm(edit=True, old_data={'user_id': id, 'email': user.email})() form_result = {} try: form_result = _form.to_python(dict(request.POST)) skip_attrs = ['extern_type', 'extern_name', ] + auth_modules.get_managed_fields(user) user_model.update(id, form_result, skip_attrs=skip_attrs) usr = form_result['username'] action_logger(request.authuser, 'admin_updated_user:%s' % usr, None, request.ip_addr) h.flash(_('User updated successfully'), category='success') Session().commit() except formencode.Invalid as errors: defaults = errors.value e = errors.error_dict or {} defaults.update({ 'create_repo_perm': user_model.has_perm(id, 'hg.create.repository'), 'fork_repo_perm': user_model.has_perm(id, 'hg.fork.repository'), }) return htmlfill.render( self._render_edit_profile(user), defaults=defaults, errors=e, prefix_error=False, encoding="UTF-8", force_defaults=False) except Exception: log.error(traceback.format_exc()) h.flash(_('Error occurred during update of user %s') \ % form_result.get('username'), category='error') raise HTTPFound(location=url('edit_user', id=id))
def save(self): """Update OLD ElicitationMethod with newly altered data.""" # Check whether the user is updating a method to have a # name that is the same as another method and redisplay # the form with an error message if so. This should be # done by the Schema, but I couldn't figure out how. otherMethodsWithSameName = meta.Session.query( model.ElicitationMethod ).filter(model.ElicitationMethod.id != self.form_result['ID']).filter( model.ElicitationMethod.name == self.form_result['name']).all() if otherMethodsWithSameName: c.elicitationMethod = meta.Session.query( model.ElicitationMethod).get(int(self.form_result['ID'])) html = render('/derived/tag/method/edit.html') errors = {'name': 'Sorry, that name is already taken'} values = { 'ID': self.form_result['ID'], 'name': self.form_result['name'], 'description': self.form_result['description'] } return htmlfill.render(html, defaults=values, errors=errors) elicitationMethod_q = meta.Session.query(model.ElicitationMethod) elicitationMethod = elicitationMethod_q.get(int( self.form_result['ID'])) elicitationMethod.name = h.NFD(self.form_result['name']) elicitationMethod.description = h.NFD(self.form_result['description']) # Update the data meta.Session.commit() # Update the syncats variable in app_globals tags = h.getSecondaryObjects(['elicitationMethods']) app_globals.elicitationMethods = tags['elicitationMethods'] # Issue an HTTP redirect response.status_int = 302 response.headers['location'] = url(controller='method', action='view', id=elicitationMethod.id) return "Moved temporarily"
def settings_email(self): c.active = 'email' if request.POST: test_email = request.POST.get('test_email') test_email_subj = 'Kallithea test email' test_body = ('Kallithea Email test, ' 'Kallithea version: %s' % c.kallithea_version) if not test_email: h.flash(_('Please enter email address'), category='error') raise HTTPFound(location=url('admin_settings_email')) test_email_txt_body = EmailNotificationModel() \ .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT, 'txt', body=test_body) test_email_html_body = EmailNotificationModel() \ .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT, 'html', body=test_body) recipients = [test_email] if test_email else None tasks.send_email(recipients, test_email_subj, test_email_txt_body, test_email_html_body) h.flash(_('Send email task created'), category='success') raise HTTPFound(location=url('admin_settings_email')) defaults = Setting.get_app_settings() defaults.update(self._get_hg_ui_settings()) import kallithea c.ini = kallithea.CONFIG return htmlfill.render( render('admin/settings/settings.html'), defaults=defaults, encoding="UTF-8", force_defaults=False)
def password_reset(self): settings = Setting.get_app_settings() captcha_private_key = settings.get('captcha_private_key') c.captcha_active = bool(captcha_private_key) c.captcha_public_key = settings.get('captcha_public_key') if request.POST: password_reset_form = PasswordResetRequestForm()() try: form_result = password_reset_form.to_python(dict(request.POST)) if c.captcha_active: from kallithea.lib.recaptcha import submit response = submit(request.POST.get('recaptcha_challenge_field'), request.POST.get('recaptcha_response_field'), private_key=captcha_private_key, remoteip=request.ip_addr) if c.captcha_active and not response.is_valid: _value = form_result _msg = _('Bad captcha') error_dict = {'recaptcha_field': _msg} raise formencode.Invalid(_msg, _value, None, error_dict=error_dict) redirect_link = UserModel().send_reset_password_email(form_result) h.flash(_('A password reset confirmation code has been sent'), category='success') raise HTTPFound(location=redirect_link) except formencode.Invalid as errors: return htmlfill.render( render('/password_reset.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) return render('/password_reset.html')
def fork_create(self, repo_name): self.__load_defaults() c.repo_info = Repository.get_by_repo_name(repo_name) _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type}, repo_groups=c.repo_groups_choices, landing_revs=c.landing_revs_choices)() form_result = {} task_id = None try: form_result = _form.to_python(dict(request.POST)) # create fork is done sometimes async on celery, db transaction # management is handled there. task = RepoModel().create_fork( form_result, c.rhodecode_user.user_id) from celery.result import BaseAsyncResult if isinstance(task, BaseAsyncResult): task_id = task.task_id except formencode.Invalid as errors: c.new_repo = errors.value['repo_name'] return htmlfill.render( render('forks/fork.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) except Exception: log.exception( u'Exception while trying to fork the repository %s', repo_name) msg = ( _('An error occurred during repository forking %s') % (repo_name, )) h.flash(msg, category='error') return redirect(h.url('repo_creating_home', repo_name=form_result['repo_name_full'], task_id=task_id))
def create(self): """POST /users_groups: Create a new item""" # url('users_groups') users_group_form = UserGroupForm()() try: form_result = users_group_form.to_python(dict(request.POST)) UserGroupModel().create(name=form_result['users_group_name'], owner=self.rhodecode_user.user_id, active=form_result['users_group_active']) gr = form_result['users_group_name'] action_logger(self.rhodecode_user, 'admin_created_users_group:%s' % gr, None, self.ip_addr, self.sa) h.flash(_('Created user group %s') % gr, category='success') Session().commit() except formencode.Invalid, errors: return htmlfill.render( render('admin/users_groups/users_group_add.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8")
def edit_advanced(self, repo_name): c.repo_info = self._load_repo() c.default_user_id = User.get_default_user().user_id c.in_public_journal = UserFollowing.query() \ .filter(UserFollowing.user_id == c.default_user_id) \ .filter(UserFollowing.follows_repository == c.repo_info).scalar() _repos = Repository.query(sorted=True).all() read_access_repos = RepoList(_repos, perm_level='read') c.repos_list = [(None, _('-- Not a fork --'))] c.repos_list += [(x.repo_id, x.repo_name) for x in read_access_repos if x.repo_id != c.repo_info.repo_id] defaults = { 'id_fork_of': c.repo_info.fork_id if c.repo_info.fork_id else '' } c.active = 'advanced' if request.POST: raise HTTPFound(location=url('repo_edit_advanced')) return htmlfill.render(render('admin/repos/repo_edit.html'), defaults=defaults, encoding="UTF-8", force_defaults=False)
def edit(self, id): # We need to recheck auth in here so we can pass in the id if not h.auth.authorized( h.auth.Or(h.auth.is_same_zkpylons_funding_submitter(id), h.auth.has_organiser_role)): # Raise a no_auth error h.auth.no_role() if not h.auth.authorized(h.auth.has_organiser_role): if c.funding_editing == 'closed': return render("funding/editing_closed.mako") elif c.funding_editing == 'not_open': return render("funding/editing_not_open.mako") c.funding = Funding.find_by_id(id) defaults = {} defaults.update(h.object_to_defaults(c.funding, 'funding')) # This is horrible, don't know a better way to do it if c.funding.type: defaults['funding.type'] = defaults['funding.funding_type_id'] form = render('/funding/edit.mako') return htmlfill.render(form, defaults)
def permission_global_update(self): c.active = 'global' self.__load_data() _form = UserPermissionsForm( [x[0] for x in c.repo_create_choices], [x[0] for x in c.repo_create_on_write_choices], [x[0] for x in c.repo_group_create_choices], [x[0] for x in c.user_group_create_choices], [x[0] for x in c.fork_choices], [x[0] for x in c.inherit_default_permission_choices])() try: form_result = _form.to_python(dict(request.POST)) form_result.update({'perm_user_name': User.DEFAULT_USER}) PermissionModel().update_user_permissions(form_result) Session().commit() h.flash(_('Global permissions updated successfully'), category='success') except formencode.Invalid as errors: defaults = errors.value return htmlfill.render( render('admin/permissions/permissions.html'), defaults=defaults, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) except Exception: log.exception("Exception during update of permissions") h.flash(_('Error occurred during update of permissions'), category='error') return redirect(url('admin_permissions_global'))
def edit(self, group_name, format='html'): """GET /repos_groups/group_name/edit: Form to edit an existing item""" # url('edit_repos_group', group_name=GROUP_NAME) c.repos_group = ReposGroupModel()._get_repo_group(group_name) #we can only allow moving empty group if it's already a top-level #group, ie has no parents, or we're admin if HasPermissionAll('hg.admin')('group edit'): #we're global admin, we're ok and we can create TOP level groups allow_empty_group = True elif not c.repos_group.parent_group: allow_empty_group = True else: allow_empty_group = False self.__load_defaults(allow_empty_group=allow_empty_group, exclude_group_ids=[c.repos_group.group_id]) defaults = self.__load_data(c.repos_group.group_id) return htmlfill.render( render('admin/repos_groups/repos_groups_edit.html'), defaults=defaults, encoding="UTF-8", force_defaults=False)
def permission_application(self): c.active = 'application' self.__load_data() c.user = User.get_default_user() # TODO: johbo: The default user might be based on outdated state which # has been loaded from the cache. A call to refresh() ensures that the # latest state from the database is used. Session().refresh(c.user) app_settings = SettingsModel().get_all_settings() defaults = { 'anonymous': c.user.active, 'default_register_message': app_settings.get('rhodecode_register_message') } defaults.update(c.user.get_default_perms()) return htmlfill.render(render('admin/permissions/permissions.html'), defaults=defaults, encoding="UTF-8", force_defaults=False)
def my_account_update(self): """PUT /_admin/my_account_update: Update an existing item""" # Forms posted to this method should contain a hidden field: # <input type="hidden" name="_method" value="PUT" /> # Or using helpers: # h.form(url('admin_settings_my_account_update'), # method='put') # url('admin_settings_my_account_update', id=ID) user_model = UserModel() uid = self.rhodecode_user.user_id _form = UserForm(edit=True, old_data={ 'user_id': uid, 'email': self.rhodecode_user.email })() form_result = {} try: form_result = _form.to_python(dict(request.POST)) user_model.update_my_account(uid, form_result) h.flash(_('Your account was updated successfully'), category='success') Session.commit() except formencode.Invalid, errors: c.user = User.get(self.rhodecode_user.user_id) all_repos = self.sa.query(Repository)\ .filter(Repository.user_id == c.user.user_id)\ .order_by(func.lower(Repository.repo_name))\ .all() c.user_repos = ScmModel().get_repos(all_repos) return htmlfill.render( render('admin/users/user_edit_my_account.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8")
def review(self, id): c.streams = Stream.select_values() c.proposal = Proposal.find_by_id(id) c.signed_in_person = h.signed_in_person() c.next_review_id = Proposal.find_next_proposal(c.proposal.id, c.proposal.type.id, c.signed_in_person.id) c.review = Review.find_by_proposal_reviewer(id, c.signed_in_person.id, abort_404=False) if c.review: c.form = 'edit' defaults = h.object_to_defaults(c.review, 'review') if c.review.score == None: defaults['review.score'] = '' if c.review.stream_id: defaults['review.stream'] = c.review.stream_id form = render('/review/edit.mako') return htmlfill.render(form, defaults) else: c.form = 'new' return render('/review/new.mako')
def fork_create(self, repo_name): self.__load_defaults() c.repo_info = Repository.get_by_repo_name(repo_name) _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type}, repo_groups=c.repo_groups, landing_revs=c.landing_revs_choices)() form_result = {} task_id = None try: form_result = _form.to_python(dict(request.POST)) # an approximation that is better than nothing if not Ui.get_by_key('hooks', Ui.HOOK_UPDATE).ui_active: form_result['update_after_clone'] = False # create fork is done sometimes async on celery, db transaction # management is handled there. task = RepoModel().create_fork(form_result, request.authuser.user_id) task_id = task.task_id except formencode.Invalid as errors: return htmlfill.render(render('forks/fork.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) except Exception: log.error(traceback.format_exc()) h.flash(_('An error occurred during repository forking %s') % repo_name, category='error') raise HTTPFound(location=h.url('repo_creating_home', repo_name=form_result['repo_name_full'], task_id=task_id))
def create(self): """POST /users: Create a new item""" # url('users') c.default_extern_type = auth_modules.auth_internal.KallitheaAuthPlugin.name user_model = UserModel() user_form = UserForm()() try: form_result = user_form.to_python(dict(request.POST)) user = user_model.create(form_result) usr = form_result['username'] action_logger(self.authuser, 'admin_created_user:%s' % usr, None, self.ip_addr, self.sa) h.flash(h.literal( _('Created user %s') % h.link_to(h.escape(usr), url('edit_user', id=user.user_id))), category='success') Session().commit() except formencode.Invalid, errors: return htmlfill.render(render('admin/users/user_add.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False)
def settings_contents(self, id): instance = self._get_current_instance(id) require.instance.edit(instance) c.page_instance = instance return htmlfill.render( self._settings_contents_form(id), defaults={ '_method': 'PUT', 'allow_propose': instance.allow_propose, 'allow_propose_changes': instance.allow_propose_changes, 'milestones': instance.milestones, 'use_norms': instance.use_norms, 'allow_thumbnailbadges': instance.allow_thumbnailbadges, 'require_selection': instance.require_selection, 'hide_global_categories': instance.hide_global_categories, 'editable_comments_default': instance.editable_comments_default, 'editable_proposals_default': instance.editable_proposals_default, 'show_norms_navigation': instance.show_norms_navigation, 'show_proposals_navigation': instance.show_proposals_navigation, 'frozen': instance.frozen, '_tok': csrf.token_id()})
def my_account(self): """ GET /_admin/my_account Displays info about my account """ # url('admin_settings_my_account') c.user = User.get(self.rhodecode_user.user_id) all_repos = self.sa.query(Repository)\ .filter(Repository.user_id == c.user.user_id)\ .order_by(func.lower(Repository.repo_name)).all() c.user_repos = ScmModel().get_repos(all_repos) if c.user.username == 'default': h.flash(_("You can't edit this user since it's" " crucial for entire application"), category='warning') return redirect(url('users')) defaults = c.user.get_dict() return htmlfill.render(render('admin/users/user_edit_my_account.html'), defaults=defaults, encoding="UTF-8", force_defaults=False)
def create(self): """POST /repos_groups: Create a new item""" # url('repos_groups') self.__load_defaults() repos_group_form = ReposGroupForm( available_groups=c.repo_groups_choices)() try: form_result = repos_group_form.to_python(dict(request.POST)) ReposGroupModel().create( group_name=form_result['group_name'], group_description=form_result['group_description'], parent=form_result['group_parent_id']) Session.commit() h.flash(_('created repos group %s') \ % form_result['group_name'], category='success') #TODO: in futureaction_logger(, '', '', '', self.sa) except formencode.Invalid, errors: return htmlfill.render( render('admin/repos_groups/repos_groups_add.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8")
def create(self): self.__load_defaults() # permissions for can create group based on parent_id are checked # here in the Form repo_group_form = RepoGroupForm(repo_groups=c.repo_groups) try: form_result = repo_group_form.to_python(dict(request.POST)) gr = RepoGroupModel().create( group_name=form_result['group_name'], group_description=form_result['group_description'], parent=form_result['parent_group_id'], owner=request.authuser.user_id, # TODO: make editable copy_permissions=form_result['group_copy_permissions']) Session().commit() #TODO: in future action_logger(, '', '', '') except formencode.Invalid as errors: return htmlfill.render( render('admin/repo_groups/repo_group_add.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) except Exception: log.error(traceback.format_exc()) h.flash(_('Error occurred during creation of repository group %s') \ % request.POST.get('group_name'), category='error') parent_group_id = form_result['parent_group_id'] #TODO: maybe we should get back to the main view, not the admin one raise HTTPFound( location=url('repos_groups', parent_group=parent_group_id)) h.flash(_('Created repository group %s') % gr.group_name, category='success') raise HTTPFound( location=url('repos_group_home', group_name=gr.group_name))
def test_checkbox(): assert (htmlfill.render('<input name="checkbox" type="checkbox" value="bar">', defaults={'checkbox': 'bar'}) == '<input name="checkbox" type="checkbox" value="bar" checked="checked">') assert (htmlfill.render('<input name="checkbox" type="checkbox">', defaults={'checkbox': ''}) == '<input name="checkbox" type="checkbox">') assert (htmlfill.render('<input name="checkbox" type="checkbox">', defaults={'checkbox': ''}, checkbox_checked_if_present=True) == '<input name="checkbox" type="checkbox" checked="checked">') assert (htmlfill.render('<input name="checkbox" type="checkbox" value="bar">', defaults={'checkbox': ''}, checkbox_checked_if_present=True) == '<input name="checkbox" type="checkbox" value="bar">') assert (htmlfill.render('<input name="checkbox" type="checkbox" value="">', defaults={'checkbox': ''}, checkbox_checked_if_present=True) == '<input name="checkbox" type="checkbox" value="" checked="checked">') assert (htmlfill.render('<input name="checkbox" type="checkbox" value="">', defaults={'checkbox': ''}) == '<input name="checkbox" type="checkbox" value="">')
class BlogController(BaseController): def latest(self): c.posts_count = h.post.get_many(amount=10, active_only=True, count_only=True) c.posts = h.post.get_many(amount=10, active_only=True, order='desc') c.post = None if c.posts is None: abort(404) page_id = int(h.page.get_page_id_with_type('blog')) return render('/blog/view.mako', extra_vars={ 'page_id': page_id, 'post_count': c.posts_count, 'page': 'latest', 'show_comment_form': 'false' }) def view(self, id): c.post = h.post.get(int(id)) c.posts = None if c.post is None: abort(404) page_id = int(h.page.get_page_id_with_type('blog')) return render('/blog/view.mako', extra_vars={ 'page_id': page_id, 'post_count': 1, 'page': 'view', 'show_comment_form': 'false' }) def archives(self): try: if request.params.get('filter'): if h.forms.validate(h.forms.FilterForm()): posts = h.post.get_many( filter=request.params.get('filter'), amount=100, active_only=True, order='desc') else: raise Exception else: raise Exception except Exception, error: posts = h.post.get_many(active_only=True, order='desc', amount=100) if posts is None: abort(404) c.paginator = paginate.Page( posts, page=int(request.params.get('page', 1)), items_per_page=20, ) page_id = int(h.page.get_page_id_with_type('archives')) if request.params.get('filter'): html = render('/blog/archives.mako', extra_vars={'page_id': page_id}) return htmlfill.render(html, defaults=c.form_result, errors=c.form_errors) else: return render('/blog/archives.mako', extra_vars={'page_id': page_id})
def permission_globals(self): c.active = 'globals' self.__load_data() if request.POST: _form = DefaultPermissionsForm( [x[0] for x in c.repo_perms_choices], [x[0] for x in c.group_perms_choices], [x[0] for x in c.user_group_perms_choices], [x[0] for x in c.repo_create_choices], [x[0] for x in c.repo_create_on_write_choices], [x[0] for x in c.repo_group_create_choices], [x[0] for x in c.user_group_create_choices], [x[0] for x in c.fork_choices], [x[0] for x in c.register_choices], [x[0] for x in c.extern_activate_choices])() try: form_result = _form.to_python(dict(request.POST)) form_result.update({'perm_user_name': 'default'}) PermissionModel().update(form_result) Session().commit() h.flash(_('Global permissions updated successfully'), category='success') except formencode.Invalid as errors: defaults = errors.value return htmlfill.render( render('admin/permissions/permissions.html'), defaults=defaults, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) except Exception: log.error(traceback.format_exc()) h.flash(_('Error occurred during update of permissions'), category='error') raise HTTPFound(location=url('admin_permissions')) c.user = User.get_default_user() defaults = {'anonymous': c.user.active} for p in c.user.user_perms: if p.permission.permission_name.startswith('repository.'): defaults['default_repo_perm'] = p.permission.permission_name if p.permission.permission_name.startswith('group.'): defaults['default_group_perm'] = p.permission.permission_name if p.permission.permission_name.startswith('usergroup.'): defaults[ 'default_user_group_perm'] = p.permission.permission_name if p.permission.permission_name.startswith( 'hg.create.write_on_repogroup.'): defaults['create_on_write'] = p.permission.permission_name elif p.permission.permission_name.startswith('hg.create.'): defaults['default_repo_create'] = p.permission.permission_name if p.permission.permission_name.startswith('hg.repogroup.'): defaults[ 'default_repo_group_create'] = p.permission.permission_name if p.permission.permission_name.startswith('hg.usergroup.'): defaults[ 'default_user_group_create'] = p.permission.permission_name if p.permission.permission_name.startswith('hg.register.'): defaults['default_register'] = p.permission.permission_name if p.permission.permission_name.startswith('hg.extern_activate.'): defaults[ 'default_extern_activate'] = p.permission.permission_name if p.permission.permission_name.startswith('hg.fork.'): defaults['default_fork'] = p.permission.permission_name return htmlfill.render(render('admin/permissions/permissions.html'), defaults=defaults, encoding="UTF-8", force_defaults=False)
if form_result[field_name] != getattr(objective, field_name): setattr(objective, field_name, form_result[field_name]) changed = True # Add onjective if this is the add form if add_form: objective.project = project session.add(objective) return HTTPFound(location=model_url(context, request)) elif 'form.cancel' in request.POST: return HTTPFound(location=model_url(context, request)) else: if not add_form: for field_name in objective_schema.fields.keys(): value = getattr(objective, field_name) if field_name == 'competences': values = [] for competence in value: values.append(competence.id) value = values defaults[field_name] = value form = render_template('templates/objective_edit.pt', objective=objective, competences=competences, add_form=add_form, api=TemplateAPI(request)) # FormEncode fills template with default values form = htmlfill.render(form, defaults=defaults, errors=errors) return Response(form)
# If there's no form supplied, just continue with the current # function call. if not form: return func(self, *args, **kwargs) request.environ['pylons.routes_dict']['action'] = form response = self._dispatch_call() # If the form_content is an exception response, return it if hasattr(response, '_exception'): return response htmlfill_kwargs2 = htmlfill_kwargs.copy() htmlfill_kwargs2.setdefault('encoding', request.charset) return htmlfill.render(response, defaults=params, errors=errors, **htmlfill_kwargs2) return func(self, *args, **kwargs) return decorator(wrapper) def pylons_formencode_gettext(value): """Translates a string ``value`` using pylons gettext first and if that fails, formencode gettext. This allows to "merge" localized error messages from built-in FormEncode's validators with application-specific validators. """ trans = pylons_gettext(value)
def new(self, id, format='html', errors={}): c.page_user = get_entity_or_abort(model.User, id) require.user.message(c.page_user) html = render("/message/new.html") return htmlfill.render(html, defaults=request.params, errors=errors, force_defaults=False)
response.errors) # FormEncode>=0.7 errors are unicode (due to being localized # via ugettext). Convert any of the possible formencode # unpack_errors formats to contain raw strings errors = encode_formencode_errors(errors, encoding, response.errors) elif not isinstance(form_content, unicode): log.debug( "Unicode form params: ensuring the '%s' form is " "converted to unicode for htmlfill", form) encoding = determine_response_charset(response) form_content = form_content.decode(encoding) form_content = htmlfill.render(form_content, defaults=params, errors=errors, **htmlfill_kwargs) if legacy_response: # Let the Controller merge the legacy response response.content = form_content return response else: return form_content return func(self, *args, **kwargs) return decorator(wrapper) def determine_response_charset(response): """Determine the charset of the specified Response object, returning the default system encoding when none is set"""
def new(self): defaults = { 'voucher.count': '1', } form = render("/voucher/new.mako") return htmlfill.render(form, defaults)