class UserFormSchema(validators.Schema):
user_id = validators.Int()
user_name = validators.UnicodeString(not_empty=True, strip=True)
display_name = validators.UnicodeString(not_empty=True, strip=True)
disabled = validators.StringBool(if_empty=False)
email_address = validators.Email(not_empty=True, strip=True)
chained_validators = [beaker_validators.UniqueUserName('user_id',
'user_name')]
def validate_email_address(self, key, value):
if not value:
raise ValueError('Email address must not be empty')
email_validator = validators.Email(not_empty=True)
try:
value = email_validator.to_python(value)
except Invalid as e:
raise ValueError('Invalid email address: %s' % e)
return value
class Preferences(RPCRoot):
exposed = True
# XMLRPC interface
@expose()
@identity.require(identity.not_anonymous())
def remove_submission_delegate_by_name(self,
delegate_name,
service=u'XMLRPC'):
user = identity.current.user
try:
submission_delegate = User.by_user_name(delegate_name)
except NoResultFound:
raise BX(_(u'%s is not a valid user name' % delegate_name))
try:
user.remove_submission_delegate(submission_delegate,
service=service)
except ValueError:
raise BX(_(u'%s is not a submission delegate of %s' % \
(delegate_name, user)))
return delegate_name
# XMLRPC Interface
@expose()
@identity.require(identity.not_anonymous())
def add_submission_delegate_by_name(self,
new_delegate_name,
service=u'XMLRPC'):
user = identity.current.user
new_delegate = User.by_user_name(new_delegate_name)
if not new_delegate:
raise BX(_(u'%s is not a valid user' % new_delegate_name))
user.add_submission_delegate(new_delegate, service)
return new_delegate_name
#XMLRPC method for updating user preferences
@cherrypy.expose
@identity.require(identity.not_anonymous())
@validate(validators=dict(email_address=validators.Email()))
def update(self, email_address=None, tg_errors=None):
"""
Update user preferences
:param email_address: email address
:type email_address: string
"""
if tg_errors:
raise BeakerException(', '.join(
str(item) for item in tg_errors.values()))
if email_address:
if email_address == identity.current.user.email_address:
raise BeakerException(
"Email address not changed: new address is same as before")
else:
identity.current.user.email_address = email_address
class CommentCaptchaForm(Form):
template = "bodhi.templates.captchacommentform"
submit_text = "Add Comment"
fields = [
TextArea(name='text', label='',
validator=validators.All(
validators.NotEmpty(),
validators.UnicodeString()),
rows=3, cols=40),
HiddenField(name='title',
validator=validators.All(
validators.NotEmpty(),
validators.UnicodeString())),
TextField(name='author', label='Author',
default='E-Mail Address',
validator=validators.Email()),
CaptchaField(name='captcha', label='Enter the code shown')
]
class Preferences(RPCRoot):
exposed = True
delete_link = DeleteLinkWidgetForm()
beaker_password = widgets.PasswordField(name='password',
label='Beaker Password')
root_password = widgets.TextField(name='_root_password',
label='Root Password')
rootpw_expiry = widgets.TextField(name='rootpw_expiry',
label='Root Password Expiry',
attrs={'disabled': True})
email = widgets.TextField(name='email_address',
label='Email Address',
validator=validators.Email())
prefs_form = HorizontalForm(
'UserPrefs',
fields=[email, beaker_password, root_password, rootpw_expiry],
action='save',
submit_text=_(u'Change'),
)
sshkey = widgets.TextArea(
name='ssh_pub_key',
label='Public SSH Key',
validator=beaker_validators.SSHPubKey(not_empty=True))
ssh_key_add_form = InlineForm(
'ssh_key_add',
fields=[sshkey],
action='ssh_key_add',
submit_text=_(u'Add'),
)
rootpw_grid = BeakerDataGrid(fields=[
BeakerDataGrid.Column('root_password',
title=_(u'Root Password'),
getter=lambda x: x.value),
BeakerDataGrid.Column('effective_from',
title=_(u'Effective from'),
getter=lambda x: x.valid_from,
options=dict(datetime=True)),
])
auto_users = AutoCompleteField(name='user',
search_controller=url("../users/by_name"),
search_param="input",
result_name="matches")
submission_delegate_form = InlineForm(
'SubmissionDelegates',
fields=[auto_users],
action='save_data',
submit_text=_(u'Add'),
)
remove_submission_delegate_link = DoAndConfirmForm()
def show_submission_delegates(self, user):
user_fields = [
('Submission Delegate', lambda x: x.display_name),
('Action', lambda x: self.remove_submission_delegate_link. \
display({'delegate_id': x.user_id},
action=url('remove_submission_delegate'), look='link',
msg='Are you sure you want to remove %s as a submitter?' % x,
action_text='Remove (-)')),]
return BeakerDataGrid(fields=user_fields)
@expose(template='bkr.server.templates.prefs')
@identity.require(identity.not_anonymous())
def index(self, *args, **kw):
user = identity.current.user
# Show all future root passwords, and the previous five
rootpw = ConfigItem.by_name('root_password')
rootpw_values = rootpw.values().filter(rootpw.value_class.valid_from > datetime.utcnow())\
.order_by(rootpw.value_class.valid_from.desc()).all()\
+ rootpw.values().filter(rootpw.value_class.valid_from <= datetime.utcnow())\
.order_by(rootpw.value_class.valid_from.desc())[:5]
return dict(
title='User Prefs',
delete_link=self.delete_link,
prefs_form=self.prefs_form,
ssh_key_form=self.ssh_key_add_form,
widgets={},
ssh_keys=user.sshpubkeys,
value=user,
rootpw=rootpw.current_value(),
rootpw_grid=self.rootpw_grid,
rootpw_values=rootpw_values,
options=None,
#Hack, to insert static content for submission_delegate
remove_submission_delegate=self.remove_submission_delegate_link,
submission_delegates_grid=self.show_submission_delegates(user),
submission_delegate_form=self.submission_delegate_form)
# XMLRPC interface
@expose()
@identity.require(identity.not_anonymous())
def remove_submission_delegate_by_name(self,
delegate_name,
service=u'XMLRPC'):
user = identity.current.user
try:
submission_delegate = User.by_user_name(delegate_name)
except NoResultFound:
raise BX(_(u'%s is not a valid user name' % delegate_name))
try:
user.remove_submission_delegate(submission_delegate,
service=service)
except ValueError:
raise BX(_(u'%s is not a submission delegate of %s' % \
(delegate_name, user)))
return delegate_name
# UI interface
@expose()
@identity.require(identity.not_anonymous())
def remove_submission_delegate(self, delegate_id, service=u'WEBUI'):
user = identity.current.user
try:
submission_delegate = User.by_id(delegate_id)
except NoResultFound:
flash(_(u'%s is not a valid user id' % delegate_id))
redirect('.')
user.remove_submission_delegate(submission_delegate, service=service)
flash(_(u'%s removed as a submission delegate' % submission_delegate))
redirect('.')
# XMLRPC Interface
@expose()
@identity.require(identity.not_anonymous())
def add_submission_delegate_by_name(self,
new_delegate_name,
service=u'XMLRPC'):
user = identity.current.user
new_delegate = User.by_user_name(new_delegate_name)
if not new_delegate:
raise BX(_(u'%s is not a valid user' % new_delegate_name))
user.add_submission_delegate(new_delegate, service)
return new_delegate_name
# UI Interface
@expose()
@identity.require(identity.not_anonymous())
def add_submission_delegate(self, **kwargs):
user = identity.current.user
new_delegate_name = kwargs['user']['text']
new_delegate = User.by_user_name(new_delegate_name)
if not new_delegate:
flash(_(u'%s is not a valid user' % new_delegate_name))
redirect('.')
try:
user.add_submission_delegate(new_delegate, u'WEBUI')
except NoChangeException, e:
flash(_(unicode(e)))
redirect('.')
flash(_(u'Added %s as a submission delegate' % new_delegate_name))
redirect('.')
elif root_password and root_password != \
identity.current.user.root_password:
try:
identity.current.user.root_password = root_password
changes.append("Test host root password hash changed")
except ValueError, msg:
changes.append("Root password not changed: %s" % msg)
if changes:
flash(_(u', '.join(changes)))
redirect('.')
#XMLRPC method for updating user preferences
@cherrypy.expose
@identity.require(identity.not_anonymous())
@validate(validators=dict(email_address=validators.Email()))
def update(self, email_address=None, tg_errors=None):
"""
Update user preferences
:param email_address: email address
:type email_address: string
"""
if tg_errors:
raise BeakerException(', '.join(
str(item) for item in tg_errors.values()))
if email_address:
if email_address == identity.current.user.email_address:
raise BeakerException(
"Email address not changed: new address is same as before")
else:
if group not in owner.groups:
raise BX(
_(u'User %s is not a member of group %s' %
(owner.user_name, group.group_name)))
job_retention = xmljob.get_xml_attr('retention_tag', unicode, None)
job_product = xmljob.get_xml_attr('product', unicode, None)
tag, product = self._process_job_tag_product(
retention_tag=job_retention, product=job_product)
job = Job(whiteboard=unicode(xmljob.whiteboard),
ttasks=0,
owner=owner,
group=group,
submitter=submitter)
job.product = product
job.retention_tag = tag
email_validator = validators.Email(not_empty=True)
for addr in set(xmljob.iter_cc()):
try:
job.cc.append(email_validator.to_python(addr))
except Invalid, e:
raise BX(
_('Invalid e-mail address %r in <cc/>: %s') %
(addr, str(e)))
for xmlrecipeSet in xmljob.iter_recipeSets():
recipe_set = self._handle_recipe_set(
xmlrecipeSet, owner, ignore_missing_tasks=ignore_missing_tasks)
job.recipesets.append(recipe_set)
job.ttasks += recipe_set.ttasks
if not job.recipesets:
raise BX(
class GroupSendInvite(validators.Schema):
groupname = KnownGroup
target = validators.Email(not_empty=True, strip=True),
class MyFields(widgets.WidgetsList):
age = widgets.TextField(validator=validators.Int())
email = widgets.TextArea(validator=validators.Email())
class MyRoot(RootController):
def defaulterrorhandler(self, tg_source, tg_errors, tg_exceptions,
*args, **kw):
return dict(title="Default error handler",
errors=_errors_to_str(tg_errors), args=args, kw=kw)
def specialisederrorhandler(self, tg_source, tg_errors, *args, **kw):
return dict(title="Specialised error handler",
errors=_errors_to_str(tg_errors), args=args, kw=kw)
def defaulterror(self, bar=""):
return dict(title="Default error provider")
defaulterror = error_handler(defaulterrorhandler)(defaulterror)
defaulterror = validate(validators={"bar": validators.StringBoolean()})(
defaulterror)
defaulterror = expose()(defaulterror)
def specialisederror(self, bar="", baz=""):
return dict(title="Specialised error provider")
specialisederror = error_handler(defaulterrorhandler)(
specialisederror)
specialisederror = error_handler(specialisederrorhandler,
"'baz' in tg_errors")(specialisederror)
specialisederror = validate(validators={
"bar": validators.Int(not_empty=True),
"baz": validators.Email()})(specialisederror)
specialisederror = expose()(specialisederror)
def exceptionerror(self):
raise Exception("Exception 1")
exceptionerror = exception_handler(defaulterrorhandler)(exceptionerror)
exceptionerror = expose()(exceptionerror)
def exceptionerror2(self):
raise Exception("Exception 2")
exceptionerror2 = exception_handler(exceptionerror2)(exceptionerror2)
exceptionerror2 = expose()(exceptionerror2)
def recursiveerror(self, tg_errors=None, bar=""):
if tg_errors:
return dict(title="Recursive error handler")
else:
return dict(title="Recursive error provider")
recursiveerror = error_handler()(recursiveerror)
recursiveerror = validate(validators={
"bar": validators.Int(not_empty=True)})(recursiveerror)
recursiveerror = expose()(recursiveerror)
def impliciterror(self, tg_errors=None, bar=""):
if tg_errors:
return dict(title="Implicit error handler",
tg_errors=str(tg_errors))
else:
return dict(title="Implicit error provider")
impliciterror = validate(validators={
"bar": validators.Int(not_empty=True)})(impliciterror)
impliciterror = expose()(impliciterror)
def normalmethod(self):
return dict(title="Normal method")
normalmethod = expose()(normalmethod)
def normalmethodcaller(self, bar=""):
return dict(title="Normal method caller")
normalmethodcaller = error_handler(normalmethod)(normalmethodcaller)
normalmethodcaller = validate(validators={
"bar": validators.StringBoolean()})(normalmethodcaller)
normalmethodcaller = expose()(normalmethodcaller)
def infiniteloop(self):
try:
self.exceptionerror2()
except Exception, e:
return dict(title=str(e))
else:
class BugzillaSave(validators.Schema):
bugzilla_email = validators.Email(strip=True, max=128)
