Example #1
0
    def getVars(self):
        wvars = WTemplated.getVars(self)
        wvars['standalone'] = self._standalone
        room = wvars['room']

        wvars['attrs'] = {attr.attribute.name: attr for attr in room.attributes
                          if not attr.attribute.is_hidden or rb_is_admin(session.user)}

        wvars['owner_name'] = room.owner.full_name

        wvars['bookable_hours'] = room.bookable_hours.all()
        wvars['nonbookable_periods'] = room.nonbookable_periods.all()

        # URLs
        wvars['stats_url'] = UH.UHRoomBookingRoomStats.getURL(room)
        wvars['delete_room_url'] = url_for('rooms_admin.delete_room', room)
        wvars['modify_room_url'] = url_for('rooms_admin.modify_room', room)
        if not self._standalone:
            wvars['conference'] = self._rh._conf

        room_mapper = RoomMapperHolder().match({'placeName': self._rh._location.name}, exact=True)
        if room_mapper:
            wvars['show_on_map'] = room_mapper[0].getMapURL(self._rh._room.name)
        else:
            wvars['show_on_map'] = UH.UHRoomBookingMapOfRooms.getURL(roomID=self._rh._room.id)

        return wvars
Example #2
0
    def _process(self):
        if self._getUser() is not None and self._getUser().isRegisteredInConf(self._conf):
            if (
                not self._conf.getRegistrationForm().inRegistrationPeriod()
                and not self._conf.getRegistrationForm().inModificationPeriod()
            ):
                flash(_("Your modification could not be recorded since the modification period is over."), "error")
                return redirect(url_for("event.confRegistrationFormDisplay", self._conf))
            else:
                rp = self._getUser().getRegistrantById(self._conf.getId())

                # Check if the email matches an existing user
                params = self._getRequestParams()
                email = self._regForm.getPersonalData().getValueFromParams(params, "email") or ""
                user = get_user_by_email(email)
                if user:
                    if not session.user:
                        flash(
                            _(
                                "The provided email ({email}) is linked to an Indico account. Please sign in with it "
                                "first."
                            ).format(email=email),
                            "error",
                        )
                        return redirect(url_for("event.confRegistrationFormDisplay-modify", self._conf))
                    elif session.user != user:
                        flash(
                            _(
                                "The provided email ({email}) is linked to another Indico account. Please sign in with "
                                "it first."
                            ).format(email=email),
                            "error",
                        )
                        return redirect(url_for("event.confRegistrationFormDisplay-modify", self._conf))

                # check if the email is being changed by another one that already exists
                if email != rp.getEmail() and self._conf.hasRegistrantByEmail(email):
                    raise FormValuesError(
                        _('There is already a user with the email "{email}". ' "Please choose another one.").format(
                            email or "--no email--"
                        )
                    )
                rp.setValues(self._getRequestParams(), self._getUser())
                log_msg = u"User modified his registration data: {}"
                self._conf.log(
                    EventLogRealm.participants,
                    EventLogKind.positive,
                    u"Registration",
                    log_msg.format(to_unicode(rp.getFullName(title=False, firstNameFirst=True))),
                    session.user,
                    data={u"Indico user": u"{} ({})".format(user.full_name, user.id) if user else u"None"},
                )
                notify_registration_modification(self._conf, rp)
                flash(_(u"Your registration has been modified successfully."), "success")
                if rp.doPay():
                    self._redirect(urlHandlers.UHConfRegistrationFormCreationDone.getURL(rp))
                else:
                    self._redirect(urlHandlers.UHConfRegistrationForm.getURL(self._conf))
        else:
            self._redirect(urlHandlers.UHConfRegistrationForm.getURL(self._conf))
Example #3
0
def notify_payment_confirmation(registrant, amount):
    event = registrant.getConference()
    reg_form = registrant.getRegistrationForm()
    from_address = reg_form.getNotificationSender()
    currency = payment_event_settings.get(event, 'currency')

    # Send email to organizers
    notification = reg_form.getNotification()
    to_list = notification.getToList()
    cc_list = notification.getCCList()
    if to_list or cc_list:
        reg_page = url_for('event_mgmt.confModifRegistrants-modification', registrant, _external=True, _secure=True)
        tpl = get_template_module('payment/emails/payment_confirmation_organizers.txt', event=event,
                                  registrant=registrant, amount=amount, currency=currency, reg_page=reg_page)
        yield make_email(to_list, cc_list, from_address=from_address, subject=tpl.get_subject(), body=tpl.get_body())

    # Send email to the registrant
    if reg_form.isSendPaidEmail():
        success_email_msg = payment_event_settings.get(event, 'success_email')
        params = {}
        if not registrant.getAvatar():
            params = {'registrantId': registrant.getId(), 'authkey': registrant.getRandomId()}
        reg_page = url_for('event.confRegistrationFormDisplay', event, _external=True, _secure=True, **params)
        tpl = get_template_module('payment/emails/payment_confirmation_registrant.txt', event=event,
                                  registrant=registrant, amount=amount, currency=currency,
                                  success_email_msg=success_email_msg, reg_page=reg_page)
        yield make_email(registrant.getEmail(), from_address=from_address, subject=tpl.get_subject(),
                         body=tpl.get_body())
