Development

docker/routlin-dash/app/session_interface.py

@@ -1,10 +1,11 @@
-import json
 import sqlite3
 import time
 import uuid
 from flask.sessions import SessionInterface, SessionMixin
 from werkzeug.datastructures import CallbackDict
 
+_LEVEL_INT_TO_STR = {0: 'nothing', 1: 'viewer', 2: 'administrator', 3: 'manager'}
+
 
 class SqliteSession(CallbackDict, SessionMixin):
     def __init__(self, initial=None, sid=None, new=False):
@@ -19,31 +20,13 @@ class SqliteSession(CallbackDict, SessionMixin):
 class SqliteSessionInterface(SessionInterface):
     def __init__(self, db_path):
         self.db_path = db_path
-        self._init_db()
 
     def _connect(self):
         con = sqlite3.connect(self.db_path, timeout=5)
         con.execute('PRAGMA journal_mode=WAL')
+        con.row_factory = sqlite3.Row
         return con
 
-    def _init_db(self):
-        try:
-            con = self._connect()
-            con.execute('''
-                CREATE TABLE IF NOT EXISTS sessions (
-                    session_id   TEXT PRIMARY KEY,
-                    email        TEXT NOT NULL DEFAULT '',
-                    access_level TEXT NOT NULL DEFAULT '',
-                    data_json    TEXT NOT NULL DEFAULT '{}',
-                    created_at   INTEGER NOT NULL,
-                    last_seen    INTEGER NOT NULL
-                )
-            ''')
-            con.commit()
-            con.close()
-        except Exception:
-            pass
-
     def open_session(self, app, request):
         name = app.config.get('SESSION_COOKIE_NAME', 'session')
         sid  = request.cookies.get(name)
@@ -51,11 +34,24 @@ class SqliteSessionInterface(SessionInterface):
             try:
                 con = self._connect()
                 row = con.execute(
-                    'SELECT data_json FROM sessions WHERE session_id=?', (sid,)
+                    '''SELECT s.session_id, s.account_id, s.tz_offset_seconds,
+                              s.apply_changes_immediately,
+                              a.email, a.access_level
+                       FROM sessions s
+                       JOIN accounts a ON a.account_id = s.account_id
+                       WHERE s.session_id=?''',
+                    (sid,)
                 ).fetchone()
                 con.close()
                 if row:
-                    return SqliteSession(json.loads(row[0]), sid=sid, new=False)
+                    data = {
+                        'account_id':                str(row['account_id']),
+                        'email_address':             str(row['email']),
+                        'access_level':              _LEVEL_INT_TO_STR.get(row['access_level'], 'viewer'),
+                        'tz_offset_seconds':         int(row['tz_offset_seconds']),
+                        'apply_changes_immediately': bool(row['apply_changes_immediately']),
+                    }
+                    return SqliteSession(data, sid=sid, new=False)
             except Exception:
                 pass
         return SqliteSession(sid=str(uuid.uuid4()), new=True)
@@ -77,29 +73,33 @@ class SqliteSessionInterface(SessionInterface):
             response.delete_cookie(name, domain=domain, path=path)
             return
 
-        now   = int(time.time())
-        email = session.get('email_address', '')
-        level = session.get('access_level', '')
+        account_id = session.get('account_id')
+        if not account_id:
+            return
+
+        now           = int(time.time())
+        tz_offset     = int(session.get('tz_offset_seconds', 0))
+        apply_changes = 1 if session.get('apply_changes_immediately') else 0
 
         try:
             con = self._connect()
             if session.new:
-                if not session.modified:
-                    con.close()
-                    return
                 con.execute(
-                    'INSERT INTO sessions(session_id,email,access_level,data_json,created_at,last_seen)'
-                    ' VALUES(?,?,?,?,?,?)',
-                    (session.sid, email, level, json.dumps(dict(session)), now, now)
+                    '''INSERT INTO sessions
+                       (session_id, account_id, tz_offset_seconds, apply_changes_immediately,
+                        session_started_ts, last_seen_ts)
+                       VALUES (?,?,?,?,?,?)''',
+                    (session.sid, account_id, tz_offset, apply_changes, now, now)
                 )
             elif session.modified:
                 con.execute(
-                    'UPDATE sessions SET email=?,access_level=?,data_json=?,last_seen=? WHERE session_id=?',
-                    (email, level, json.dumps(dict(session)), now, session.sid)
+                    '''UPDATE sessions SET tz_offset_seconds=?, apply_changes_immediately=?,
+                       last_seen_ts=? WHERE session_id=?''',
+                    (tz_offset, apply_changes, now, session.sid)
                 )
             else:
                 con.execute(
-                    'UPDATE sessions SET last_seen=? WHERE session_id=?',
+                    'UPDATE sessions SET last_seen_ts=? WHERE session_id=?',
                     (now, session.sid)
                 )
             con.commit()