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