Example #4
0
def _sidemenu_items(sender, event, **kwargs):

    # Some legacy handling of menu items
    # Once those parts are modularized, we will be able to include them
    # conditionally from their respective modules.

    can_modify = event.can_manage(session.user, allow_key=True)
    rb_active = Config.getInstance().getIsRoomBookingActive()
    cfa_enabled = event.as_legacy.hasEnabledSection("cfa")

    event_type = event.as_legacy.getType()
    is_lecture = event_type == "simple_event"
    is_conference = event_type == "conference"
    paper_review = event.as_legacy.getConfPaperReview()
    is_review_staff = paper_review.isInReviewingTeam(session.avatar)
    is_review_manager = paper_review.isPaperReviewManager(session.avatar)

    if can_modify:
        yield SideMenuItem(
            "general", _("General settings"), url_for("event_mgmt.conferenceModification", event), 90, icon="settings"
        )
        if not is_lecture:
            yield SideMenuItem(
                "timetable", _("Timetable"), url_for("event_mgmt.confModifSchedule", event), 80, icon="calendar"
            )
        if rb_active:
            yield SideMenuItem(
                "room_booking", _("Room Booking"), url_for("event_mgmt.rooms_booking_list", event), 50, icon="location"
            )
    if is_conference:
        if can_modify:
            yield SideMenuItem(
                "program", _("Programme"), url_for("event_mgmt.confModifProgram", event), section="organization"
            )
        if can_modify and cfa_enabled:
            yield SideMenuItem(
                "abstracts", _("Abstracts"), url_for("event_mgmt.confModifCFA", event), section="organization"
            )
        if can_modify or is_review_manager:
            yield SideMenuItem(
                "contributions",
                _("Contributions"),
                url_for("event_mgmt.confModifContribList", event),
                section="organization",
            )
        if can_modify or is_review_staff:
            yield SideMenuItem(
                "paper_reviewing",
                _("Paper Reviewing"),
                url_for("event_mgmt.confModifReviewing-access", event),
                section="organization",
            )

    if can_modify:
        if not is_lecture:
            yield SideMenuItem(
                "lists", _("Lists"), url_for("event_mgmt.confModifListings-allSpeakers", event), section="reports"
            )
        yield SideMenuItem("utilities", _("Utilities"), url_for("event_mgmt.confModifTools", event), section="advanced")
        yield SideMenuItem("protection", _("Protection"), url_for("event_mgmt.confModifAC", event), 60, icon="shield")
Example #5
0
def _sidemenu_items(sender, category, **kwargs):
    yield SideMenuItem('content', _('Content'), url_for('categories.manage_content', category),
                       100, icon='eye')
    yield SideMenuItem('settings', _('Settings'), url_for('categories.manage_settings', category),
                       90, icon='settings')
    yield SideMenuItem('protection', _('Protection'), url_for('categories.manage_protection', category),
                       70, icon='shield')
Example #6
0
    def _createTabCtrl(self):
        self._tabCtrl = TabControl()

        if session.user.is_admin:
            self._subTabRoomBooking = self._tabCtrl.newTab(
                'booking',
                _('Room Booking'),
                url_for('rooms_admin.settings')
            )

            self._subTabMain = self._subTabRoomBooking.newSubTab(
                'settings',
                _('Settings'),
                url_for('rooms_admin.settings')
            )
        else:
            self._subTabRoomBooking = self._tabCtrl.newTab(
                'booking',
                _('Room Booking'),
                urlHandlers.UHRoomBookingAdmin.getURL()
            )

        self._subTabConfig = self._subTabRoomBooking.newSubTab(
            'management',
            _('Management'),
            urlHandlers.UHRoomBookingAdmin.getURL()
        )
        self._subTabRoomMappers = self._tabCtrl.newTab(
            'mappers',
            _('Room Mappers'),
            urlHandlers.UHRoomMappers.getURL()
        )
Example #7
0
def notify_registration_modification(event, registrant):
    reg_form = registrant.getRegistrationForm()
    from_address = reg_form.getNotificationSender()
    reg_details = _get_reg_details(reg_form, registrant)

    # Send email to organizers
    notification = reg_form.getNotification()
    to_list = notification.getToList()
    cc_list = notification.getCCList()
    if to_list or cc_list:
        reg_page = url_for('event_mgmt.confModifRegistrants-modification', registrant, _external=True, _secure=True)
        tpl = get_template_module('events/registration/emails/registration_modification_organizers.html', event=event,
                                  registrant=registrant, reg_page=reg_page, reg_details=reg_details)
        yield make_email(to_list, cc_list, from_address=from_address, subject=tpl.get_subject(), body=tpl.get_body(),
                         html=True)

    # Send email to the registrant
    if reg_form.isSendRegEmail():
        needs_to_pay = registrant.doPay() and payment_event_settings.get(event, 'enabled')
        params = {}
        if not registrant.getAvatar():
            params = {'registrantId': registrant.getId(), 'authkey': registrant.getRandomId()}
        reg_page = url_for('event.confRegistrationFormDisplay', event, _external=True, _secure=True, **params)
        tpl = get_template_module('events/registration/emails/registration_modification_registrant.html', event=event,
                                  registrant=registrant, payment_enabled=payment_event_settings.get(event, 'enabled'),
                                  reg_page=reg_page, needs_to_pay=needs_to_pay, reg_details=reg_details)

        yield make_email(registrant.getEmail(), from_address=from_address, subject=tpl.get_subject(),
                         body=tpl.get_body(), html=True)
