frontend.ptl

#
# The quick-n-dirty LPC BBB frontend system
#   Copyright 2020 Jonathan Corbet <corbet@lwn.net>
#   Copyright 2020 Guy Lunardi <guy@linux.com>
# Redistributable under the terms of the GNU General Public License,
# version 2 or greater
#
from quixote.directory import Directory, export, subdir
from quixote import get_request, get_response
from quixote.html import htmltext
from quixote.form import *
import datetime
from datetime import timezone
from email import policy
from email.message import EmailMessage
import smtplib
import re

import auth, page, bbb, config, indico, timetable, times, buttons

#
# Show this many minutes of upcoming sessions.
#
minutes = 360

cookie_name = 'lpc_session'

class frontend(Directory):

    @export(name='')
    def index [html] (self):
        user = self.logged_in()
        if user:
            self.front_page(user)
        else:
            self.login_form()

    def front_page [html] (self, user):
        page.header('/', 'Welcome %s!' % (user.name), user.is_admin())
        # Always notice timezone changes across page refreshes. Without
        # this, if the timezone wasn't set at user login, or the user
        # changes their timezone later, it will not be updated for display.
        insert_tz_js()
        self.main_text()
        page.end_text_area()
        self.render_schedule(times.current_time(), minutes)
        if user.is_admin():
            self.time_selector(times.current_time())
        page.trailer()

    def main_text [html] (self):
        '''This is the entry portal for the %s
           meeting rooms.  Look below for the list of what is happening
           currently.
           <p>
           The timetable below is focused on current (or near-future) sessions.
           Times are given in both UTC and our best guess as to your local time
           (which appears to be offset from UTC by %d minutes).  Click on the
           "join" button that will appear for any sessions that are currently
           ongoing.
           <p>
           The full schedule is always available on the <a
           href="https://linuxplumbersconf.org/event/%d/timetable/?view=lpc">main
           Linux Plumbers Conference</a> site.
           <p>
           Thank you for participating in LPC 2021; please do not hesitate to
           contact us at <tt>contact@linuxplumbersconf.org</tt> should you have
           any difficulties, questions, or comments.
           ''' % (config.EVENT, times.user_tz_offset(get_request()), config.EVENT_ID)

    def time_selector(self, when):
        return time_selector_widget(when.weekday(), when.hour).render()

    @export
    def fake_time [html] (self):
        weekday, hour = time_selector_widget(0, 0).parse()
        page.header('/', 'LPC timetable at a fake time', admin = True)
        tz = datetime.timezone(datetime.timedelta(hours = config.SERVER_TZOFFSET))
        begin = datetime.datetime(2021, 9, 20, 0, 0, 0, tzinfo = timezone.utc)
        begin += datetime.timedelta(days = weekday)
        begin += datetime.timedelta(hours = hour)
        '''This is the timetable rendered as if it were %s UTC
        ''' % (begin.strftime(str('%Y-%m-%d %H:%M')))
        page.end_text_area()
        self.render_schedule(begin, minutes)
        self.time_selector(begin)
        page.trailer()


    @export
    def logout(self):
        response = get_response()
        response.expire_cookie('lpc_session')
        return response.redirect(config.SITE_URL)

    @export
    def stylesheet(self):
        response = get_response()
        response.set_header('content-type', 'text/css; charset=utf-8')
        response.cache = 600
        return page.CSS()
    #
    # Return the logged-in user, if any.
    #
    def logged_in(self):
        request = get_request()
        cookie = request.get_cookie('lpc_session')
        if not cookie:
            return None
        return auth.validate_cookie(cookie)

    def display_greeting [html] (self):
        try:
            greeting = config.GREETING_FILE
        except NameError:
            return
        if greeting:
            try:
                with open(greeting, str('r')) as f:
                    htmltext(f.read())
            except FileNotFoundError:
                pass

    def login_form [html] (self, message = None, email = '', target = ''):
        page.header('/', 'Welcome to %s' % (config.EVENT), menu = False)
        insert_tz_js()
        self.display_greeting()
        #
        # Are we feeling open today?
        #
        if config.GUEST_ALLOWED:
            '''<h3>Log in as a guest</h3>
               <p>
               To log in without an existing account, please enter your full
               name in the blank below.  This is the name that will identify
               you in the conference rooms.
            '''
            GuestForm().render()
        '''<p>Please login with the email address you used to register to LPC 2021.
           You need to enter your Registration Confirmation Number. That
           information is found in your confirmation email titled
           "Registration Confirmed - Linux Plumbers Conference 2021".
           <p>
           '''
        if message:
            '<b>' + message + '</b><p>\n'
        '<blockquote>\n'
        LoginForm(email = email, target = target).render('/login')
        '</blockquote>\n'
        '''<h3>Having trouble?</h3>
           <p>
           Please email <tt>contact@linuxplumbersconf.org</tt> for assistance
           accessing the conference site.
           '''
        page.trailer()

    # A really crude email-address checker that splits out a +foo part.
    email_addr = re.compile(r'(\w[^@+]*)(\+\w+)?@(.+\..+)')
    @export
    def login(self):
        lf = LoginForm()
        email, password = lf.parse()
        target = lf.target()
        #
        # Check and fix up the email address.
        #
        m = email and self.email_addr.match(email)
        if not m:
            return self.login_form('Please supply a valid email address', target = target)
        email = m.group(1) + '@' + m.group(3) # drop +foo
        #
        # Perhaps what they really want is an ID reminder.
        #
        if get_request().get_field('reminder'):
            if not email:
                return self.login_form('Please supply an email address')
            return self.id_reminder(email)
        if not (email and password):
            return self.login_form('Please fill in both fields', email = email, target = target)
        u = auth.check_password(email, password)
        if not u:
            return self.login_form('Unknown email or invalid password',
                                   email = email, target = target)
        #
        # OK, they've convinced us that they are for real.  Let's fix
        # them up with a session cookie and give them the real page.
        #
        cookie = auth.make_cookie(u)
        response = get_response()
        response.set_cookie('lpc_session', cookie)
        return response.redirect(config.SITE_URL + target)

    def id_reminder(self, email):
        with open('/tmp/reminder_requests', 'a') as f:
            when = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
            f.write('Request: %s %s\n' % (when, email))
        user = auth.lookup(email)
        if user:
            send_reminder(email, user.id)
        return self.login_form('''If %s is a valid registration address, a
        			  reminder mail has been sent.''' % (email))

    @export
    def guest_login(self):
        if not config.GUEST_ALLOWED:
            return self.login_form('Guest logins disabled, just what are '
                                   'you doing here, anyway??')
        name = GuestForm().parse()
        if not name:
            return self.login_form('Guest login requires a name')
        cookie = auth.make_guest_cookie(name)
        response = get_response()
        response.set_cookie('lpc_session', cookie)
        return response.redirect(config.SITE_URL)

    #
    # Moderator's server information page.
    #
    @export
    def status [html] (self):
        user = self.logged_in()
        if (not user) or (not user.is_admin()):
            get_response().redirect(config.SITE_URL)
        page.header('/status', 'Server and room status', True)
        self.gm_button()
        self.list_servers()
        page.end_text_area()
        self.list_rooms()
        page.trailer()

    def gm_button [html] (self):
        '<form action="toggle_guest">\n'
        '<b>Guest mode</b>: '
        if config.GUEST_ALLOWED:
            'ENABLED '
            SubmitWidget(name='guestmode', value = 'Disable').render()
        else:
            'DISABLED '
            SubmitWidget(name='guestmode', value = 'Enable').render()
        '</form><p>'

    @export
    def toggle_guest(self):
        user = self.logged_in()
        if (not user) or (not user.is_admin()):
            return get_response().redirect(config.SITE_URL)
        config.GUEST_ALLOWED = not config.GUEST_ALLOWED
        return self.status()

    def list_servers [html] (self):
        '<h4>Server status</h4>'
        '<dl>\n'
        '''<blockquote>
           <table class="OddEven">
           <tr><th>Server</th><th>status</th><th>Rooms</th><th>People</th></tr>
           '''
        total_people = total_rooms = 0
        for server in bbb.all_servers():
            meetings = bbb.status(server)
            if meetings is None:
                '<tr><td>%s</td><td>DOWN</td><td></td><td></td></tr>\n' % (server)
                continue
            nrooms = len(meetings)
            npeople = 0
            for m in meetings:
                npeople += int(m['people'])
            '<tr><td>%s</td><td>UP</td><td>%d</td><td>%d</td></tr>\n' % \
                        (server, nrooms, npeople)
            total_rooms += nrooms
            total_people += npeople
        '<tr><td>TOTAL</td><td></td><td>%d</td><td>%d</td></tr>\n' % (total_rooms,
                                                                      total_people)
        '</table></blockquote>\n'
    #
    # Room management
    #
    def list_rooms [html] (self):
        '''<h4>Room status</h4>
           <p>
           <blockquote>
           <table class="OddEven">
           <tr><th>Room</th>
               <th>Server</th>
               <th>Type</th>
               <th>Status</th>
               <th>People</th>
               <th>Listen</th>
               <th>Video</th>
               <th>Moderators</th>
               <th></th></tr>
           '''
        for room in bbb.all_rooms():
            status = bbb.room_status(room)
            '<tr><td>%s</td><td>%s</td><td>%s</td>' % (room, status['server'],
                                                       status['type'])
            if status['running']:
                '''<td>RUNNING</td>
                   <td align=right>%s</td><td align=right>%s</td>
                   <td align=right>%s</td>
                   <td>%s</td><td>''' % (status['people'], status['listeners'],
                                         status['video'], status['moderators'])
                buttons.room_join_button(room)
                '</td></tr>\n'
            else:
                '''<td>CLOSED</td>
                   <td></td><td></td><td></td><td></td><td>'''
                buttons.room_start_button(room)
                '</td></tr>\n'
        '</table></blockquote>\n'

    #
    # A special staff room.
    #
    @export
    def staff_room(self):
        return self.special_room('Staff room')

    @export
    def maintainers(self):
        return self.special_room('Maintainers summit')

    def special_room(self, room):
        user = self.logged_in()
        #
        # Let them in even if they are not admin, so we can invite
        # somebody there if need be.
        #
        if not user:
            return self.login_form('Please log in to access this room',
                                   target = get_request().environ['REQUEST_URI'][1:])
        status = bbb.room_status(room)
        if status['server'] == '???':
            return get_response().redirect(config.SITE_URL)
        # Duplicated code, ugh
        if not status['running']:
            bbb.start_room(room)
        url = bbb.join_room_url(user.name, room, user)
        return get_response().redirect(url)

    @export
    def join_room(self):
        response = get_response()
        user = self.logged_in()
        if not user:
            return response.redirect(config.SITE_URL) # No fast ones here
        room = HiddenWidget('room', '').parse()
        if not bbb.valid_room(room):
            return response.redirect(config.SITE_URL) # No fast ones here
        status = bbb.room_status(room)
        #
        # Policy: let any user start a room if they have access to
        # a "join" button.
        #
        if not status['running']:
            bbb.start_room(room, matrix = self.get_matrix(room))
        url = bbb.join_room_url(user.name, room, user)
        return response.redirect(url)

    def get_matrix(self, room):
        # Should really limit this to session rooms
        track = indico.track_in_room(room, times.current_time())
        if track:
            return timetable.matrix_room(track)
        return ''
    #
    # This is not currently used.
    #
    def room_closed [html] (self, room):
        page.header('/', 'Room closed', False)
        '''The room you are trying to join has not yet been opened for
           general access.  Please accept our apologies for the inconvenience
           and retry shortly.
           <p>
           <blockquote>
           '''
        buttons.room_join_button(room, button_text = 'Retry room ' + room)
        '</blockquote>\n'
    #
    # A first shot at rendering a schedule.
    #
    def render_schedule [html] (self, begin, minutes):
        ttable = indico.get_timetable(begin, minutes)
        #
        # No timetable, figure out something to do.
        #
        if len(ttable) == 0:
            '''<p>
               <b>NOTE</b>: there are no sessions underway at the current
               time.
               '''
            restart = indico.find_restart_time(begin)
            if not restart:
                return '''<p>
                	  <b>NOTE</b>: the event is over — see you next year!
                          '''
            lrestart = times.offset_time(get_request(), restart)
            '''The conference will restart at %s UTC (%s local) with the sessions
               shown below.
               ''' % (times.utc_time(restart).strftime(str('%Y-%m-%d %H:%M')),
                      lrestart.strftime(str('%H:%M')))
            ttable = indico.get_timetable(restart, minutes)
            #
            # Hack: back up the "start" time by 61 minutes to ensure that
            # the timetable code knows this isn't happening now.
            #
            begin = restart - datetime.timedelta(minutes = 61)
        tracks = sorted(ttable.keys())
        rows = timetable.generate_rows(ttable, tracks, begin)
        timetable.render_rows(begin, rows)


    #
    # Access to the hack rooms
    #
    @export
    def hackrooms [html] (self):
        #
        # We need a proper _q_access function!
        #
        user = self.logged_in()
        if not user:
            return get_response().redirect(config.SITE_URL)
        page.header('/hackrooms', 'LPC 2021 hackrooms', user.is_admin())
        '''This page lists the LPC 2021 hackrooms — rooms that are open for
           informal meetings or just the desire to get together and talk for a
           bit.
           <p>
           Please remember that our code of conduct applies to the hackrooms,
           and that your presence in these rooms will be visible on this page.
           '''
        page.end_text_area()
        '''<p>
           <blockquote>
           <table>
           <tr><th></th><th>Room</th><th>Participants</th></tr>
           '''
        for room in bbb.all_rooms(type = 'hack'):
            status = bbb.room_status(room)
            if status['running']:
                people = status['participants']
            else:
                people = '(empty)'
            '<tr><td>%s</td><td>%s</td><td>%s</td></tr>\n' % (buttons.room_join_button(room),
                                                              room, people)
        '</table></blockquote>\n'
        page.trailer()

    #
    # Access to recordings.
    #
    @export
    def recordings [html] (self):
        user = self.logged_in()
        if not user:
            return get_response().redirect(config.SITE_URL)
        page.header('/recordings', 'Available recordings', user.is_admin())
        '''<table class="OddEven">
           <tr><th>Server</th><th>Room</th><th>Start</th><th>Length</th><th>View</th></tr>
           '''
        recs = [ ]
        for server in bbb.all_servers():
            recs += bbb.recordings(server)
        for rec in sorted(recs, key = lambda r: r.start):
            '''<tr><td>%s</td><td>%s</td><td>%s</td><td align="right">%s</td>
                   <td><a href="%s">View</a></td></tr>
                   ''' % (rec.server.split(str('.'))[0], rec.meeting,
                          rec.start.strftime(str('%Y-%m-%d %H:%M')),
                          self.format_len(rec.length),
                          rec.url)
        '</table>\n'
        page.trailer()

    def format_len(self, length):
        ret = ''
        if length > 3600:
            ret = '%d:' % (length/3600)
        if length > 60:
            ret += '%02d:' % ((length/60) % 60)
        return ret + '%02d' % (length % 60)

    #
    # Yet another hack: this serves out the special CSS that we inject into
    # BBB to hide the "end meeting" button for moderators.
    #
    @export
    def bbb_css(self):
        get_response().set_content_type('text/css')
        return 'li[aria-labelledby="dropdown-item-label-47"] { display: none; }\n'

