class UserManageFormView(UserEditFormView):
buttons = (Button('save', _(u'Save')),
Button('cancel', _(u'Cancel')),
Button('delete', _(u'Delete'), css_class='btn btn-danger'))
def schema_factory(self):
schema = user_schema()
del schema['name']
return schema
def before(self, form):
context = self.context.__dict__.copy()
context['password'] = u''
form.appstruct = _massage_groups_out(context)
def save_success(self, appstruct):
if appstruct.get('password'):
hashed = get_principals().hash_password(appstruct['password'])
appstruct['password'] = hashed
else:
appstruct.pop('password', None)
_massage_groups_in(appstruct)
return super(UserEditFormView, self).save_success(appstruct)
def cancel_success(self, appstruct):
self.request.session.flash(_(u'No changes were made.'), 'info')
location = u'{0}/@@setup-users'.format(self.request.application_url)
return HTTPFound(location=location)
cancel_failure = cancel_success
def delete_success(self, appstruct):
location = u'{0}/@@delete-user?name={1}'.format(
self.request.application_url, self.request.params['name'])
return HTTPFound(location=location)
class UserAddFormView(AddFormView):
item_type = _(u'User')
buttons = (Button('add_user',
_(u'Add User')), Button('cancel', _(u'Cancel')))
def schema_factory(self):
schema = user_schema()
del schema['active']
schema.add(
colander.SchemaNode(
colander.Boolean(),
name=u'send_email',
title=_(u'Send password registration link'),
default=True,
))
return schema
def add_user_success(self, appstruct):
appstruct.pop('csrf_token', None)
_massage_groups_in(appstruct)
name = appstruct['name'] = appstruct['name'].lower()
appstruct['email'] = appstruct['email'] and appstruct['email'].lower()
send_email = appstruct.pop('send_email', False)
get_principals()[name] = appstruct
if send_email:
email_set_password(get_principals()[name], self.request)
self.request.session.flash(
_(u'${title} added.', mapping=dict(title=appstruct['title'])),
'success')
location = self.request.url.split('?')[0] + '?' + urlencode(
{'extra': name})
return HTTPFound(location=location)
class UserManageFormView(UserEditFormView):
buttons = (Button('save', _(u'Save')),
Button('cancel', _(u'Cancel')),
Button('delete', _(u'Delete'), css_class='btn btn-danger'))
def schema_factory(self):
schema = user_schema()
del schema['name']
del schema['password']
return schema
def before(self, form):
form.appstruct = _massage_groups_out(self.context.__dict__.copy())
def save_success(self, appstruct):
_massage_groups_in(appstruct)
return super(UserEditFormView, self).save_success(appstruct)
def cancel_success(self, appstruct):
self.request.session.flash(_(u'No changes were made.'), 'info')
location = "%s/@@setup-users" % self.request.application_url
return HTTPFound(location=location)
cancel_failure = cancel_success
def delete_success(self, appstruct):
location = "%s/@@delete-user?name=%s" % (
self.request.application_url, self.request.params['name'])
return HTTPFound(location=location)
class UserManageFormView(UserEditFormView):
buttons = (Button('save', _(u'Save')), Button('cancel', _(u'Cancel')),
Button('delete', _(u'Delete')))
def schema_factory(self):
schema = user_schema()
del schema['name']
del schema['password']
return schema
def before(self, form):
form.appstruct = _massage_groups_out(self.context.__dict__.copy())
def save_success(self, appstruct):
_massage_groups_in(appstruct)
return super(UserEditFormView, self).save_success(appstruct)
def cancel_success(self, appstruct):
self.request.session.flash(_(u'No changes made.'), 'info')
location = "%s/@@setup-users" % self.request.application_url
return HTTPFound(location=location)
cancel_failure = cancel_success
def delete_success(self, appstruct):
principals = get_principals()
user = principals.search(email=appstruct['email']).first()
location = "%s/@@delete-user?name=%s" % (self.request.application_url,
user.name)
return HTTPFound(location=location)
class UserAddFormView(AddFormView):
item_type = _("User")
form_options = (("formid", "deform_user_add"), )
buttons = (Button("add_user",
_("Add User")), Button("cancel", _("Cancel")))
@staticmethod
def schema_factory():
schema = user_schema()
del schema["active"]
schema.add(
colander.SchemaNode(
colander.Boolean(),
name="send_email",
title=_("Send password registration link."),
default=True,
))
return schema
def add_user_success(self, appstruct):
appstruct.pop("csrf_token", None)
_massage_groups_in(appstruct)
name = appstruct["name"] = appstruct["name"].lower()
appstruct["email"] = appstruct["email"] and appstruct["email"].lower()
send_email = appstruct.pop("send_email", False)
get_principals()[name] = appstruct
if send_email:
email_set_password(get_principals()[name], self.request)
self.request.session.flash(
_("${title} was added.", mapping=dict(title=appstruct["title"])),
"success")
location = self.request.url.split("?")[0] + "?" + urlencode(
{"extra": name})
return HTTPFound(location=location)
class BaseFormView(FormView):
form_class = Form
buttons = (Button('save', _(u'Save')), Button('cancel', _(u'Cancel')))
success_message = _(u"Your changes have been saved.")
success_url = None
schema_factory = None
use_csrf_token = True
add_template_vars = ()
def __init__(self, context, request, **kwargs):
self.context = context
self.request = request
self.__dict__.update(kwargs)
def __call__(self):
if self.schema_factory is not None:
self.schema = self.schema_factory()
if self.use_csrf_token and 'csrf_token' not in self.schema:
self.schema.children.append(CSRFSchema()['csrf_token'])
result = super(BaseFormView, self).__call__()
if isinstance(result, dict):
result.update(self.more_template_vars())
return result
def cancel_success(self, appstruct):
return HTTPFound(location=self.request.url)
def more_template_vars(self):
result = {}
for name in self.add_template_vars:
result[name] = getattr(self, name)
return result
def buttons(self):
prev_disabled = not self.prev_ok()
next_disabled = not self.next_ok()
prev_button = Button(
name='previous',
title='Previous',
css_class="btn-warning",
disabled=prev_disabled
) # type=submit|reset|button,value=name,css_type="btn-..."
cancel_button = Button(name='cancel',
title='Cancel',
css_class='btn-danger',
disabled=False)
next_button = Button(name='next',
title='Next',
css_class="btn-success",
disabled=next_disabled)
done_button = Button(name='next',
title='Done',
css_class="btn-success",
disabled=next_disabled
or not self.request.has_permission('submit'))
buttons = []
# TODO: fix focus button
if not self.wizard_state.is_first():
buttons.append(prev_button)
buttons.append(cancel_button)
if self.wizard_state.is_last():
buttons.append(done_button)
else:
buttons.append(next_button)
return buttons
def make_client_authorization_form(request):
schema = ClientAuthorization()
auth_form = Form(schema.bind(request=request),
buttons=(
Button('submit', title='Authorize Application'),
Button('cancel', title='Deny Access'),
))
return auth_form
def form(self):
return Form(
CreateUserSchema().bind(request=self.request),
buttons=[
Button("reset", "Reset", type="reset"),
Button("register", "Register"),
],
)
def destroy(request):
schema = AccountDestroySchema()
button1 = Button('submit', _('Yes, I am sure. Destroy my account'))
button1.css_class = 'btn-danger'
button2 = Button('cancel', _('Cancel'))
button2.css_class = 'btn-default'
form = Form(schema, buttons=(button1, button2))
user = request.user
can_destroy = len(user.applications) == 0
context = {
'passwords': len(user.passwords),
'can_destroy': can_destroy,
}
if 'submit' in request.POST:
if not can_destroy:
request.session.flash(
_('You must remove your applications before destroying your account'
),
'error',
)
return HTTPFound(
location=request.route_path('oauth2_developer_applications'))
controls = request.POST.items()
try:
appstruct = form.validate(controls)
except ValidationFailure as e:
context['form'] = e.render()
return context
reason = appstruct['reason']
notify_admins_of_account_removal(request, user, reason)
Session.delete(user)
request.session.flash(
_('Your account has been removed. Have a nice day!'),
'success',
)
return logout(request)
elif 'cancel' in request.POST:
request.session.flash(
_('Thanks for reconsidering removing your account!'),
'info',
)
return HTTPFound(location=request.route_path('user_information'))
context['form'] = form.render()
return context
def get_form_buttons():
submit = Button(name='submit',
title=u'Potvrdi',
type='submit',
css_class='btn-primary')
cancel = Button(name='cancel',
title=u'Odustani',
type='submit',
css_class='btn-default')
return submit, cancel
def make_disable_user_form(request):
schema = DisableUser()
# This form will be on a page with multiple forms,
# so we have to set the formid attribute for the ajax
# stuff to work.
disable_user_form = Form(
schema=schema.bind(request=request),
buttons=(Button('submit', title='Yes'), Button('cancel', title='No')),
formid='disable-form',
)
return disable_user_form
def contact(request):
button1 = Button('submit', _('Send message'))
button1.css_class = 'btn-primary'
button2 = Button('cancel', _('Cancel'))
button2.css_class = 'btn-default'
form = Form(ContactSchema(), buttons=(button1, button2))
if 'submit' in request.POST:
controls = request.POST.items()
try:
appstruct = form.validate(controls)
except ValidationFailure as e:
return {'form': e.render()}
context = {'link': request.route_url('contact')}
context.update(appstruct)
subject = ("%s sent a message from Yith's contact form" %
appstruct['name'])
result = send_email_to_admins(
request,
'yithlibraryserver:templates/email_contact',
context,
subject,
extra_headers={'Reply-To': appstruct['email']},
)
if result is None:
log.error(
'%s <%s> tried to send a message from the contact form but no '
'admin emails were configured. Message: %s' % (
appstruct['name'],
appstruct['email'],
appstruct['message'],
))
request.session.flash(
_('Thank you very much for sharing your opinion'),
'info',
)
return HTTPFound(location=request.route_path('home'))
elif 'cancel' in request.POST:
return HTTPFound(location=request.route_path('home'))
initial = {}
if request.user is not None:
initial['name'] = request.user.first_name
if request.user.email_verified:
initial['email'] = request.user.email
return {'form': form.render(initial)}
class GroupAddFormView(UserAddFormView):
buttons = (Button('add_group',
_(u'Add Group')), Button('cancel', _(u'Cancel')))
def schema_factory(self):
schema = group_schema()
del schema['active']
return schema
def add_group_success(self, appstruct):
appstruct['name'] = u'group:%s' % appstruct['name'].lower()
return self.add_user_success(appstruct)
class GroupAddFormView(UserAddFormView):
item_type = _(u"Group")
form_options = (('formid', 'deform_group_add'), )
buttons = (Button('add_group', _(u'Add Group')),
Button('cancel', _(u'Cancel')))
def schema_factory(self):
schema = group_schema()
del schema['active']
return schema
def add_group_success(self, appstruct):
appstruct['name'] = u'group:{0}'.format(appstruct['name'].lower())
return self.add_user_success(appstruct)
class ConfirmBadPollMethodView(BaseForm):
buttons = (
Button(
"edit",
title=_("Change method"),
),
Button("override",
title=_("Override - I'm aware of the consequences"),
css_class='btn-danger'),
BaseForm.button_cancel,
)
def get_schema(self):
return colander.Schema()
def __call__(self):
values = super(ConfirmBadPollMethodView, self).__call__()
if isinstance(values, dict):
values["bad_method_text"] = self.request.session.get(
'_bad_method_text', '')
values["bad_method_recommendation"] = self.request.session.get(
'_bad_method_recommendation', '')
return values
def _cleanup(self):
self.request.session.pop('_bad_method_text', None)
self.request.session.pop('_bad_method_recommendation', None)
def edit_success(self, appstruct):
self._cleanup()
url = self.request.resource_url(self.context, "edit")
return HTTPFound(location=url)
def override_success(self, appstruct):
try:
self.context.set_workflow_state(self.request, "ongoing")
except WorkflowError as exc:
raise HTTPForbidden(str(exc))
self._cleanup()
url = self.request.resource_url(self.context.__parent__,
anchor=self.context.uid)
return HTTPFound(location=url)
def cancel_success(self, *args):
self._cleanup()
url = self.request.resource_url(self.context.__parent__,
anchor=self.context.uid)
return HTTPFound(location=url)
def generate_form(self):
if self.tab == 'group':
btn = Button(name='update',
title='Update Group Permission',
css_class="btn btn-success btn-lg btn-block",
disabled=not self.request.has_permission('admin'))
form = Form(schema=self.schema(), buttons=(btn, ), formid='deform')
elif self.tab == 'profile':
btn = Button(name='update',
title='Update Profile',
css_class="btn btn-success btn-lg btn-block")
form = Form(schema=self.schema(), buttons=(btn, ), formid='deform')
else:
form = Form(schema=self.schema(), formid='deform')
return form
class GroupAddFormView(UserAddFormView):
item_type = _("Group")
form_options = (("formid", "deform_group_add"), )
buttons = (Button("add_group",
_("Add Group")), Button("cancel", _("Cancel")))
@staticmethod
def schema_factory():
schema = group_schema()
del schema["active"]
return schema
def add_group_success(self, appstruct):
appstruct["name"] = "group:{}".format(appstruct["name"].lower())
return self.add_user_success(appstruct)
def get_duplicate_form(request, counter=None):
"""
Return the form for task duplication
"""
duplicate_js.need()
schema = DuplicateSchema().bind(request=request)
action = request.route_path(
request.context.__name__,
id=request.context.id,
_query=dict(action='duplicate'),
)
valid_btn = Button(
name='submit',
value="duplicate",
type='submit',
title=u"Valider",
)
form = Form(
schema=schema,
buttons=(valid_btn, ),
action=action,
formid="duplicate_form",
counter=counter,
)
return form
def edit(self):
location = self.request.context
form = Form(
LocationForm().bind(
request=self.request,
location=location),
buttons=('Save', Button(name='cancel', type='button')),
appstruct=location.appstruct)
if self.request.method == 'POST':
data = self.request.POST.items()
try:
values = form.validate(data)
except ValidationFailure:
pass
else:
location.update(**values)
self.request.session.flash(
_("Your changes have been saved"), 'success')
return HTTPFound(
self.request.route_url(
'locations', traverse=(location.id, 'edit')))
return {
'form': form,
'location': location,
'period': self.period
}
def ballot_voting_form(ballot_voting, request):
yes_no_choices = [(True, _('Yes')), (False, _('No')), (None, _('Abstention'))]
max_points = 9 if len(ballot_voting.options) > 3 else 3
point_choices = [(i, str(i)) for i in range(max_points+1)]
schema = Schema()
for option in ballot_voting.options:
option_schema = SchemaNode(Mapping(), name=str(option.uuid), title=option.title)
option_schema.add(SchemaNode(
Boolean(),
validator=OneOf([x[0] for x in yes_no_choices]),
widget=RadioChoiceWidget(values=yes_no_choices, inline=True),
name='yes_no',
title=f'Stimmst du dem Antrag zu?'))
option_schema.add(SchemaNode(
Int(),
validator=OneOf([x[0] for x in point_choices]),
widget=RadioChoiceWidget(values=point_choices, inline=True, null_value='0'),
name='points',
title='Welche Punktzahl gibst du dem Antrag?',
missing=0))
schema.add(option_schema)
form = Form(schema, request, buttons=[Button(title=_('check'))])
return form
class login(FormView):
schema = LoginSchema(validator=login_validator)
buttons = (
Button('log in', type='submit'),
Button('forgot', title='Password help?'),
)
form_class = partial(Form,
bootstrap_form_style='form-vertical',
formid='auth')
def log_in_success(self, form):
request = self.request
user = (AuthUser.get_by_login(form['username'])
or AuthUser.get_by_email(form['username']))
headers = remember(request, user.auth_id)
return HTTPSeeOther(headers=headers, location=get_came_from(request))
def __init__(self, request):
super(Login, self).__init__(request)
schema = LoginSchema().bind(request=self.request)
self.form = Form(schema,
buttons=(Button(title=u'Login!'), ),
method=u'post',
action=self.request.route_path('login'))
def __init__(self, *args, **kwargs):
"""Initialize DefaultRegisterForm."""
sign_up_button = Button(name="sign_up",
title="Sign up with email",
css_class="btn-lg btn-block")
kwargs['buttons'] = (sign_up_button, )
super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
"""Initialize DefaultLoginForm."""
login_button = Button(name="login_email",
title="Login with email",
css_class="btn-lg btn-block")
kwargs['buttons'] = (login_button, )
super().__init__(*args, **kwargs)
def make_new_authorization_form(request):
schema = Authorization()
new_authoization_form = Form(
schema=schema.bind(request=request),
buttons=(Button(u'submit', title=u'Create'), ),
)
return new_authoization_form
def _get_login_form(request, use_ajax=False):
"""
Return the login form object
:param obj request: The pyramid request object
:param bool use_ajax: Is this form called through xhr (should it be an ajax
form) ?
"""
if use_ajax:
action = request.route_path('login')
ajax_options = """{
'dataType': 'json',
'success': ajaxAuthCallback
}"""
else:
action = None
ajax_options = "{}"
form = Form(
get_auth_schema(),
action=action,
use_ajax=use_ajax,
formid="authentication",
ajax_options=ajax_options,
bootstrap_form_style="authentication-form",
buttons=(Button(
name="submit",
title="Connexion",
type='submit',
), ),
)
return form
def make_login_form(request, action=''):
schema = Login()
login_form = Form(schema=schema.bind(request=request),
action=action,
bootstrap_form_style='form-vertical',
buttons=(Button('submit', title='Log In'), 'cancel'))
return login_form
def register(context, request):
schema = RegisterSchema().bind(request=request)
form = Form(schema, buttons=(Button('register', _(u'Register')), ))
rendered_form = None
if 'register' in request.POST:
try:
appstruct = form.validate(request.POST.items())
except ValidationFailure, e:
request.session.flash(_(u"There was an error."), 'error')
rendered_form = e.render()
else:
settings = get_settings()
appstruct['groups'] = u''
appstruct['roles'] = u''
register_groups = settings['kotti.register.group']
if register_groups:
appstruct['groups'] = [register_groups]
register_roles = settings['kotti.register.role']
if register_roles:
appstruct['roles'] = set(['role:' + register_roles])
appstruct['send_email'] = True
form = UserAddFormView(context, request)
form.add_user_success(appstruct)
success_msg = _(
'Congratulations! You are successfully registered. '
'You should receive an email with a link to set your '
'password momentarily.')
request.session.flash(success_msg, 'success')
return HTTPFound(location=request.application_url)
def preferences(request):
schema = UserPreferencesSchema()
button1 = Button('submit', _('Save changes'))
button1.css_class = 'btn-primary'
form = Form(schema, buttons=(button1, ))
user = request.user
if 'submit' in request.POST:
controls = request.POST.items()
try:
appstruct = form.validate(controls)
except ValidationFailure as e:
return {'form': e.render()}
user.update_preferences(appstruct)
Session.add(user)
request.session.flash(
_('The changes were saved successfully'),
'success',
)
return HTTPFound(location=request.route_path('user_preferences'))
return {
'form':
form.render({
'allow_google_analytics':
user.allow_google_analytics,
'send_passwords_periodically':
user.send_passwords_periodically,
})
}