Example #8
0
 def url(self):
     # explicit _external=False since offline site creation forces
     # _external=True if not specified and we want to be able to mangle
     # the generated urls into something suitable as filenames
     if self.is_user_link:
         return self.link_url
     elif self.is_internal_link:
         data = self.default_data
         if data.static_site and isinstance(data.static_site, basestring) and ContextManager.get('offlineMode'):
             return data.static_site
         kwargs = {}
         if self.name == 'timetable':
             from indico.modules.events. layout import layout_settings
             if layout_settings.get(self.event, 'timetable_by_room'):
                 kwargs['ttLyt'] = 'room'
             if layout_settings.get(self.event, 'timetable_detailed'):
                 start_date = self.event.getSchedule().getAdjustedStartDate()
                 kwargs['_anchor'] = start_date.strftime('%Y%m%d.detailed')
         return url_for(data.endpoint, self.event, _external=False, **kwargs)
     elif self.is_plugin_link:
         from indico.core.plugins import url_for_plugin
         return url_for_plugin(self.default_data.endpoint, self.event, _external=False)
     elif self.is_page:
         return url_for('event_pages.page_display', self.event, page_id=self.page_id, slug=slugify(self.title),
                        _external=False)
     else:
         return None
Example #9
0
    def _process(self):
        if session.user:
            return redirect(url_for('misc.index'))
        handler = MultipassRegistrationHandler(self) if self.identity_info else LocalRegistrationHandler(self)
        verified_email = self._get_verified_email()
        if verified_email is not None:
            handler.email_verified(verified_email)
            flash(_('You have successfully validated your email address and can now proceeed with the registration.'),
                  'success')

            # Check whether there is already an existing pending user with this e-mail
            pending = User.find_first(User.all_emails.contains(verified_email), is_pending=True)

            if pending:
                session['register_pending_user'] = pending.id
                flash(_("There is already some information in Indico that concerns you. "
                        "We are going to link it automatically."), 'info')

            return redirect(url_for('.register', provider=self.provider_name))

        form = handler.create_form()
        if form.validate_on_submit():
            if handler.must_verify_email:
                return self._send_confirmation(form.email.data)
            else:
                return self._create_user(form, handler)
        return WPAuth.render_template('register.html', form=form, local=(not self.identity_info),
                                      must_verify_email=handler.must_verify_email, widget_attrs=handler.widget_attrs,
                                      email_sent=session.pop('register_verification_email_sent', False))
 def _processIfActive(self):
     if not self._registrant:
         return redirect(url_for('event.confRegistrationFormDisplay-display', self._conf))
     if not self._regForm.inModificationPeriod():
         flash(_("The modification period is over."), 'error')
         return redirect(url_for('event.confRegistrationFormDisplay', self._conf))
     return registrationForm.WPRegistrationFormModify(self, self._conf).display()
Example #11
0
 def process_form(self):
     form = self.manager_form
     if self.request.state == RequestState.withdrawn:
         return
     elif not form.validate_on_submit():
         # very unlikely, unless the definition uses a custom form
         return
     if 'action_accept' in form and form.action_accept.data:
         action = 'accept'
     elif 'action_reject' in form and form.action_reject.data:
         action = 'reject'
     elif 'action_save' in form and form.action_save.data:
         action = 'save'
     else:
         # This happens when the request was already processed, e.g. in another
         # tab or if you simply click the submit button twice.  No nee to fail;
         # just don't do anything.
         return redirect(url_for('.event_requests_details', self.request))
     if action == 'accept':
         self.definition.accept(self.request, self.manager_form.data, session.user)
         flash(_('You have accepted this request.'), 'info')
     elif action == 'reject':
         self.definition.reject(self.request, self.manager_form.data, session.user)
         flash(_('You have rejected this request.'), 'info')
     elif action == 'save':
         self.definition.manager_save(self.request, self.manager_form.data)
         flash(_("You have updated the request (only management-specific data)."), 'info')
     return redirect(url_for('.event_requests_details', self.request))
Example #12
0
    def _process(self):
        if session.user:
            return redirect(url_for('misc.index'))
        handler = MultipassRegistrationHandler(self) if self.identity_info else LocalRegistrationHandler(self)
        verified_email = self._get_verified_email()
        if verified_email is not None:
            handler.email_verified(verified_email)
            flash(_('You have successfully validated your email address and can now proceeed with the registration.'),
                  'success')
            return redirect(url_for('.register', provider=self.provider_name))

        form = handler.create_form()
        # Check for pending users if we have verified emails
        pending = None
        if not handler.must_verify_email:
            pending = User.find_first(~User.is_deleted, User.is_pending,
                                      User.all_emails.contains(db.func.any(list(handler.get_all_emails(form)))))

        if form.validate_on_submit():
            if handler.must_verify_email:
                return self._send_confirmation(form.email.data)
            else:
                return self._create_user(form, handler, pending)
        elif not form.is_submitted() and pending:
            # If we have a pending user, populate empty fields with data from that user
            for field in form:
                value = getattr(pending, field.short_name, '')
                if value and not field.data:
                    field.data = value
        if pending:
            flash(_("There is already some information in Indico that concerns you. "
                    "We are going to link it automatically."), 'info')
        return WPAuth.render_template('register.html', form=form, local=(not self.identity_info),
                                      must_verify_email=handler.must_verify_email, widget_attrs=handler.widget_attrs,
                                      email_sent=session.pop('register_verification_email_sent', False))