#
# The login form
#
class LoginForm:
    def __init__(self, email = '', target = ''):
        self.email = StringWidget(name="email", size = 30, value = email,
                                  id="loginemail", placeholder="Email address")
        self.pw = PasswordWidget(name = 'Password', size = 30, id="logincode",
                                 placeholder="Registration Confirmation Number")
        self._target = HiddenWidget(name = 'target', value = target)

    def render [html] (self, target):
        '''<form action=%s method="post">
           %s
           %s
           %s %s
           <hr>
           To receive a reminder email containing your confirmation number,
           please enter the email address you used to register above and
           click here:
           <p>
           %s
           </form>
           ''' % (target, self.email.render(), self.pw.render(),
                  SubmitWidget(name = 'login', value = 'Log in').render(),
                  self._target.render(),
                  SubmitWidget(name = 'reminder', value = 'Send reminder').render())

    def parse(self):
        return (self.email.parse(), self.pw.parse())

    def target(self):
        return self._target.parse() or ''

class GuestForm:
    def __init__(self):
        self.name = StringWidget(name="name", size = 30, value = '',
                                  id="guestname", placeholder="Full name")

    def render [html] (self):
        '''<blockquote>
           <form action="guest_login" method="post">%s%s</form>
           </blockquote>''' % (self.name.render(),
                               SubmitWidget(name='login',
                                            value = 'Log in as guest').render())

    def parse(self):
        return self.name.parse()

