def _process(self): regforms = RegistrationForm.find_all( RegistrationForm.publish_registrations_enabled, event_id=int(self.event.id)) query = (Registration.find( Registration.event_id == self.event.id, RegistrationForm.publish_registrations_enabled, ~RegistrationForm.is_deleted, ~Registration.is_deleted, _join=Registration.registration_form).order_by( db.func.lower(Registration.last_name), db.func.lower(Registration.first_name))) registrations = [(reg.get_full_name(), reg.get_personal_data()) for reg in query] enabled_pd_fields = { field.personal_data_type for reg in regforms for field in reg.active_fields } affiliation_enabled = PersonalDataType.affiliation in enabled_pd_fields position_enabled = PersonalDataType.position in enabled_pd_fields published = bool( RegistrationForm.find( RegistrationForm.publish_registrations_enabled, RegistrationForm.event_id == int(self.event.id)).count()) return self.view_class.render_template( 'display/participant_list.html', self.event, event=self.event, regforms=regforms, show_affiliation=affiliation_enabled and any(pd.get('affiliation') for reg, pd in registrations), show_position=position_enabled and any(pd.get('position') for reg, pd in registrations), registrations=registrations, published=published)
def _process(self): regforms = RegistrationForm.find_all(RegistrationForm.publish_registrations_enabled, event_id=int(self.event.id)) query = (Registration .find(Registration.event_id == self.event.id, Registration.state == RegistrationState.complete, RegistrationForm.publish_registrations_enabled, ~RegistrationForm.is_deleted, ~Registration.is_deleted, _join=Registration.registration_form) .order_by(db.func.lower(Registration.last_name), db.func.lower(Registration.first_name))) registrations = [(reg.get_full_name(), reg.get_personal_data()) for reg in query] enabled_pd_fields = {field.personal_data_type for reg in regforms for field in reg.active_fields} affiliation_enabled = PersonalDataType.affiliation in enabled_pd_fields position_enabled = PersonalDataType.position in enabled_pd_fields published = bool(RegistrationForm.find(RegistrationForm.publish_registrations_enabled, RegistrationForm.event_id == int(self.event.id)).count()) return self.view_class.render_template( 'display/participant_list.html', self.event, event=self.event, regforms=regforms, show_affiliation=affiliation_enabled and any(pd.get('affiliation') for reg, pd in registrations), show_position=position_enabled and any(pd.get('position') for reg, pd in registrations), registrations=registrations, published=published )
def _process(self): participant_visibility = (PublishRegistrationsMode.hide_all if self.event.type_ == EventType.conference else PublishRegistrationsMode.show_all) public_visibility = PublishRegistrationsMode.hide_all form = RegistrationFormCreateForm(event=self.event, visibility=[participant_visibility.name, public_visibility.name, None]) if form.validate_on_submit(): regform = RegistrationForm(event=self.event, currency=payment_settings.get('currency')) create_personal_data_fields(regform) form.populate_obj(regform, skip=['visibility']) participant_visibility, public_visibility, visibility_duration = form.visibility.data regform.publish_registrations_participants = PublishRegistrationsMode[participant_visibility] regform.publish_registrations_public = PublishRegistrationsMode[public_visibility] regform.publish_registrations_duration = (timedelta(days=visibility_duration*30) if visibility_duration is not None else None) db.session.add(regform) db.session.flush() signals.event.registration_form_created.send(regform) flash(_('Registration form has been successfully created'), 'success') self.event.log(EventLogRealm.management, LogKind.positive, 'Registration', f'Registration form "{regform.title}" has been created', session.user) return redirect(url_for('.manage_regform', regform)) return WPManageRegistration.render_template('management/regform_create.html', self.event, form=form, regform=None)
def _process(self): regform = self.event.participation_regform registration_enabled = self.event.has_feature('registration') participant_visibility = (PublishRegistrationsMode.show_with_consent if self.event.type_ == EventType.lecture else PublishRegistrationsMode.show_all) public_visibility = (PublishRegistrationsMode.show_with_consent if self.event.type_ == EventType.lecture else PublishRegistrationsMode.show_all) form = RegistrationFormCreateForm(title='Participants', visibility=[participant_visibility.name, public_visibility.name, None]) if form.validate_on_submit(): set_feature_enabled(self.event, 'registration', True) if not regform: regform = RegistrationForm(event=self.event, is_participation=True, currency=payment_settings.get('currency')) create_personal_data_fields(regform) form.populate_obj(regform, skip=['visibility']) participant_visibility, public_visibility, visibility_duration = form.visibility.data regform.publish_registrations_participants = PublishRegistrationsMode[participant_visibility] regform.publish_registrations_public = PublishRegistrationsMode[public_visibility] regform.publish_registrations_duration = (timedelta(days=visibility_duration*30) if visibility_duration is not None else None) db.session.add(regform) db.session.flush() signals.event.registration_form_created.send(regform) self.event.log(EventLogRealm.management, LogKind.positive, 'Registration', f'Registration form "{regform.title}" has been created', session.user) return redirect(url_for('event_registration.manage_regform', regform)) if not regform or not registration_enabled: return WPManageParticipants.render_template('management/participants.html', self.event, form=form, regform=regform, registration_enabled=registration_enabled) return redirect(url_for('event_registration.manage_regform', regform))
def migrate_regforms(self): try: self.old_participation = self.conf._participation except AttributeError: self.print_info('Event has no participation') return if not self.old_participation._participantList and not self.old_participation._pendingParticipantList: self.print_info('Participant lists are empty') return set_feature_enabled(self.event, 'registration', True) with db.session.no_autoflush: self.regform = RegistrationForm( event_id=self.event.id, title=PARTICIPATION_FORM_TITLE, is_participation=True, currency=payment_settings.get('currency')) if not self.quiet: self.print_success('%[cyan]{}'.format(self.regform.title)) self._migrate_settings() self._create_form() self._migrate_participants() db.session.add(self.regform) db.session.flush()
def _get_open_regforms(event): if not event.has_feature('registration'): return [] from indico.modules.events.registration.models.forms import RegistrationForm return (RegistrationForm.find(RegistrationForm.is_open, event_id=int(event.id)) .order_by(db.func.lower(RegistrationForm.title)) .all())
def _process(self): regforms = (self.event_new.registration_forms .filter(RegistrationForm.publish_registrations_enabled, ~RegistrationForm.is_deleted) .options(subqueryload('registrations').subqueryload('data').joinedload('field_data')) .all()) if registration_settings.get(self.event, 'merge_registration_forms'): tables = [self._merged_participant_list_table()] else: tables = [] regforms_dict = {regform.id: regform for regform in regforms if regform.publish_registrations_enabled} for form_id in registration_settings.get_participant_list_form_ids(self.event): try: regform = regforms_dict.pop(form_id) except KeyError: # The settings might reference forms that are not available # anymore (publishing was disabled, etc.) continue tables.append(self._participant_list_table(regform)) # There might be forms that have not been sorted by the user yet tables += map(self._participant_list_table, regforms_dict.viewvalues()) published = bool(RegistrationForm.find(RegistrationForm.publish_registrations_enabled, RegistrationForm.event_id == int(self.event.id)).count()) num_participants = sum(len(table['rows']) for table in tables) return self.view_class.render_template( 'display/participant_list.html', self.event, event=self.event, regforms=regforms, tables=tables, published=published, num_participants=num_participants )
def _process(self): regforms = (RegistrationForm.query.with_parent(self.event) .filter(RegistrationForm.is_participant_list_visible(self.event.is_user_registered(session.user))) .options(subqueryload('registrations').subqueryload('data').joinedload('field_data')) .all()) if registration_settings.get(self.event, 'merge_registration_forms'): tables = [self._merged_participant_list_table()] else: tables = [] regforms_dict = {regform.id: regform for regform in regforms} for form_id in registration_settings.get_participant_list_form_ids(self.event): try: regform = regforms_dict.pop(form_id) except KeyError: # The settings might reference forms that are not available # anymore (publishing was disabled, etc.) continue tables.append(self._participant_list_table(regform)) # There might be forms that have not been sorted by the user yet tables.extend(map(self._participant_list_table, regforms_dict.values())) num_participants = sum(table['num_participants'] for table in tables) return self.view_class.render_template( 'display/participant_list.html', self.event, tables=tables, published=bool(regforms), num_participants=num_participants )
def _process(self): form = RegistrationFormForm( event=self.event, publish_registrations_enabled=(self.event.type_ != EventType.conference)) if form.validate_on_submit(): regform = RegistrationForm(event=self.event) create_personal_data_fields(regform) form.populate_obj(regform) db.session.add(regform) db.session.flush() signals.event.registration_form_created.send(regform) flash(_('Registration form has been successfully created'), 'success') self.event.log( EventLogRealm.management, EventLogKind.positive, 'Registration', 'Registration form "{}" has been created'.format( regform.title), session.user) return redirect(url_for('.manage_regform', regform)) return WPManageRegistration.render_template( 'management/regform_edit.html', self.event, form=form, regform=None)
def _get_open_regforms(event): if not event.has_feature('registration'): return [] from indico.modules.events.registration.models.forms import RegistrationForm return (RegistrationForm.find(RegistrationForm.is_open, event_id=int(event.id)) .order_by(db.func.lower(RegistrationForm.title)) .all())
def _form_validated(self, form, **kwargs): """ Forbid to disable the tickets when access to CERN is requested and to use CERN access ticket template with regforms without active CERN access request. """ if not isinstance(form, TicketsForm): return regform = RegistrationForm.get_one(request.view_args['reg_form_id']) if regform.cern_access_request and regform.cern_access_request.is_active and form.tickets_enabled.data is False: err = _( 'This form is used to grant CERN site access so ticketing must be enabled' ) form.tickets_enabled.errors.append(err) return False access_tpl = self.settings.get('access_ticket_template') ticket_template = DesignerTemplate.get_one( form.ticket_template_id.data) if not access_tpl: return if ticket_template == access_tpl or ticket_template.backside_template == access_tpl: if (not regform.cern_access_request or (regform.cern_access_request and regform.cern_access_request.request_state != CERNAccessRequestState.active)): form.ticket_template_id.errors.append( _('The selected template can only be used with an ' 'active CERN access request')) return False
def dummy_regform(dummy_event, db): # event has to be in the future (badge request) dummy_event.start_dt += timedelta(days=1) dummy_event.end_dt += timedelta(days=1) regform = RegistrationForm(event=dummy_event, title="Dummy Registration Form", currency="CHF") create_personal_data_fields(regform) db.session.flush() return regform
def _visible_participant_list(event): if not event.has_feature('registration'): return False if not (RegistrationForm.query.with_parent(event) .filter(RegistrationForm.is_participant_list_visible(event.is_user_registered(session.user))) .has_rows()): return False return not any(values_from_signal(signals.event.hide_participant_list.send(event)))
def dummy_regform(db, dummy_event): regform = RegistrationForm(event=dummy_event, title='Registration Form', currency='USD') create_personal_data_fields(regform) # enable all fields for field in regform.sections[0].fields: field.is_enabled = True db.session.add(regform) db.session.flush() return regform
def run(self): self.regform = RegistrationForm(event_id=int(self.event.id), title=PARTICIPATION_FORM_TITLE, is_participation=True) if not self.importer.quiet: self.importer.print_success(cformat('%{cyan}{}').format( self.regform.title), event_id=self.event.id) self._migrate_settings() self._create_form() self._migrate_participants()
def _visible_registration(event): if not event.has_feature('registration'): return False if RegistrationForm.find(RegistrationForm.is_scheduled, RegistrationForm.event_id == int(event.id)).count(): return True if not session.user: return False return bool(Registration.find(Registration.user == session.user, Registration.event_id == int(event.id), ~Registration.is_deleted, ~RegistrationForm.is_deleted, _join=Registration.registration_form).count())
def _process_POST(self): regform = self.event_new.participation_regform set_feature_enabled(self.event_new, 'registration', True) if not regform: regform = RegistrationForm(event_new=self.event_new, title="Participants", is_participation=True, currency=payment_settings.get('currency')) create_personal_data_fields(regform) db.session.add(regform) db.session.flush() signals.event.registration_form_created.send(regform) self.event_new.log(EventLogRealm.management, EventLogKind.positive, 'Registration', 'Registration form "{}" has been created'.format(regform.title), session.user) return redirect(url_for('event_registration.manage_regform', regform))
def count_hidden_registrations(event, is_participant): """Get the number of hidden registrations for an event. :param event: the `Event` to get registrations for :param is_participant: whether the user accessing the registrations is a participant of the event :return: number of registrations """ query = (Registration.query.with_parent(event).filter( Registration.is_state_publishable, ~Registration.is_publishable(is_participant), RegistrationForm.is_participant_list_visible(is_participant)).join( Registration.registration_form)) return query.count()
def _visible_registration(event): if not event.has_feature('registration'): return False if RegistrationForm.find(RegistrationForm.is_scheduled, RegistrationForm.event_id == int( event.id)).count(): return True if not session.user: return False return bool( Registration.find(Registration.user == session.user, Registration.event_id == int(event.id), ~Registration.is_deleted, ~RegistrationForm.is_deleted, _join=Registration.registration_form).count())
def run(self, new_event, cloners, shared_data): # if the registration cloner is also enabled, we have to keep # all revisions since they are likely to be in use clone_all_revisions = 'registrations' in cloners attrs = get_simple_column_attrs(RegistrationForm) - {'start_dt', 'end_dt', 'modification_end_dt'} self._field_data_map = {} self._form_map = {} for old_form in self.old_event.registration_forms: new_form = RegistrationForm(**{attr: getattr(old_form, attr) for attr in attrs}) self._clone_form_items(old_form, new_form, clone_all_revisions) new_event.registration_forms.append(new_form) db.session.flush() self._form_map[old_form] = new_form return {'form_map': self._form_map, 'field_data_map': self._field_data_map}
def clone(self, new_event, options): if not options: return self._clone_with_registrations = 'registrations' in options attrs = get_simple_column_attrs(RegistrationForm) - { 'start_dt', 'end_dt', 'modification_end_dt' } with db.session.no_autoflush: for old_form in self._find_registration_forms(): new_form = RegistrationForm( event_new=new_event.as_event, **{attr: getattr(old_form, attr) for attr in attrs}) self._clone_form_items(old_form, new_form) if self._clone_with_registrations: self._clone_registrations(old_form, new_form, new_event) db.session.add(new_form) db.session.flush()
def _process(self): regforms = (self.event_new.registration_forms.filter( RegistrationForm.publish_registrations_enabled, ~RegistrationForm.is_deleted).options( subqueryload('registrations').subqueryload('data').joinedload( 'field_data')).all()) if registration_settings.get(self.event, 'merge_registration_forms'): tables = [self._merged_participant_list_table()] else: tables = [] regforms_dict = { regform.id: regform for regform in regforms if regform.publish_registrations_enabled } for form_id in registration_settings.get_participant_list_form_ids( self.event): try: regform = regforms_dict.pop(form_id) except KeyError: # The settings might reference forms that are not available # anymore (publishing was disabled, etc.) continue tables.append(self._participant_list_table(regform)) # There might be forms that have not been sorted by the user yet tables += map(self._participant_list_table, regforms_dict.viewvalues()) published = bool( RegistrationForm.find( RegistrationForm.publish_registrations_enabled, RegistrationForm.event_id == int(self.event.id)).count()) num_participants = sum(len(table['rows']) for table in tables) return self.view_class.render_template( 'display/participant_list.html', self.event, event=self.event, regforms=regforms, tables=tables, published=published, num_participants=num_participants)
def _process(self): regforms = RegistrationForm.find_all(RegistrationForm.publish_registrations_enabled, event_id=int(self.event.id)) query = (Registration .find(Registration.event_id == self.event.id, RegistrationForm.publish_registrations_enabled, ~RegistrationForm.is_deleted, ~Registration.is_deleted, _join=Registration.registration_form) .order_by(db.func.lower(Registration.last_name), db.func.lower(Registration.first_name))) registrations = [(reg.get_full_name(), reg.get_personal_data()) for reg in query] return self.view_class.render_template( 'display/participant_list.html', self.event, event=self.event, regforms=regforms, show_affiliation=any(pd.get('affiliation') for reg, pd in registrations), show_position=any(pd.get('position') for reg, pd in registrations), registrations=registrations )
def has_data(self): return RegistrationForm.find(title=PARTICIPATION_FORM_TITLE).has_rows()
def test_filter_contrib_entries(app, db, dummy_event, create_user, create_contribution, create_registration): registered_user = create_user(1) registered_speaker = create_user(2) unregistered_user = create_user(3) dummy_regform = RegistrationForm(event=dummy_event, title='Registration Form', currency='USD') dummy_event.registrations.append( create_registration(registered_user, dummy_regform)) dummy_event.registrations.append( create_registration(registered_speaker, dummy_regform)) registered_speaker_contribution = create_contribution( dummy_event, 'Registered Speaker', person_links=[ ContributionPersonLink(person=EventPerson.create_from_user( registered_speaker, dummy_event), is_speaker=True) ]) registered_speaker_author_contribution = create_contribution( dummy_event, 'Registered Speaker Author', person_links=[ ContributionPersonLink(person=EventPerson.for_user( registered_speaker, dummy_event), is_speaker=True, author_type=AuthorType.primary) ]) unregistered_speaker_registered_author_contribution = create_contribution( dummy_event, 'Unregistered Speaker, Registered Author', person_links=[ ContributionPersonLink(person=EventPerson.for_user( unregistered_user, dummy_event), is_speaker=True), ContributionPersonLink(person=EventPerson.for_user( registered_user, dummy_event), author_type=AuthorType.primary) ]) registered_speaker_unregistered_author_contribution = create_contribution( dummy_event, 'Registered Speaker, Unregistered Author', person_links=[ ContributionPersonLink(person=EventPerson.for_user( registered_user, dummy_event), is_speaker=True), ContributionPersonLink(person=EventPerson.for_user( unregistered_user, dummy_event), author_type=AuthorType.primary) ]) # Filter contributions with registered users with app.test_request_context(): list_gen = ContributionListGenerator(dummy_event) list_gen.list_config['filters'] = {'items': {'people': {'registered'}}} result = list_gen.get_list_kwargs() assert result['contribs'] == [ registered_speaker_contribution, registered_speaker_author_contribution, unregistered_speaker_registered_author_contribution, registered_speaker_unregistered_author_contribution ] # Filter contributions with registered speakers list_gen.list_config['filters'] = {'items': {'speakers': {'registered'}}} with app.test_request_context(): result = list_gen.get_list_kwargs() assert result['contribs'] == [ registered_speaker_contribution, registered_speaker_author_contribution, registered_speaker_unregistered_author_contribution ] # Filter contributions with unregistered speakers and registered users list_gen.list_config['filters'] = { 'items': { 'speakers': {'not_registered'}, 'people': {'registered'} } } with app.test_request_context(): result = list_gen.get_list_kwargs() assert result['contribs'] == [ unregistered_speaker_registered_author_contribution ]
def _find_registration_forms(self): return RegistrationForm.find(~RegistrationForm.is_deleted, RegistrationForm.event_id == int(self.event.id))
def has_data(self): return bool( RegistrationForm.find(title=PARTICIPATION_FORM_TITLE).count())
def has_data(self): return RegistrationForm.find(title=PARTICIPATION_FORM_TITLE).has_rows()
def _checkParams(self): self.regform = ( RegistrationForm.find(id=request.view_args["reg_form_id"], is_deleted=False) .options(defaultload("form_items").joinedload("children").joinedload("current_data")) .one() )
def _find_registration_forms(self): return RegistrationForm.find( ~RegistrationForm.is_deleted, RegistrationForm.event_id == int(self.event.id))
else: category_role = CategoryRole.get_category_role_by_id( category, category_role_id) if category_role is None: raise ValueError(f'Invalid category role: {category_role_id}') return category_role elif type_ == 'RegistrationForm': if not allow_registration_forms: raise ValueError('Registration forms are not allowed') try: reg_form_id = int(data) except ValueError: raise ValueError('Invalid data') registration_form = RegistrationForm.get( reg_form_id, is_deleted=(None if soft_fail else False)) if registration_form is None or registration_form.event_id != event_id: raise ValueError(f'Invalid registration form: {reg_form_id}') return registration_form elif type_ == 'Email': if not allow_emails: raise ValueError('Emails are not allowed') return EmailPrincipal(data) elif type_ == 'IPNetworkGroup': if not allow_networks: raise ValueError('Network groups are not allowed') try: netgroup_id = int(data) except ValueError: raise ValueError('Invalid data') netgroup = IPNetworkGroup.get(netgroup_id)
def has_data(self): return bool(RegistrationForm.find(title=PARTICIPATION_FORM_TITLE).count())
def _visible_participant_list(event): if not event.has_feature('registration'): return False return bool(RegistrationForm.find(RegistrationForm.publish_registrations_enabled, RegistrationForm.event_id == int(event.id)).count())
def principal_from_fossil(fossil, allow_pending=False, allow_groups=True, allow_missing_groups=False, allow_emails=False, allow_networks=False, allow_registration_forms=False, existing_data=None, event=None, category=None): from indico.modules.networks.models.networks import IPNetworkGroup from indico.modules.events.models.roles import EventRole from indico.modules.categories.models.roles import CategoryRole from indico.modules.events.registration.models.forms import RegistrationForm from indico.modules.groups import GroupProxy from indico.modules.users import User if event and category is None: category = event.category if existing_data is None: existing_data = set() type_ = fossil['_type'] id_ = fossil['id'] if type_ == 'Avatar': if isinstance(id_, int) or id_.isdigit(): # regular user user = User.get(int(id_)) elif allow_pending: data = GenericCache('pending_identities').get(id_) if not data: raise ValueError("Cannot find user '{}' in cache".format(id_)) data = {k: '' if v is None else v for k, v in data.items()} email = data['email'].lower() # check if there is not already a (pending) user with that e-mail # we need to check for non-pending users too since the search may # show a user from external results even though the email belongs # to an indico account in case some of the search criteria did not # match the indico account user = User.query.filter(User.all_emails == email, ~User.is_deleted).first() if not user: user = User(first_name=data.get('first_name') or '', last_name=data.get('last_name') or '', email=email, address=data.get('address', ''), phone=data.get('phone', ''), affiliation=data.get('affiliation', ''), is_pending=True) db.session.add(user) db.session.flush() else: raise ValueError("Id '{}' is not a number and allow_pending=False".format(id_)) if user is None: raise ValueError('User does not exist: {}'.format(id_)) return user elif allow_emails and type_ == 'Email': return EmailPrincipal(id_) elif allow_networks and type_ == 'IPNetworkGroup': group = IPNetworkGroup.get(int(id_)) if group is None or (group.hidden and group not in existing_data): raise ValueError('IP network group does not exist: {}'.format(id_)) return group elif allow_groups and type_ in {'LocalGroupWrapper', 'LocalGroup'}: group = GroupProxy(int(id_)) if group.group is None: raise ValueError('Local group does not exist: {}'.format(id_)) return group elif allow_groups and type_ in {'LDAPGroupWrapper', 'MultipassGroup'}: provider = fossil['provider'] group = GroupProxy(id_, provider) if group.group is None and not allow_missing_groups: raise ValueError('Multipass group does not exist: {}:{}'.format(provider, id_)) return group elif category and type_ == 'CategoryRole': role = CategoryRole.get_category_role_by_id(category, id_) role_name = fossil.get('name') if role is None: raise ValueError('Category role "{}" is not available in "{}"'.format(role_name, category.title)) return role elif event and type_ == 'EventRole': role = EventRole.get(id_) role_name = fossil.get('name') if role is None: raise ValueError('Event role "{}" does not exist'.format(role_name)) if role.event != event: raise ValueError('Event role "{}" does not belong to "{}"'.format(role_name, event.title)) return role elif allow_registration_forms and type_ == 'RegistrationForm': registration_form = RegistrationForm.get(id_) reg_form_name = fossil.get('title') if registration_form is None: raise ValueError('Registration form "{}" does not exist'.format(reg_form_name)) if registration_form.event != event: raise ValueError('Registration form "{}" does not belong to "{}"'.format(reg_form_name, event.title)) return registration_form else: raise ValueError('Unexpected fossil type: {}'.format(type_))
def principal_from_identifier(identifier, allow_groups=False, allow_external_users=False, allow_event_roles=False, allow_category_roles=False, allow_registration_forms=False, allow_emails=False, event_id=None, soft_fail=False): from indico.modules.events.models.events import Event from indico.modules.events.models.roles import EventRole from indico.modules.categories.models.roles import CategoryRole from indico.modules.events.registration.models.forms import RegistrationForm from indico.modules.groups import GroupProxy from indico.modules.users import User try: type_, data = identifier.split(':', 1) except ValueError: raise ValueError('Invalid data') if type_ == 'User': try: user_id = int(data) except ValueError: raise ValueError('Invalid data') user = User.get(user_id, is_deleted=(None if soft_fail else False)) if user is None: raise ValueError('Invalid user: {}'.format(user_id)) return user elif type_ == 'ExternalUser': if not allow_external_users: raise ValueError('External users are not allowed') cache = GenericCache('external-user') external_user_data = cache.get(data) if not external_user_data: raise ValueError('Invalid data') user = User.query.filter(User.all_emails == external_user_data['email'], ~User.is_deleted).first() if user: return user # create a pending user. this user isn't sent to the DB unless it gets added # to the sqlalchemy session somehow (e.g. by adding it to an ACL). # like this processing form data does not result in something being stored in # the database, which is good! return User(first_name=external_user_data['first_name'], last_name=external_user_data['last_name'], email=external_user_data['email'], affiliation=external_user_data['affiliation'], address=external_user_data['address'], phone=external_user_data['phone'], is_pending=True) elif type_ == 'Group': if not allow_groups: raise ValueError('Groups are not allowed') try: provider, name = data.split(':', 1) except ValueError: raise ValueError('Invalid data') if not provider: # local group try: group_id = int(name) except ValueError: raise ValueError('Invalid data') group = GroupProxy(group_id) else: # multipass group group = GroupProxy(name, provider) if not soft_fail and group.group is None: raise ValueError('Invalid group: {}'.format(data)) return group elif type_ == 'EventRole': if not allow_event_roles: raise ValueError('Event roles are not allowed') try: event_role_id = int(data) except ValueError: raise ValueError('Invalid data') event_role = EventRole.get(event_role_id) if event_role is None or event_role.event_id != event_id: raise ValueError('Invalid event role: {}'.format(event_role_id)) return event_role elif type_ == 'CategoryRole': if not allow_category_roles: raise ValueError('Category roles are not allowed') event = Event.get(event_id) if event is None: raise ValueError('Invalid event id: {}'.format(event_id)) try: category_role_id = int(data) except ValueError: raise ValueError('Invalid data') if soft_fail: category_role = CategoryRole.get(category_role_id) else: category_role = CategoryRole.get_category_role_by_id(event.category, category_role_id) if category_role is None: raise ValueError('Invalid category role: {}'.format(category_role_id)) return category_role elif type_ == 'RegistrationForm': if not allow_registration_forms: raise ValueError('Registration forms are not allowed') try: reg_form_id = int(data) except ValueError: raise ValueError('Invalid data') registration_form = RegistrationForm.get(reg_form_id, is_deleted=(None if soft_fail else False)) if registration_form is None or registration_form.event_id != event_id: raise ValueError('Invalid registration form: {}'.format(reg_form_id)) return registration_form elif type_ == 'Email': if not allow_emails: raise ValueError('Emails are not allowed') return EmailPrincipal(data) else: raise ValueError('Invalid data')