Example #13
0
    def _process_POST(self):
        if User.has_rows():
            return redirect(url_for('misc.index'))
        setup_form = BootstrapForm(request.form)
        if not setup_form.validate():
            flash(_("Some fields are invalid. Please, correct them and submit the form again."), 'error')
            return redirect(url_for('bootstrap.index'))

        # Creating new user
        user = User()
        user.first_name = to_unicode(setup_form.first_name.data)
        user.last_name = to_unicode(setup_form.last_name.data)
        user.affiliation = to_unicode(setup_form.affiliation.data)
        user.email = to_unicode(setup_form.email.data)
        user.is_admin = True

        identity = Identity(provider='indico', identifier=setup_form.username.data, password=setup_form.password.data)
        user.identities.add(identity)

        db.session.add(user)
        db.session.flush()

        user.settings.set('timezone', Config.getInstance().getDefaultTimezone())
        user.settings.set('lang', to_unicode(setup_form.language.data))

        login_user(user, identity)
        full_name = user.full_name  # needed after the session closes

        transaction.commit()

        # Configuring server's settings
        minfo = HelperMaKaCInfo.getMaKaCInfoInstance()
        minfo.setOrganisation(setup_form.affiliation.data)
        minfo.setLang(setup_form.language.data)

        message = get_template_module('bootstrap/flash_messages.html').bootstrap_success(name=full_name)
        flash(Markup(message), 'success')

        # Activate instance tracking
        if setup_form.enable_tracking.data:
            contact_name = setup_form.contact_name.data
            contact_email = setup_form.contact_email.data

            try:
                register_instance(contact_name, contact_email)
            except (HTTPError, ValueError) as err:
                message = get_template_module('bootstrap/flash_messages.html').community_error(err=err)
                category = 'error'
            except Timeout:
                message = get_template_module('bootstrap/flash_messages.html').community_timeout()
                category = 'error'
            except RequestException as exc:
                message = get_template_module('bootstrap/flash_messages.html').community_exception(exc=exc)
                category = 'error'
            else:
                message = get_template_module('bootstrap/flash_messages.html').community_success()
                category = 'success'
            flash(Markup(message), category)

        return redirect(url_for('misc.index'))
Example #14
0
    def _process(self):
        # QRCode (Version 6 with error correction L can contain up to 106 bytes)
        qr = qrcode.QRCode(
            version=6,
            error_correction=qrcode.constants.ERROR_CORRECT_M,
            box_size=4,
            border=1
        )

        checkin_app = OAuthApplication.find_one(system_app_type=SystemAppType.checkin)
        qr_data = {
            "event_id": self.event.id,
            "title": self.event.title,
            "date": self.event.start_dt.isoformat(),
            "version": 1,
            "server": {
                "base_url": config.BASE_URL,
                "consumer_key": checkin_app.client_id,
                "auth_url": url_for('oauth.oauth_authorize', _external=True),
                "token_url": url_for('oauth.oauth_token', _external=True)
            }
        }
        json_qr_data = json.dumps(qr_data)
        qr.add_data(json_qr_data)
        qr.make(fit=True)
        qr_img = qr.make_image()

        output = BytesIO()
        qr_img.save(output)
        output.seek(0)

        return send_file('config.png', output, 'image/png')
Example #15
0
def render_breadcrumbs(*titles, **kwargs):
    """Render the breadcrumb navigation

    :param titles: A list of plain text titles.  If present, these will
                   simply create a unlinked trail of breadcrumbs.
                   A 'Home' element is inserted automatically.
    :param event: Generate the event/category breadcrumb trail starting
                  at the specified event.
    :param category: Generate the category breadcrumb trail starting at
                     the specified category.
    :param management: Whether the event/category breadcrumb trail
                       should link to management pages.
    """
    category = kwargs.get('category', None)
    event = kwargs.get('event', None)
    management = kwargs.get('management', False)
    assert bool(titles) + bool(event) + bool(category) == 1
    if not category and not event:
        items = [(_('Home'), url_for_index())] + [(x, None) for x in titles]
    else:
        items = []
        if event:
            items.append((event.title, url_for('event_management.settings', event) if management else event.url))
            category = event.category
        for cat in category.chain_query[::-1]:
            items.append((cat.title, url_for('categories.manage_content', cat) if management else cat.url))
        items.reverse()
    return render_template('breadcrumbs.html', items=items, management=management)
Example #16
0
 def serialize_session_block_entry(self, entry, load_children=True):
     block = entry.session_block
     data = {}
     if not load_children:
         entries = defaultdict(dict)
     else:
         entries = {self._get_entry_key(x): self.serialize_timetable_entry(x) for x in entry.children}
     data.update(self._get_entry_data(entry))
     data.update(self._get_color_data(block.session))
     data.update(self._get_location_data(block))
     data.update({'entryType': 'Session',
                  'sessionSlotId': block.id,
                  'sessionId': block.session_id,
                  'sessionCode': block.session.code,
                  'title': block.session.title,
                  'slotTitle': block.title,
                  'attachments': self._get_attachment_data(block.session),
                  'code': block.session.code,
                  'contribDuration': block.session.default_contribution_duration.seconds / 60,
                  'conveners': [self._get_person_data(x) for x in block.person_links],
                  'description': block.session.description,
                  'duration': block.duration.seconds / 60,
                  'isPoster': block.session.is_poster,
                  'entries': entries,
                  'pdf': url_for('sessions.export_session_timetable', block.session),
                  'url': url_for('sessions.display_session', block.session),
                  'friendlyId': block.session.friendly_id})
     return data