#
# Let's see if we can magically get their timezone offset
#
def insert_tz_js [html] ():
    '''<script type="text/javascript">
       <!--
       function setTZCookie() {
           off = new Date().getTimezoneOffset();
           document.cookie = "tzoffset=" + off + "; SameSite=strict;";
       }
       window.onload = setTZCookie;
       // -->
       </script>
       '''


#
# A kludgy time selector to be used before production.
#
weekdays = [ (6, 'Sunday'), (0, 'Monday'), (1, 'Tuesday'), (2, 'Wednesday'),
             (3, 'Thursday'), (4, 'Friday'), (5, 'Saturday') ]

class time_selector_widget:
    def __init__(self, weekday, hour):
        self.wday = SingleSelectWidget(name = 'weekday', value = weekday,
                                       options = weekdays)
        hours = [ (hour, '%d:00' % (hour)) for hour in range(24) ]
        self.hour = SingleSelectWidget(name = 'hour', value = hour,
                                       options = hours)

    def render [html] (self):
        '''<blockquote>
           <form action="fake_time" method="post">
           <table> <!-- dont ask -->
           <tr><td>See schedule at</td><td>%s</td><td>on</td><td>%s.</td>
               <td>%s</td></tr>
           </table>
           </form>
           </blockquote>
           ''' % (self.hour.render(), self.wday.render(),
                  SubmitWidget("Go", "Go").render())

    def parse(self):
        return (int(self.wday.parse()), int(self.hour.parse()))

#
# Send an email reminder.
#
EmailTemplate = '''
You (hopefully) requested a reminder of your confirmation number for 
%s.  Your login credentials are:

  Email address:     %s
  Registration code: %s

You may enter these at %s to join the conference.

Thanks for participating in LPC, we look forward to seeing you in the
sessions!
'''

def send_reminder(email, id):
    # Yes, you really do have to set the default explicitly
    msg = EmailMessage(policy = policy.default)
    msg.set_content(EmailTemplate % (config.EVENT, email, id, config.SITE_URL))
    msg.set_charset('utf-8')
    msg['To'] = email
    msg['From'] = config.EMAIL_FROM
    msg['Subject'] = 'LPC 2021 confirmation number reminder'
    msg['Date'] = datetime.datetime.now()
    server = smtplib.SMTP(config.SMTP_SERVER, port = 587)
    server.send_message(msg, from_addr = config.EMAIL_FROM)
    server.quit()