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)