Example #17
0
    def _process(self):
        if not self.plugin.can_manage_vc_rooms(session.user, self.event_new):
            flash(
                _("You are not allowed to refresh {plugin_name} rooms for this event.").format(
                    plugin_name=self.plugin.friendly_name
                ),
                "error",
            )
            return redirect(url_for(".manage_vc_rooms", self.event_new))

        Logger.get("modules.vc").info("Refreshing VC room {} from event {}".format(self.vc_room, self._conf))

        try:
            self.plugin.refresh_room(self.vc_room, self.event_new)
        except VCRoomNotFoundError as err:
            Logger.get("modules.vc").warning("VC room '{}' not found. Setting it as deleted.".format(self.vc_room))
            self.vc_room.status = VCRoomStatus.deleted
            flash(err.message, "error")
            return redirect(url_for(".manage_vc_rooms", self.event_new))

        flash(
            _("{plugin_name} room '{room.name}' refreshed").format(
                plugin_name=self.plugin.friendly_name, room=self.vc_room
            ),
            "success",
        )
        return redirect(url_for(".manage_vc_rooms", self.event_new))
Example #18
0
    def process_form(self):
        form = self.form
        if not form.validate_on_submit():
            return
        if not self.request or not self.request.can_be_modified:
            req = Request(event=self.event, definition=self.definition, created_by_user=session.user)
            new = True
        else:
            req = self.request
            new = False

        try:
            with db.session.no_autoflush:
                self.definition.send(req, form.data)
        except RequestModuleError:
            self.commit = False
            flash_msg = _('There was a problem sending your request ({0}). Please contact support.')
            flash(flash_msg.format(self.definition.title), 'error')
        else:
            if new:
                flash_msg = (_("Your request ({0}) has been accepted.") if req.state == RequestState.accepted
                             else _("Your request ({0}) has been sent."))
            else:
                flash_msg = _("Your request ({0}) has been modified.")
            flash(flash_msg.format(self.definition.title), 'success')
        if self.is_manager:
            return redirect(url_for('.event_requests_details', self.event, type=self.definition.name))
        else:
            return redirect(url_for('.event_requests', self.event))
Example #19
0
    def getVars(self):
        wvars = WTemplated.getVars(self)
        wvars["standalone"] = self._standalone
        room = wvars["room"]

        wvars["attrs"] = {
            attr.attribute.name: attr
            for attr in room.attributes
            if not attr.attribute.is_hidden or rb_is_admin(session.user)
        }

        wvars["owner_name"] = room.owner.full_name

        wvars["bookable_hours"] = room.bookable_hours.all()
        wvars["nonbookable_periods"] = room.nonbookable_periods.all()

        # URLs
        wvars["stats_url"] = UH.UHRoomBookingRoomStats.getURL(room)
        wvars["delete_room_url"] = url_for("rooms_admin.delete_room", room)
        wvars["modify_room_url"] = url_for("rooms_admin.modify_room", room)
        if not self._standalone:
            wvars["conference"] = self._rh._conf

        wvars["show_on_map"] = room.map_url if room.map_url else url_for("rooms.roomBooking-mapOfRooms", room)

        return wvars
