def get(self, slug = None): """show the complete registration form with registration data, user registration and more""" regform = self.registration_form userform = self.user_registration_form # a list of all ticket class objects ticketlist = self.barcamp.ticketlist if self.request.method == "POST": try: self.process_post_data() except ProcessingError, e: self.log.exception() self.flash(self._("Unfortunately an error occurred when trying to register you. Please try again or contact the barcamptools administrator."), category="danger") else: if self.logged_in: if self.barcamp.paid_tickets: self.flash(self._("Your ticket reservations have been processed. Please check your email for information on how to pay for your ticket."), category="success") else: self.flash(self._("Your ticket reservation was successful."), category="success") return redirect(self.url_for(".mytickets", slug = self.barcamp.slug)) else: self.flash(self._("In order to finish your registration you have to activate your account. Please check your email."), category="success") return redirect(self.url_for(".index", slug = self.barcamp.slug))
def get(self, slug=None): """show the complete registration form with registration data, user registration and more""" # show tickets instead if ticketmode is enabled if self.barcamp.ticketmode_enabled: return redirect(self.url_for(".tickets", slug=slug)) regform = self.registration_form userform = self.user_registration_form if self.request.method == "POST": try: self.process_post_data() except ProcessingError, e: self.flash(self._( "Unfortunately an error occurred when trying to register you. Please try again or contact the barcamptools administrator." ), category="danger") print "error on processing post data", e else: if self.logged_in: self.flash(self._( "You have been successfully registered. Please check your email." ), category="success") return redirect( self.url_for(".user_events", slug=self.barcamp.slug)) else: self.flash(self._( "In order to finish your registration you have to activate your account. Please check your email." ), category="success") return redirect( self.url_for(".index", slug=self.barcamp.slug))
def get(self, slug = None): """handle the barcamp registration for multiple events with optional registration form""" if self.barcamp.workflow != "registration": return "registration is not open yet" # check if the user has filled out all the required information on the form already uid = unicode(self.user._id) if not self.barcamp.registration_data.has_key(uid) and self.barcamp.registration_form: # user is not in list and we have a form return redirect(self.url_for(".registration_form", slug = self.barcamp.slug)) # now check the fields if self.barcamp.registration_form: ok = True data = self.barcamp.registration_data[uid] for field in self.barcamp.registration_form: if field['required'] and field['name'] not in data: ok = False return redirect(self.url_for(".registration_form", slug = self.barcamp.slug)) # user can register, show the list of events return self.render( view = self.barcamp_view, barcamp = self.barcamp, title = self.barcamp.name, has_form_data = self.barcamp.registration_data.has_key(uid), form_data = self.barcamp.registration_data.get(uid,{}), **self.barcamp)
def post(self, slug = None): """only a post without parameters is done to remove.""" event = self.barcamp.event view = self.barcamp_view # get the username from the form username = self.request.form.get("u", None) if username is not None: user = self.app.module_map.userbase.get_user_by_username(username) else: user = self.user uid = unicode(user._id) # now check if we are allowed to to any changes to the user. We are if a) we are that user or b) we are an admin if not view.is_admin and not user==self.user: self.flash(self._("You are not allowed to change this."), category="danger") return redirect(self.url_for("barcamp_userlist", slug = self.barcamp.slug)) if uid in event.participants: event.participants.remove(uid) if len(event.participants) < self.barcamp.size and len(event.waiting_list)>0: # somebody from the waiting list can move up nuid = event.waiting_list[0] event.waiting_list = event.waiting_list[1:] event.participants.append(nuid) # you are now still a subscriber self.barcamp.subscribe(user) self.barcamp.put() if user == self.user: self.flash(self._("You have been removed from the list of participants."), category="danger") else: self.flash(self._("%(fullname)s has been removed from the list of participants.") %user, category="danger") return redirect(self.url_for("barcamp_userlist", slug = self.barcamp.slug))
def get(self): """show the registration form""" cfg = self.module.config mod = self.module form = ActivationEMailForm(self.request.form) if self.request.method == 'POST': if form.validate(): f = form.data user = mod.get_user_by_email(f['email']) if user is not None: # send out new activation code and redirect to code sent success screen if user.active: self.flash( self._( "The user is already active. Please log in.") % user) url_for_params = cfg.urls.activation_success url = self.url_for(**url_for_params) return redirect(url) mod.send_activation_code(user) self.flash( self. _("A new activation code has been sent out, please check your email" ) % user) url_for_params = cfg.urls.activation_code_sent url = self.url_for(**url_for_params) return redirect(url) else: self.flash(self._( "This email address cannot not be found in our user database" ), category="danger") return self.render(form=form)
def get(self): """show the registration form""" cfg = self.module.config mod = self.module form = cfg.registration_form obj_class = cfg.user_class form = form(self.request.form, module = self.module) if self.request.method == 'POST': if form.validate(): f = form.data user = mod.register(f, create_pw=False) if cfg.login_after_registration and not cfg.use_double_opt_in: user = mod.login(self, force=True, **f) self.flash(self._("Welcome, %(fullname)s") %user) url_for_params = cfg.urls.login_success url = self.url_for(**url_for_params) return redirect(url) if cfg.use_double_opt_in: self.flash(self._(u'To finish the registration process please check your email with instructions on how to activate your account.') %user) url_for_params = cfg.urls.double_opt_in_pending else: self.flash(self._(u'Your user registration has been successful') %user) url_for_params = cfg.urls.registration_success url = self.url_for(**url_for_params) return redirect(url) return self.render(form = form, use_double_opt_in = cfg.use_double_opt_in)
def get(self): """show the registration form""" cfg = self.module.config mod = self.module form = cfg.registration_form obj_class = cfg.user_class form = form(self.request.form, module=self.module) if self.request.method == 'POST': if form.validate(): f = form.data user = mod.register(f, create_pw=False) if cfg.login_after_registration and not cfg.use_double_opt_in: user = mod.login(self, force=True, **f) self.flash(self._("Welcome, %(fullname)s") % user) url_for_params = cfg.urls.login_success url = self.url_for(**url_for_params) return redirect(url) if cfg.use_double_opt_in: self.flash( self. _(u'To finish the registration process please check your email with instructions on how to activate your account.' ) % user) url_for_params = cfg.urls.double_opt_in_pending else: self.flash( self._(u'Your user registration has been successful') % user) url_for_params = cfg.urls.registration_success url = self.url_for(**url_for_params) return redirect(url) return self.render(form=form, use_double_opt_in=cfg.use_double_opt_in)
def get(self, slug=None): """handle the barcamp registration for multiple events with optional registration form""" if self.barcamp.workflow != "registration": return "registration is not open yet" # check if the user has filled out all the required information on the form already uid = unicode(self.user._id) if not self.barcamp.registration_data.has_key( uid) and self.barcamp.registration_form: # user is not in list and we have a form return redirect( self.url_for(".registration_form", slug=self.barcamp.slug)) # now check the fields if self.barcamp.registration_form: ok = True data = self.barcamp.registration_data[uid] for field in self.barcamp.registration_form: if field['required'] and field['name'] not in data: ok = False return redirect( self.url_for(".registration_form", slug=self.barcamp.slug)) # user can register, show the list of events return self.render( view=self.barcamp_view, barcamp=self.barcamp, title=self.barcamp.name, has_form_data=self.barcamp.registration_data.has_key(uid), form_data=self.barcamp.registration_data.get(uid, {}), **self.barcamp)
def post(self, slug=None): """only a post without parameters is done to add. Post again to unsubscribe""" view = self.barcamp_view username = self.request.form.get("u", None) if username is not None: user = self.app.module_map.userbase.get_user_by_username(username) else: user = self.user # now check if we are allowed to to any changes to the user. We are if a) we are that user or b) we are an admin if not view.is_admin and not user == self.user: self.flash(self._("You are not allowed to change this."), category="danger") return redirect(self.url_for(".userlist", slug=self.barcamp.slug)) if unicode(user._id) not in self.barcamp.subscribers: self.barcamp.subscribe(self.user) # we can only subscribe our own user, thus self.user and not user self.flash(self._("You are now on the list of people interested in the barcamp"), category="success") else: self.barcamp.unsubscribe(user) # we can remove any user if we have the permission (see above for the check) if user == self.user: self.flash( self._("You have been removed from the list of people interested in this barcamp"), category="danger", ) else: self.flash( self._("%(fullname)s has been removed from the list of people interested in this barcamp") % user, category="danger", ) return redirect(self.url_for(".userlist", slug=self.barcamp.slug))
def get(self): """show the registration form""" cfg = self.module.config mod = self.module form = ActivationEMailForm(self.request.form) if self.request.method == 'POST': if form.validate(): f = form.data user = mod.get_user_by_email(f['email']) if user is not None: # send out new activation code and redirect to code sent success screen if user.active: self.flash(self._("The user is already active. Please log in.") %user) url_for_params = cfg.urls.activation_success url = self.url_for(**url_for_params) return redirect(url) mod.send_activation_code(user) self.flash(self._("A new activation code has been sent out, please check your email") %user) url_for_params = cfg.urls.activation_code_sent url = self.url_for(**url_for_params) return redirect(url) else: self.flash(self._("This email address cannot not be found in our user database"), category="danger") return self.render(form = form)
def wrapper(self, *args, **kwargs): if self.user is None: self.flash(u"Sie haben keine Berechtigung, diese Seite aufzurufen.", category="error") return redirect(self.url_for("index")) elif not self.user.has_permission("admin"): self.flash(u"Sie haben keine Berechtigung, diese Seite aufzurufen.", category="error") return redirect(self.url_for("index")) return method(self, *args, **kwargs)
def wrapper(self, *args, **kwargs): if self.user is None: self.flash("Sie haben nicht die erforderlichen Rechte, diese Seite einzusehen", category="danger") return redirect(self.url_for("index")) if self.user.has_permission("admin"): return method(self, *args, **kwargs) self.flash("Sie haben nicht die erforderlichen Rechte, diese Seite einzusehen", category="danger") return redirect(self.url_for("index"))
def wrapper(self, *args, **kwargs): if self.user is None: self.flash(self._(u"you don't have the permission to access this page."), category="error") return redirect(self.url_for("index")) elif not self.user.has_permission("admin"): self.flash(self._(u"you don't have the permission to access this page."), category="error") return redirect(self.url_for("index")) return method(self, *args, **kwargs)
def wrapper(self, *args, **kwargs): if self.user is None: self.flash(u"Sie haben keine Berechtigung, diese Seite aufzurufen.", category="error") return redirect(self.url_for("index")) if unicode(self.user._id) in self.barcamp.admins: return method(self, *args, **kwargs) if self.user.has_permission("admin"): return method(self, *args, **kwargs) self.flash(u"Sie haben keine Berechtigung, diese Seite aufzurufen.", category="error") return redirect(self.url_for("index"))
def wrapper(self, *args, **kwargs): if self.user is None: self.flash(self._("you don't have the correct permissions to access this page."), category="error") return redirect(self.url_for("index")) if self.user.has_permission("admin"): return method(self, *args, **kwargs) if unicode(self.user._id) in self.barcamp.admins: return method(self, *args, **kwargs) self.flash(self._("You don't have the correct permissions to access this page."), category="error") return redirect(self.url_for("index"))
def delete(self, slug = None): uid = self.request.args.get("uid") if len(self.barcamp.admins)<2: self.flash(self._(u"you at least need to have one administrator."), category="error") return redirect(self.url_for("barcamps.permissions", slug = slug)) if uid in self.barcamp.admins: self.barcamp.remove_admin_by_id(uid) self.barcamp.save() self.flash(self._(u"Administrator deleted.")) return redirect(self.url_for("barcamps.permissions", slug = slug))
def wrapper(self, *args, **kwargs): if self.user is None: self.flash(self._(u"you don't have the permission to access this page."), category="error") return redirect(self.url_for("index")) if unicode(self.user._id) in self.barcamp.admins: return method(self, *args, **kwargs) if self.user.has_permission("admin"): return method(self, *args, **kwargs) self.flash(self._(u"you don't have the permission to access this page."), category="error") return redirect(self.url_for("index"))
def delete(self, slug=None): uid = self.request.args.get("uid") if len(self.barcamp.admins) < 2: self.flash(self._(u"you at least need to have one administrator."), category="error") return redirect(self.url_for("barcamps.permissions", slug=slug)) if uid in self.barcamp.admins: self.barcamp.remove_admin_by_id(uid) self.barcamp.save() self.flash(self._(u"Administrator deleted.")) return redirect(self.url_for("barcamps.permissions", slug=slug))
def wrapper(self, *args, **kwargs): if self.user is None: self.flash(self._( u"you don't have the permission to access this page."), category="error") return redirect(self.url_for("index")) elif not self.user.has_permission("admin"): self.flash(self._( u"you don't have the permission to access this page."), category="error") return redirect(self.url_for("index")) return method(self, *args, **kwargs)
def delete(self, slug = None): uid = self.request.args.get("uid") if uid == self.barcamp.created_by: self.flash(u"Dem Ersteller des Barcamps kann das Admin-Recht nicht entzogen werden.", category="error") return redirect(self.url_for("barcamp_permissions", slug = slug)) if len(self.barcamp.admins)<2: self.flash(u"Es muss mindestens einen Administrator geben.", category="error") return redirect(self.url_for("barcamp_permissions", slug = slug)) if uid in self.barcamp.admins: self.barcamp.remove_admin_by_id(uid) self.barcamp.save() self.flash(u"Administrator gelöscht.") return redirect(self.url_for("barcamp_permissions", slug = slug))
def post(self, slug = None): """set the visibility of the barcamp""" email = self.request.form.get("email") user = self.app.module_map.userbase.get_user_by_email(email) if user is None: self.flash(self._(u"a user with this email address wasn't found in our database."), category="error") return redirect(self.url_for("barcamps.permissions", slug = slug)) uid = str(user._id) if uid not in self.barcamp.admins: self.barcamp.add_admin(user) self.barcamp.save() self.flash(self._(u"%s is not an administrator for this barcamp.") %user.fullname) return redirect(self.url_for("barcamps.permissions", slug = slug))
def post(self, slug = None): """set the visibility of the barcamp""" email = self.request.form.get("email") user = self.app.module_map.userbase.get_user_by_email(email) if user is None: self.flash("Ein Benutzer mit dieser E-Mail-Adresse wurde leider nicht gefunden.", category="error") return redirect(self.url_for("barcamp_permissions", slug = slug)) uid = str(user._id) if uid not in self.barcamp.admins: self.barcamp.add_admin(user) self.barcamp.save() self.flash(u"%s ist nun ebenfalls ein Admin für dieses Barcamp." %user.fullname) return redirect(self.url_for("barcamp_permissions", slug = slug))
def delete(self, seg_id = None, p_id = None): """delete a proposal""" p = self.config.dbs.proposals.get(p_id) p.set_workflow("deleted") p.save() self.flash(u"Der Vorschlag wurde erfolgreich gelöscht", category="danger") return redirect(self.url_for('segment_view', seg_id=seg_id))
def post(self, slug = None): """render the view""" barcamp_id = self.barcamp._id # delete pages self.config.dbs.pages._remove({'barcamp' : unicode(self.barcamp._id)}) # delete sessions sessions = self.config.dbs.sessions._remove({'barcamp_id' : str(barcamp_id)}) # delete blog entries blogs = self.config.dbs.blog._remove({'barcamp' : str(barcamp_id)}) # delete galleries galleries = self.config.dbs.galleries._remove({'barcamp' : str(barcamp_id)}) # delete participant data data = self.config.dbs.participant_data._remove({'barcamp_id' : str(barcamp_id)}) # delete tickets data = self.config.dbs.tickets._remove({'barcamp_id' : str(barcamp_id)}) # delete user favs data = self.config.dbs.userfavs._remove({'barcamp_id' : str(barcamp_id)}) # delete barcamp self.barcamp.remove() self.flash(self._("The barcamp and all it's contents have been deleted!"), category="success") return redirect(self.url_for("index"))
def delete(self, slug=None): uid = self.request.args.get("uid") if uid == self.barcamp.created_by: self.flash( u"Dem Ersteller des Barcamps kann das Admin-Recht nicht entzogen werden.", category="error") return redirect(self.url_for("barcamp_permissions", slug=slug)) if len(self.barcamp.admins) < 2: self.flash(u"Es muss mindestens einen Administrator geben.", category="error") return redirect(self.url_for("barcamp_permissions", slug=slug)) if uid in self.barcamp.admins: self.barcamp.remove_admin_by_id(uid) self.barcamp.save() self.flash(u"Administrator gelöscht.") return redirect(self.url_for("barcamp_permissions", slug=slug))
class Permissions(BarcampBaseHandler): """screen for private/public and admin management""" template = "admin/permissions.html" @ensure_barcamp() @logged_in() @is_admin() def get(self, slug=None): """render the view""" return self.render(title=self.barcamp.name, **self.barcamp) @ensure_barcamp() @logged_in() @is_admin() def post(self, slug=None): """set the workflow state for the barcamp""" try: self.barcamp.set_workflow(self.request.form.get("wf", "")) self.barcamp.save() except WorkflowError, e: print e self.flash(self._("you cannot perform this action."), category="error") return redirect(self.url_for(".admin_wizard", slug=slug)) # send out the notification email wf = self.request.form.get("wf", "") if wf == "registration": self.flash(self._("The barcamp is now open for registration."), category="success") elif wf == "public": self.flash(self._("The barcamp is now public."), category="success") # this can be multiple addresses split by comma send_to = self.app.config.new_bc_notification_addr if send_to: send_tos = [e.strip() for e in send_to.split(",")] mailer = self.app.module_map['mail'] if self.barcamp.start_date and self.barcamp.end_date: date = "%s - %s" % ( self.barcamp.start_date.strftime('%d.%m.%Y'), self.barcamp.end_date.strftime('%d.%m.%Y')) else: date = "TBA" kwargs = dict(name=self.barcamp.name, description=self.barcamp.description, date=date, url=self.url_for("barcamps.index", slug=self.barcamp.slug, _full=True)) payload = self.render_lang("emails/new_barcamp.txt", **kwargs) subject = self._("camper: new barcamp created") # now send it out to all recipients for send_to in send_tos: mailer.mail(send_to, subject, payload) return redirect(self.url_for(".admin_wizard", slug=slug))
def forbidden(self): """call this if you want to show the user a message that a permission is missing and redirect to the homepage""" self.flash(self._("You don't have the correct permissions to access this page."), category="error") # TODO: maybe check barcamp and permissions for the barcamp homepage and redirect there instead # TODO: maybe create a remember decorator which remember the last page in the session which is safe to redirect to. # the forbidden handler should delete it though return redirect(self.url_for("index"))
def get(self): """show the registration form""" cfg = self.module.config mod = self.module code = self.request.args.get("code", None) if self.request.method == 'POST': code = self.request.form.get("code", "") else: code = self.request.args.get("code", None) if code is not None: # TODO: check expiration time user = mod.get_user_by_activation_code(code) if user is not None: user.activate() mod.login(self, user=user, save=False) user.save() self.flash( self._("Your account has been successfully activated.") % user) url_for_params = cfg.urls.activation_success url = self.url_for(**url_for_params) return redirect(url) else: url = self.url_for(endpoint=".activation_code") params = {'url': url, 'code': code} self.flash(self._( """The activation code is not valid. Please try again or click <a href="%(url)s">here</a> to get a new one.""" ) % params, category="danger") return self.render()
def get(self, slug = None): """render the view""" form = ParticipantCountForm(self.request.form, obj = self.barcamp, config = self.config) min_count = self.barcamp.size form['size'].validators = [validators.Required(), validators.NumberRange(min=min_count, message=self._("you cannot reduce the participant number, the minimum amount is %s") %min_count)] if self.request.method == 'POST' and form.validate(): size = form.data['size'] self.barcamp.size = size # now move people from the waiting list to the particpating list obj = self.barcamp while obj.size > len(obj.event.participants) and len(obj.event.waiting_list)>0: nuid = obj.event.waiting_list[0] obj.event.waiting_list = obj.event.waiting_list[1:] obj.event.participants.append(nuid) # send out the mail user = self.app.module_map.userbase.get_user_by_id(nuid) self.mail_template("fromwaitinglist", view = self.barcamp_view, barcamp = self.barcamp, title = self.barcamp.name, send_to = user.email, fullname = user.fullname, **self.barcamp) self.barcamp.put() self.flash("Barcamp aktualisiert", category="info") return redirect(self.url_for("barcamps.index", slug = self.barcamp.slug)) return self.render(form = form, barcamp = self.barcamp)
def get(self): """show the form for entering your email address. The form can be overwritten in the userbase module""" cfg = self.module.config mod = self.module form = cfg.pw_forgot_form(self.request.form) if self.request.method == 'POST': if form.validate(): f = form.data user = mod.get_user_by_email(f['email']) if user is not None: # send out pw forgot code and redirect to code sent success screen mod.send_pw_code(user) self.flash( self. _(u'A link to set a new password has been sent to you') % user) url_for_params = cfg.urls.pw_code_success url = self.url_for(**url_for_params) return redirect(url) else: self.flash( self._(u'The email address is not in our database.')) return self.render(form=form)
def get(self): """show the password set form""" cfg = self.module.config mod = self.module code = self.request.args.get("code", None) if self.request.method == 'POST': code = self.request.form.get("code", "") else: code = self.request.args.get("code", None) if code is not None: user = mod.get_user_by_activation_code(code) if user is not None: user.activate() mod.login(self, user=user, save=False) user.save() self.flash( self._("Your password has been successfully changed")) url_for_params = cfg.urls.activation_success url = self.url_for(**url_for_params) return redirect(url) else: url = self.url_for(endpoint=".activation_code") params = {'url': url, 'code': code} self.flash(self._("Your password change has failed" % params), category="danger") self.flash(cfg.messages.activation_failed % params, category="danger") return self.render()
def get(self, slug=None): """render the view""" obj = copy.copy(self.barcamp) form = LegalEditForm(self.request.form, obj=self.barcamp, config=self.config) if self.barcamp.paid_tickets: for field in form: form[field.name].validators.append(validators.Required()) else: for field in form: form[field.name].validators.append(validators.Optional()) if self.request.method == 'POST' and form.validate(): f = form.data # update it so we have the new data for comparison self.barcamp.update(f) self.barcamp.put() self.flash(self._("The barcamp has been updated."), category="info") return redirect( self.url_for("barcamps.legaledit", slug=self.barcamp.slug)) return self.render(form=form, bcid=str(self.barcamp._id))
def get(self, slug = None): """render the view""" form = ParticipantDataEditForm(self.request.form, config = self.config) registration_form = self.barcamp.registration_form if self.request.method == 'POST' and form.validate(): f = form.data f['name'] = unicode(uuid.uuid4()) # clean up choices new_choices = [] for c in f['choices'].split("\n"): choice = c.strip() if choice: new_choices.append((choice, choice)) # value and name are the same f['choices'] = new_choices self.barcamp.registration_form.append(f) self.barcamp.save() return redirect(self.url_for("barcamps.registration_form_editor", slug = self.barcamp.slug)) return self.render( view = self.barcamp_view, barcamp = self.barcamp, title = self.barcamp.name, form = form, fields = self.barcamp.registration_form, **self.barcamp )
def post(self, slug=None): """render the view""" barcamp_id = self.barcamp._id # delete pages self.config.dbs.pages._remove({'barcamp': unicode(self.barcamp._id)}) # delete sessions sessions = self.config.dbs.sessions._remove( {'barcamp_id': str(barcamp_id)}) # delete blog entries blogs = self.config.dbs.blog._remove({'barcamp': str(barcamp_id)}) # delete galleries galleries = self.config.dbs.galleries._remove( {'barcamp': str(barcamp_id)}) # delete participant data data = self.config.dbs.participant_data._remove( {'barcamp_id': str(barcamp_id)}) # delete tickets data = self.config.dbs.tickets._remove({'barcamp_id': str(barcamp_id)}) # delete user favs data = self.config.dbs.userfavs._remove( {'barcamp_id': str(barcamp_id)}) # delete barcamp self.barcamp.remove() self.flash( self._("The barcamp and all it's contents have been deleted!"), category="success") return redirect(self.url_for("index"))
def get(self): """show the password set form""" cfg = self.module.config mod = self.module code = self.request.args.get("code", None) if self.request.method == 'POST': code = self.request.form.get("code", "") else: code = self.request.args.get("code", None) if code is not None: user = mod.get_user_by_activation_code(code) if user is not None: user.activate() mod.login(self, user=user, save = False) user.save() self.flash(self._("Your password has been successfully changed")) url_for_params = cfg.urls.activation_success url = self.url_for(**url_for_params) return redirect(url) else: url = self.url_for(endpoint=".activation_code") params = {'url': url, 'code' : code} self.flash(self._("Your password change has failed" %params), category="danger") self.flash(cfg.messages.activation_failed %params, category="danger") return self.render()
def get(self, slug=None): """render the view""" tickets = self.config.dbs.tickets userbase = self.app.module_map.userbase ticket_classes = self.barcamp.ticketlist for tc in ticket_classes: for status in [ 'pending', 'confirmed', 'canceled', 'cancel_request' ]: tc[status] = tickets.get_tickets(barcamp_id=self.barcamp._id, ticketclass_id=tc._id, status=status) # compute users uids = [t.user_id for t in tc[status]] users = userbase.get_users_by_ids(uids) userdict = {} for user in users: userdict[str(user._id)] = user for ticket in tc[status]: ticket['user'] = userdict[ticket.user_id] # make sure we are supposed to be shown if not self.barcamp.ticketmode_enabled: self.flash(self._('Ticketing Mode not enabled.'), category="danger") return redirect( self.url_for("barcamps.admin_ticketeditor", slug=self.barcamp.slug)) return self.render(view=self.barcamp_view, barcamp=self.barcamp, ticket_classes=ticket_classes, title=self.barcamp.name)
def get(self, slug = None): """render the view""" tickets = self.config.dbs.tickets userbase = self.app.module_map.userbase ticket_classes = self.barcamp.ticketlist for tc in ticket_classes: for status in ['pending', 'confirmed', 'canceled', 'cancel_request']: tc[status] = tickets.get_tickets( barcamp_id = self.barcamp._id, ticketclass_id = tc._id, status = status) # compute users uids = [t.user_id for t in tc[status]] users = userbase.get_users_by_ids(uids) userdict = {} for user in users: userdict[str(user._id)] = user for ticket in tc[status]: ticket['user'] = userdict[ticket.user_id] # make sure we are supposed to be shown if not self.barcamp.ticketmode_enabled: self.flash(self._('Ticketing Mode not enabled.'), category="danger") return redirect(self.url_for("barcamps.admin_ticketeditor", slug = self.barcamp.slug)) return self.render( view = self.barcamp_view, barcamp = self.barcamp, ticket_classes = ticket_classes, title = self.barcamp.name)
def get(self): """render the view""" form = EMailForm(self.request.form, obj=self.user, config=self.config, app=self.app, handler=self) if self.request.method == "POST": if form.validate(): email = form.data['email'] # now save it temporarily and send an activation email code = self.user.set_new_email(email) activation_url = self.url_for("confirm_email", _full=True, _append=True, code=code) self.mail_text("emails/new_reply_to.txt", self._('Confirm your Reply-To address'), send_to=email, activation_url=activation_url) self.user.save() self.flash(self._( "Please check your inbox of the new email for a confirmation mail and confirm it" ), category="info") url = self.url_for("profile", username=self.user.username) return redirect(url) else: self.flash(self._("There have been errors in the form"), category="danger") return self.render(form=form, user=self.user)
def get(self): """render the view""" form = EditForm(self.request.form, obj=self.user, config=self.config, app=self.app, handler=self) if self.user.image: try: asset = self.app.module_map.uploader.get(self.user.image) image = self.url_for( "asset", asset_id=asset.variants['medium_user']._id) except: image = None else: image = None if self.request.method == "POST": if form.validate(): self.user.update(form.data) self.user.save() self.flash(self._("Your profile has been updated"), category="info") url = self.url_for("profile", username=self.user.username) return redirect(url) else: self.flash(self._("There have been errors in the form"), category="danger") return self.render(form=form, user=self.user, image=image)
def get(self): """show the login form""" cfg = self.module.config mod = self.module form = cfg.login_form obj_class = cfg.user_class langs = [getattr(self, 'LANGUAGE', 'en')] form = cfg.login_form(self.request.form, handler = self) if self.request.method == 'POST': if form.validate(): f = form.data try: remember = self.module.config.use_remember and self.request.form.get("remember") user = mod.login(self, **f) url_for_params = cfg.urls.login_success url = self.url_for(**url_for_params) self.flash(self._("Hello %(fullname)s, you are now logged in.") %user) return redirect(url) except PasswordIncorrect, e: log.warn("login failed: incorrect password", username = e.username) self.flash(self._("Invalid credentials. You might have mistyped something, please check your spelling."), category="danger") except UserUnknown, e: log.warn("login failed: unknown user", username = e.username) self.flash(self._("Invalid credentials. You might have mistyped something, please check your spelling."), category="danger") except UserNotActive, e: if cfg.use_double_opt_in: log.warn("login failed: user account not yet activated") self.flash(self._("""Your user account has not been activated. In order to receive a new activation email <a href="%s">click here</a>""") %self.url_for(".activation_code"), category="warning") else: log.warn("login failed: unknown error", user = user) self.flash(self._("Login failed, please try again."), category="danger")
def post(self, slug = None): """only a post without parameters is done to add.""" view = self.barcamp_view event = self.barcamp.event uid = unicode(self.user._id) if len(event.participants) >= self.barcamp.size: self.flash(self._("Unfortunately list of participants is already full. You have been put onto the waiting list and will be informed should you move on to the list of participants."), category="danger") if uid not in event.waiting_list: event.waiting_list.append(uid) self.barcamp.subscribers.remove(uid) self.barcamp.put() self.mail_text("emails/welcome.txt", self._('You are now on the waiting list for %s' %self.barcamp.name), view = view, barcamp = self.barcamp, title = self.barcamp.name, **self.barcamp) else: self.flash(self._("You are now on the list of participants for this barcamp."), category="success") if uid not in event.participants: event.participants.append(uid) if uid in self.barcamp.subscribers: self.barcamp.subscribers.remove(uid) self.barcamp.put() self.mail_text("emails/welcome.txt", self._('Welcome to %s' %self.barcamp.name), view = view, barcamp = self.barcamp, title = self.barcamp.name, **self.barcamp) return redirect(self.url_for("barcamp_userlist", slug = self.barcamp.slug))
def get(self, slug=None): """render the view""" form = ParticipantDataEditForm(self.request.form, config=self.config) registration_form = self.barcamp.registration_form if self.request.method == 'POST' and form.validate(): f = form.data f['name'] = unicode(uuid.uuid4()) # clean up choices new_choices = [] for c in f['choices'].split("\n"): choice = c.strip() if choice: new_choices.append( (choice, choice)) # value and name are the same f['choices'] = new_choices self.barcamp.registration_form.append(f) self.barcamp.save() return redirect( self.url_for("barcamps.registration_form_editor", slug=self.barcamp.slug)) return self.render(view=self.barcamp_view, barcamp=self.barcamp, title=self.barcamp.name, form=form, fields=self.barcamp.registration_form, **self.barcamp)
def get(self): """show the registration form""" cfg = self.module.config mod = self.module code = self.request.args.get("code", None) if self.request.method == 'POST': code = self.request.form.get("code", "") else: code = self.request.args.get("code", None) if code is not None: # TODO: check expiration time user = mod.get_user_by_activation_code(code) if user is not None: user.activate() mod.login(self, user=user, save = False) user.save() self.flash(self._("Your account has been successfully activated.") %user) url_for_params = cfg.urls.activation_success url = self.url_for(**url_for_params) return redirect(url) else: url = self.url_for(endpoint=".activation_code") params = {'url': url, 'code' : code} self.flash(self._("""The activation code is not valid. Please try again or click <a href="%(url)s">here</a> to get a new one.""") %params, category="danger") return self.render()
def get(self): """render the view""" form = BarcampAddForm(self.request.form, config = self.config) if self.request.method == 'POST' and form.validate(): f = form.data f['admins'] = [self.user._id] f['created_by'] = self.user._id f['subscribers'] = [self.user._id] f['location'] = { 'name' : f['location_name'], 'street' : f['location_street'], 'city' : f['location_city'], 'zip' : f['location_zip'], 'email' : f['location_email'], 'phone' : f['location_phone'], 'url' : f['location_url'], 'description' : f['location_description'], 'country' : 'de', } pid = unicode(uuid.uuid4())[:8] pid = f['planning_pad'] = "%s_%s" %(f['slug'],pid) did = f['slug'] try: self.config.etherpad.createPad(padID=pid, text=u"Planung") self.config.etherpad.createPad(padID=did, text=u"Dokumentation") except: self.flash(self._("Attention: One or both of the etherpads exist already!"), category="warning") pass f['documentation_pad'] = did # retrieve geo location if form.data['location_street']: url = "http://nominatim.openstreetmap.org/search?q=%s, %s&format=json&polygon=0&addressdetails=1" %( form.data['location_street'], form.data['location_city'], ) data = requests.get(url).json() if len(data)==0: # trying again but only with city url = "http://nominatim.openstreetmap.org/search?q=%s&format=json&polygon=0&addressdetails=1" %( form.data['location_city'], ) data = requests.get(url).json() if len(data)==0: self.flash(self._("the city was not found in the geo database"), category="danger") return self.render(form = form) # we have at least one entry, take the first one result = data[0] f['location']['lat'] = result['lat'] f['location']['lng'] = result['lon'] # create and save the barcamp object barcamp = db.Barcamp(f, collection = self.config.dbs.barcamps) barcamp = self.config.dbs.barcamps.put(barcamp) self.flash(self._("%s has been created") %f['name'], category="info") return redirect(self.url_for("index")) return self.render(form = form, slug = None)
def delete(self, slug = None): """delete a form entry""" idx = self.request.args.get("idx", None) rf = self.barcamp.registration_form if idx is not None and int(idx) < len(rf) and int(idx) >= 0: del self.barcamp.registration_form[int(idx)] self.barcamp.save() return redirect(self.url_for("barcamps.registration_form_editor", slug = self.barcamp.slug))
def get(self): """show the login form""" cfg = self.module.config self.module.logout(self) self.flash(self._(u"You are now logged out.")) url_for_params = cfg.urls.logout_success url = self.url_for(**url_for_params) return redirect(url)
def get(self, slug=None): """verify the reply to code and inform the user""" code = self.request.args.get("code", "") confirmed = self.user.verify_email_code(code) self.user.save() if confirmed: self.flash( self._('You have successfully changed your email address!'), category="info") return redirect( self.url_for("profile", username=self.user.username)) else: self.flash( self._('Unfortunately the code was wrong. Please try again!'), category="danger") return redirect(self.url_for("email_edit"))
def get(self, slug=None): """render the view""" obj = copy.copy(self.barcamp) obj['location_name'] = self.barcamp.location['name'] obj['location_street'] = self.barcamp.location['street'] obj['location_city'] = self.barcamp.location['city'] obj['location_zip'] = self.barcamp.location['zip'] obj['location_country'] = self.barcamp.location['country'] obj['location_email'] = self.barcamp.location['email'] obj['location_phone'] = self.barcamp.location['phone'] obj['location_url'] = self.barcamp.location['url'] obj['location_description'] = self.barcamp.location['description'] form = BarcampEditForm(self.request.form, obj=obj, config=self.config) if self.barcamp.public: del form['slug'] if self.request.method == 'POST' and form.validate(): f = form.data f['location'] = { 'name': f['location_name'], 'street': f['location_street'], 'city': f['location_city'], 'zip': f['location_zip'], 'email': f['location_email'], 'phone': f['location_phone'], 'url': f['location_url'], 'description': f['location_description'], 'country': 'de', } # do the nominatim request to find out lat/long but only if street and city have not changed if (form.data['location_street'] != self.barcamp.location['street'] or form.data['location_city'] != self.barcamp.location['city'] or form.data['location_zip'] != self.barcamp.location['zip']) or True: url = "http://nominatim.openstreetmap.org/search?q=%s, %s&format=json&polygon=0&addressdetails=1" % ( form.data['location_street'], form.data['location_city'], ) data = requests.get(url).json() if len(data) == 0: # trying again but only with city url = "http://nominatim.openstreetmap.org/search?q=%s&format=json&polygon=0&addressdetails=1" % ( form.data['location_city'], ) data = requests.get(url).json() if len(data) == 0: self.flash( self._("the city was not found in the geo database"), category="danger") return self.render(form=form) # we have at least one entry, take the first one result = data[0] f['location']['lat'] = result['lat'] f['location']['lng'] = result['lon'] self.barcamp.update(f) self.barcamp.put() self.flash("Barcamp aktualisiert", category="info") return redirect(self.url_for("barcamp", slug=self.barcamp.slug)) return self.render(form=form)
def delete(self, slug=None, page_slug=None): """delete a page""" self.page.remove() self.flash(self._(u"the page has been deleted")) if self.barcamp is not None: url = self.url_for("barcamps.index", slug=self.barcamp.slug) else: url = self.url_for("index") return redirect(url)
def post(self, slug=None): """set the visibility of the barcamp""" email = self.request.form.get("email") user = self.app.module_map.userbase.get_user_by_email(email) if user is None: self.flash( "Ein Benutzer mit dieser E-Mail-Adresse wurde leider nicht gefunden.", category="error") return redirect(self.url_for("barcamp_permissions", slug=slug)) uid = str(user._id) if uid not in self.barcamp.admins: self.barcamp.add_admin(user) self.barcamp.save() self.flash(u"%s ist nun ebenfalls ein Admin für dieses Barcamp." % user.fullname) return redirect(self.url_for("barcamp_permissions", slug=slug))
def delete(self, slug = None, page_slug = None): """delete a page""" self.page.remove() self.flash(self._(u"the page has been deleted")) if self.barcamp is not None: url = self.url_for("barcamps.index", slug = self.barcamp.slug) else: url = self.url_for("index") return redirect(url)
def post(self, slug = None): """set the workflow state for the barcamp""" try: self.barcamp.set_workflow(self.request.form.get("wf","")) self.barcamp.save() except WorkflowError, e: print e self.flash(self._("you cannot perform this action."), category="error") return redirect(self.url_for(".admin_wizard", slug=slug))
def get(self, slug=None): """render the view""" form = DuplicateForm(self.request.form, config=self.config) slugify = UniqueSlugify(separator='_', max_length=50, to_lower=True) if self.request.method == 'POST' and form.validate(): f = form.data # as a test just copy everything by just changing the existing camp self.barcamp.name = self._("Copy of ") + self.barcamp.name new_slug = slugify(self.barcamp.name) while self.config.dbs.barcamps.by_slug(new_slug): new_slug = new_slug + "_1" self.barcamp.slug = new_slug self.barcamp.workflow = "created" self.barcamp.registration_data = {} # either delete all events or just the people if "events" not in self.request.form: self.barcamp.events = {} else: for eid, event in self.barcamp.events.items(): event['participants'] = [] event['maybe'] = [] event['waiting_list'] = [] event['timetable']['sessions'] = {} self.barcamp.events[eid] = event # delete ticket classes if switched off if "tickets" not in self.request.form: self.barcamp.ticket_classes = [] else: # if events are deleted we need to delete them from the tickets, too if "events" not in self.request.form: new_tcs = [] for tc in self.barcamp.ticket_classes: tc['events'] = [] new_tcs.append(tc) self.barcamp.ticket_classes = new_tcs # create new pad uids self.barcamp.planning_pad = unicode(uuid.uuid4()) self.barcamp.documentation_pad = unicode(uuid.uuid4()) # make it a new one self.barcamp['_id'] = ObjectId() barcamp = self.config.dbs.barcamps.put(self.barcamp) self.flash(self._("The barcamp has been duplicated."), category="info") return redirect( self.url_for("barcamps.edit", slug=self.barcamp.slug)) return self.render(form=form)
def delete(self, slug=None): """delete a form entry""" idx = self.request.args.get("idx", None) rf = self.barcamp.registration_form if idx is not None and int(idx) < len(rf) and int(idx) >= 0: del self.barcamp.registration_form[int(idx)] self.barcamp.save() return redirect( self.url_for("barcamps.registration_form_editor", slug=self.barcamp.slug))
def delete(self, slug = None, page_slug = None): """delete a page""" # TODO: delete page self.page.remove() self.flash(u"Die Seite wurde erfolgreich gelöscht") if self.barcamp is not None: url = self.url_for("barcamp", slug = self.barcamp.slug) else: url = self.url_for("index") return redirect(url)
def get(self): """show the form for entering a new password.""" cfg = self.module.config mod = self.module # check pw code which comes via URL code = self.request.args.get("code", None) if code is None: self.flash( "The URL is missing a code for the password reset. Please enter the email address you registered with to receive a proper link", category="danger") url = self.url_for("userbase.pw_forgot") return redirect(url) user = mod.get_user_by_pw_code(code) if user is None: self.flash( "We couldn't find a user with that code, please try again", category="danger") url = self.url_for("userbase.pw_forgot") return redirect(url) # check for expiration time if user.pw_code_expires < datetime.datetime.now(): self.flash("The code has expired, please try again", category="danger") url = self.url_for("userbase.pw_forgot") return redirect(url) form = cfg.pw_change_form(self.request.form) if self.request.method == 'POST': if form.validate(): f = form.data # send out pw forgot code and redirect to code sent success screen user.password = f['password'] user.pw_code = None user.save() self.flash(self._(u'Your password has been changed') % user) url_for_params = cfg.urls.pw_code_success url = self.url_for(**url_for_params) return redirect(url) return self.render(form=form, code=code)