Example #20
0
    def serialize_contribution_entry(self, entry):
        from indico.modules.events.api import SerializerBase

        block = entry.parent.session_block if entry.parent else None
        contribution = entry.contribution
        data = {}
        data.update(self._get_entry_data(entry))
        if contribution.session:
            data.update(self._get_color_data(contribution.session))
        data.update(self._get_location_data(contribution))
        data.update({'entryType': 'Contribution',
                     '_type': 'ContribSchEntry',
                     '_fossil': 'contribSchEntryDisplay',
                     'contributionId': contribution.id,
                     'attachments': self._get_attachment_data(contribution),
                     'description': contribution.description,
                     'duration': contribution.duration.seconds / 60,
                     'pdf': url_for('contributions.export_pdf', entry.contribution),
                     'presenters': map(self._get_person_data,
                                       sorted([p for p in contribution.person_links if p.is_speaker],
                                              key=lambda x: (x.author_type != AuthorType.primary,
                                                             x.author_type != AuthorType.secondary,
                                                             x.display_order_key))),
                     'sessionCode': block.session.code if block else None,
                     'sessionId': block.session_id if block else None,
                     'sessionSlotId': block.id if block else None,
                     'sessionSlotEntryId': entry.parent.id if entry.parent else None,
                     'title': contribution.title,
                     'url': url_for('contributions.display_contribution', contribution),
                     'friendlyId': contribution.friendly_id,
                     'references': map(SerializerBase.serialize_reference, contribution.references),
                     'board_number': contribution.board_number})
        return data
    def _process(self):
        canManageRegistration = self._conf.canManageRegistration(self._getUser())
        if not canManageRegistration and not self._regForm.isActivated():
            p = registrationForm.WPRegFormInactive(self, self._conf)
            return p.display()
        params = self._getRequestParams()
        email = self._regForm.getPersonalData().getValueFromParams(params, 'email')
        if email is None:
            raise FormValuesError(_("An email address has to be set in order to make the registration in the event."))
        elif not validMail(email, False):
            raise FormValuesError(_("The given email address is not valid."))

        # Check if the email matches an existing user
        user = get_user_by_email(email)
        avatar = user.as_avatar if user else None

        # Check if the user can register
        if not canManageRegistration:  # normal user registering. Managers can.
            if self._conf.getRegistrationForm().isFull():
                self._redirect(urlHandlers.UHConfRegistrationFormDisplay.getURL(self._conf))
                return
            elif not self._conf.getRegistrationForm().inRegistrationPeriod():
                flash(_("Your registration couldn't be recorded."), 'error')
                return redirect(url_for('event.confRegistrationFormDisplay', self._conf))
        if user is None:
            if self._conf.hasRegistrantByEmail(email):
                raise FormValuesError("There is already a user with the email \"%s\". Please choose another one" % email)
        else:
            if avatar.isRegisteredInConf(self._conf) or self._conf.hasRegistrantByEmail(email):
                if canManageRegistration:
                    raise FormValuesError("There is already a user with the email \"%s\". Please choose another one" % email)
                else:
                    raise FormValuesError("You have already registered with the email address \"%s\". If you need to modify your registration, please contact the managers of the conference." % email)

        rp = registration.Registrant()
        self._conf.addRegistrant(rp, avatar)
        rp.setValues(self._getRequestParams(), avatar)

        if avatar is not None:
            rp.setAvatar(avatar)

        notify_registration_confirmation(self._conf, rp)
        self._conf.log(EventLogRealm.management if self.is_manager else EventLogRealm.participants,
                       EventLogKind.positive, u'Registration',
                       u'User registered: {}'.format(to_unicode(rp.getFullName(title=False, firstNameFirst=True))),
                       session.user,
                       data={u'Indico user': u'{} ({})'.format(user.full_name, user.id) if user else u'None'})

        if self.is_manager:
            self._redirect(RHRegistrantListModif._uh.getURL(self._conf))
        else:
            params = {}
            if not rp.doPay() or not payment_event_settings.get(self._conf, 'enabled'):
                flash(_(u"Your registration has been recorded successfully."), 'success')
            if not session.user or session.user != user:
                params.update(rp.getLocator(), **{'authkey': rp.getRandomId()})
            else:
                params.update(self._conf.getLocator())
            return redirect(url_for('event.confRegistrationFormDisplay', **params))
Example #22
0
 def _process(self):
     session_key = "reglist_config_{}".format(self.regform.id)
     configuration = {"regform_id": self.regform.id, "data": session.get(session_key)}
     url = url_for(".manage_reglist", self.regform, _external=True)
     if configuration["data"]:
         link = ReportLink.create(self.event_new, REPORT_LINK_TYPE, configuration)
         url = url_for(".manage_reglist", self.regform, config=link.uuid, _external=True)
     return jsonify(url=url)
Example #23
0
def _extend_event_management_menu_layout(sender, event, **kwargs):
    if not event.can_manage(session.user, allow_key=True):
        return
    if event.as_legacy.getType() == 'conference':
        yield SideMenuItem('layout', _('Layout'), url_for('event_layout.index', event), section='customization')
        yield SideMenuItem('menu', _('Menu'), url_for('event_layout.menu', event), section='customization')
    if event.has_feature('images'):
        yield SideMenuItem('images', _('Images'), url_for('event_layout.images', event), section='customization')
Example #24
0
def _extend_event_management_menu_layout(sender, event, **kwargs):
    if not event.can_manage(session.user):
        return
    yield SideMenuItem('layout', _('Layout'), url_for('event_layout.index', event), section='customization')
    if event.type_ == EventType.conference:
        yield SideMenuItem('menu', _('Menu'), url_for('event_layout.menu', event), section='customization')
    if event.has_feature('images'):
        yield SideMenuItem('images', _('Images'), url_for('event_layout.images', event), section='customization')
Example #25
0
 def _process(self):
     if self._room.has_live_reservations():
         flash(_(u'Cannot delete room with live bookings'), 'error')
         return redirect(url_for('rooms.roomBooking-roomDetails', self._room))
     else:
         db.session.delete(self._room)
         flash(_(u'Room deleted'), 'success')
         return redirect(url_for('rooms_admin.roomBooking-adminLocation', self._room.location))
Example #26
0
def _extend_event_management_menu_layout(sender, event, **kwargs):
    if not event.can_manage(session.user):
        return
    if event.as_legacy.getType() == "conference":
        yield SideMenuItem("layout", _("Layout"), url_for("event_layout.index", event), section="customization")
        yield SideMenuItem("menu", _("Menu"), url_for("event_layout.menu", event), section="customization")
    if event.has_feature("images"):
        yield SideMenuItem("images", _("Images"), url_for("event_layout.images", event), section="customization")
Example #27
0
def _sidemenu_items(sender, category, **kwargs):
    yield SideMenuItem('view', _('View category'), url_for('category.categoryDisplay', category),
                       100, icon='eye')
    yield SideMenuItem('general', _('General Settings'), url_for('category_mgmt.categoryModification', category),
                       90, icon='settings')
    yield SideMenuItem('protection', _('Protection'), url_for('category_mgmt.categoryAC', category),
                       70, icon='shield')
    yield SideMenuItem('tools', _('Tools'), url_for('category_mgmt.categoryTools', category),
                       60, icon='wrench')
Example #28
0
 def _createTabCtrl(self):
     self._tabCtrl = TabControl()
     self._tabExistBookings = self._tabCtrl.newTab('existing', 'Existing Bookings',
                                                   url_for('event_mgmt.rooms_booking_list', self._conf))
     self._tabNewBooking = self._tabCtrl.newTab('new', 'New Booking',
                                                url_for('event_mgmt.rooms_choose_event', self._conf))
     if not Reservation.find(event_id=self._conf.getId()).count():
         self._tabExistBookings.setEnabled(False)
     self._setActiveTab()
Example #29
0
 def _createTabCtrl(self):
     self._tabCtrl = TabControl()
     self._tabExistBookings = self._tabCtrl.newTab('existing', 'Existing Bookings',
                                                   url_for('event_mgmt.rooms_booking_list', self.event))
     self._tabNewBooking = self._tabCtrl.newTab('new', 'New Booking',
                                                url_for('event_mgmt.rooms_choose_event', self.event))
     if not Reservation.query.with_parent(self.event).has_rows():
         self._tabExistBookings.setEnabled(False)
     self._setActiveTab()
Example #30
0
    def _process(self):
        if not self.plugin.can_manage_vc_rooms(session.user, self.event_new):
            flash(
                _("You are not allowed to modify {} rooms for this event.").format(self.plugin.friendly_name), "error"
            )
            return redirect(url_for(".manage_vc_rooms", self.event_new))

        form = self.plugin.create_form(
            self.event_new, existing_vc_room=self.vc_room, existing_event_vc_room=self.event_vc_room
        )

        if form.validate_on_submit():

            self.plugin.update_data_vc_room(self.vc_room, form.data)

            event_vc_room = process_vc_room_association(
                self.plugin, self.event_new, self.vc_room, form, event_vc_room=self.event_vc_room, allow_same_room=True
            )
            if not event_vc_room:
                return redirect(url_for(".manage_vc_rooms", self.event_new))

            self.vc_room.modified_dt = now_utc()

            try:
                self.plugin.update_room(self.vc_room, self.event_new)
            except VCRoomNotFoundError as err:
                Logger.get("modules.vc").warning("VC room {} not found. Setting it as deleted.".format(self.vc_room))
                self.vc_room.status = VCRoomStatus.deleted
                flash(err.message, "error")
                return redirect(url_for(".manage_vc_rooms", self.event_new))
            except VCRoomError as err:
                if err.field is None:
                    raise
                field = getattr(form, err.field)
                field.errors.append(err.message)
                transaction.abort()
            else:
                # TODO
                # notify_modified(self.vc_room, self.event_new, session.user)

                flash(
                    _("{plugin_name} room '{room.name}' updated").format(
                        plugin_name=self.plugin.friendly_name, room=self.vc_room
                    ),
                    "success",
                )
                return jsonify_data(flash=False)

        form_html = self.plugin.render_form(
            plugin=self.plugin,
            event=self.event_new,
            form=form,
            existing_vc_room=self.vc_room,
            skip_fields=form.skip_fields | {"name"},
        )

        return jsonify(html=form_html, js=_pop_injected_js())
Example #31
0
 def _process(self):
     self.application.reset_client_secret()
     logger.info("Client secret of %s reset by %s", self.application,
                 session.user)
     flash(_("New client secret generated for the application"), 'success')
     return redirect(url_for('.app_details', self.application))
Example #32
0
def url_for_logout(next_url=None):
    return url_for('auth.logout', next=next_url)
Example #33
0
 def booking_url(self):
     if self.id is None:
         return None
     return url_for('rooms.room_book', self)
Example #34
0
 def large_photo_url(self):
     if self.id is None:
         return None
     return url_for('rooms.photo', self, size='large')
Example #35
0
 def small_photo_url(self):
     if self.id is None:
         return None
     return url_for('rooms.photo', self, size='small')
Example #36
0
 def _process(self):
     self._conf.setClosed(False)
     flash(_('The event is now unlocked.'), 'success')
     return redirect(
         url_for('event_mgmt.conferenceModification', self._conf))
Example #37
0
 def _get_url(self, uh_or_endpoint, target, **params):
     if isinstance(uh_or_endpoint, basestring):
         return url_for(uh_or_endpoint, target, **params)
     else:
         return str(uh_or_endpoint.getStaticURL(target, **params))
Example #38
0
 def success_url(self):
     return url_for('.display_regform', self.registration.locator.registrant)
Example #39
0
 def get_ajax_url(self, **url_args):
     kwargs = request.view_args | request.args.to_dict(False)
     kwargs.update(url_args)
     kwargs['__wtf_ajax'] = self.id
     return url_for(request.endpoint, **kwargs)
Example #40
0
 def external_url(self):
     return url_for('events.display', self, _external=True)
Example #41
0
def _sidemenu_items(sender, **kwargs):
    if session.user.is_admin:
        yield SideMenuItem('announcement',
                           _('Announcement'),
                           url_for('announcement.manage'),
                           section='homepage')
Example #42
0
 def url(self):
     return url_for('categories.display', self)
Example #43
0
 def _process(self):
     db.session.delete(self.application)
     logger.info("Application %s deleted by %s", self.application,
                 session.user)
     flash(_("Application deleted successfully"), 'success')
     return redirect(url_for('.apps'))
Example #44
0
def _category_sidemenu_items(sender, category, **kwargs):
    if category.can_manage(session.user):
        return SideMenuItem('designer',
                            _('Posters/Badges'),
                            url_for('designer.template_list', category),
                            icon='palette')
Example #45
0
def _sidemenu_items(sender, **kwargs):
    if session.user.is_admin:
        yield SideMenuItem('settings', _('General Settings'), url_for('core.settings'), 100, icon='settings')
Example #46
0
def _event_sidemenu_items(sender, event, **kwargs):
    if event.can_manage(session.user):
        return SideMenuItem('designer',
                            _('Posters/Badges'),
                            url_for('designer.template_list', event),
                            section='customization')
Example #47
0
 def _process_POST(self):
     self._conf.setClosed(True)
     flash(_('The event is now locked.'), 'success')
     return jsonify_data(url=url_for('event_mgmt.conferenceModification',
                                     self._conf),
                         flash=False)
Example #48
0
 def effective_icon_url(self):
     """Get the HTTP URL of the icon (possibly inherited)."""
     data = self.effective_icon_data
     return url_for('categories.display_icon', category_id=data['source_id'], slug=data['metadata']['hash'])
Example #49
0
 def logo_url(self):
     """Get the HTTP URL of the logo."""
     return url_for('categories.display_logo', self, slug=self.logo_metadata['hash'])
Example #50
0
 def _process(self):
     db.session.delete(self.group)
     flash(
         _("The group '{name}' has been deleted.").format(
             name=self.group.name), 'success')
     return redirect(url_for('.groups'))
Example #51
0
 def details_url(self):
     if self.id is None:
         return None
     return url_for('rooms.roomBooking-roomDetails', self)
Example #52
0
    def _process_POST(self):
        if User.query.filter_by(is_system=False).has_rows():
            return redirect(url_for_index())
        setup_form = BootstrapForm(request.form)
        if not setup_form.validate():
            flash(
                _("Some fields are invalid. Please, correct them and submit the form again."
                  ), 'error')
            return redirect(url_for('bootstrap.index'))

        # Creating new user
        user = User()
        user.first_name = setup_form.first_name.data
        user.last_name = setup_form.last_name.data
        user.affiliation = setup_form.affiliation.data
        user.email = setup_form.email.data
        user.is_admin = True

        identity = Identity(provider='indico',
                            identifier=setup_form.username.data,
                            password=setup_form.password.data)
        user.identities.add(identity)

        db.session.add(user)
        db.session.flush()

        user.settings.set('timezone', config.DEFAULT_TIMEZONE)
        user.settings.set('lang', session.lang or config.DEFAULT_LOCALE)

        login_user(user, identity)
        full_name = user.full_name  # needed after the session closes

        db.session.commit()

        # Configuring server's settings
        core_settings.set('site_organization', setup_form.affiliation.data)

        message = get_template_module(
            'bootstrap/flash_messages.html').bootstrap_success(name=full_name)
        flash(Markup(message), 'success')

        # Activate instance tracking
        if setup_form.enable_tracking.data:
            contact_name = setup_form.contact_name.data
            contact_email = setup_form.contact_email.data

            try:
                register_instance(contact_name, contact_email)
            except (HTTPError, ValueError) as err:
                message = get_template_module('bootstrap/flash_messages.html'
                                              ).community_error(err=str(err))
                category = 'error'
            except Timeout:
                message = get_template_module(
                    'bootstrap/flash_messages.html').community_timeout()
                category = 'error'
            except RequestException as exc:
                message = get_template_module(
                    'bootstrap/flash_messages.html').community_exception(
                        err=str(exc))
                category = 'error'
            else:
                message = get_template_module(
                    'bootstrap/flash_messages.html').community_success()
                category = 'success'
            flash(Markup(message), category)

        return redirect(url_for_index())
Example #53
0
def _extend_event_management_menu(sender, event, **kwargs):
    if not event.can_manage(session.user) or not EditingFeature.is_allowed_for_event(event):
        return
    return SideMenuItem('editing', _('Editing'), url_for('event_editing.dashboard', event),
                        section='organization')
Example #54
0
 def _process_args(self):
     self.agent = LiveSyncAgent.get_one(request.view_args['agent_id'])
     if self.agent.backend is None:
         flash(_('Cannot edit an agent that is not loaded'), 'error')
         return redirect(url_for('plugins.details', plugin='livesync'))
Example #55
0
 def _checkParams(self, params):
     RHRegistrationFormRegistrationBase._checkParams(self, params)
     InvitationMixin._checkParams(self)
     if self.invitation and self.invitation.state == InvitationState.accepted and self.invitation.registration:
         return redirect(url_for('.display_regform', self.invitation.registration.locator.registrant))
Example #56
0
def url_for_login(next_url=None):
    if next_url == '/':
        next_url = None
    return url_for('auth.login', next=next_url, _external=True)
Example #57
0
 def url(self):
     return url_for('events.display', self)
Example #58
0
 def icon_url(self):
     """Get the HTTP URL of the icon."""
     return url_for('categories.display_icon', self, slug=self.icon_metadata['hash'])
Example #59
0
 def logo_url(self):
     return url_for('event_images.logo_display',
                    self,
                    slug=self.logo_metadata['hash'])
Example #60
0
def _get_event_management_url(event, **kwargs):
    if event.cfp.is_manager(session.user):
        return url_for('papers.management', event)