Additional loading functions.

dsst/dsst_server/data_access/mapping.py

@@ -10,20 +10,46 @@ def map_base_fields(cls, db_model):
     return model
 
 
+def db_to_drink(drink: 'sql.Drink'):
+    return map_base_fields(models.Drink, drink)
+
+
 def db_to_enemy(enemy: 'sql.Enemy'):
     return map_base_fields(models.Enemy, enemy)
 
 
 def db_to_player(player: 'sql.Player'):
-    model = map_base_fields(models.Player, player)
+    return map_base_fields(models.Player, player)
+
+
+def db_to_penalty(penalty: 'sql.Penalty'):
+    model = map_base_fields(models.Penalty, penalty)
+    model.drink = db_to_drink(penalty.drink)
+    model.player = db_to_player(penalty.player)
+    return model
+
+
+def db_to_death(death: 'sql.Death'):
+    model = map_base_fields(models.Death, death)
+    model.player = db_to_player(death.player)
+    model.enemy = db_to_enemy(death.enemy)
+    model.penalties = [db_to_penalty(penalty) for penalty in death.penalties]
+    return model
+
+
+def db_to_victory(victory: 'sql.Victory'):
+    model = map_base_fields(models.Victory, victory)
+    model.player = db_to_player(victory.player)
+    model.enemy = db_to_enemy(victory.enemy)
     return model
 
 
 def db_to_episode(episode: 'sql.Episode'):
     model = map_base_fields(models.Episode, episode)
     model.players = [db_to_player(player) for player in episode.players]
-    model.deaths = []
-    model.victories = []
+    model.deaths = [db_to_death(death) for death in episode.deaths]
+    model.victories = [db_to_victory(victory) for victory in episode.victories]
+    return model
 
 
 def db_to_season(season: 'sql.Season'):

dsst/dsst_server/read_functions.py

@@ -13,7 +13,16 @@ class ReadFunctions:
     def load_seasons_all(*_):
         return [shortcuts.model_to_dict(season, backrefs=True, max_depth=2) for season in sql.Season.select()]
 
+    @staticmethod
+    def load_episodes(season_id, *_):
+        if not season_id:
+            raise Exception('Exception: Missing argument (season_id)')
+        return [mapping.db_to_episode(ep) for ep in sql.Season.get(sql.Season.id == season_id).episodes]
+
     @staticmethod
     def load_players(*_):
         return [mapping.db_to_player(player) for player in sql.Player.select()]
 
+    @staticmethod
+    def load_drinks(*_):
+        return [mapping.db_to_drink(drink) for drink in sql.Drink.select()]

dsst/dsst_server/server.py

@@ -6,7 +6,7 @@ import sys
 import os
 
 from common import util, models
-from dsst_server import read_functions, write_functions
+from dsst_server import read_functions, write_functions, tokens
 from dsst_server.func_proxy import FunctionProxy
 from dsst_server.data_access import sql
 
@@ -23,12 +23,19 @@ class DsstServer:
         self.socket_server.bind((HOST, PORT))
         print(f'Bound socket to {PORT} on host {HOST}')
 
-        self.read_actions = util.list_class_methods(read_functions.ReadFunctions)
-        self.write_actions = util.list_class_methods(write_functions.WriteFunctions)
+        # Initialize database
         sql.db.init('dsst', user='dsst', password='dsst')
+        print(f'Database initialized ({sql.db.database})')
 
-        self.key_access = {'a': self.read_actions,
-                           'b': self.read_actions + self.write_actions}
+        # Load access tokens and map them to their allowed methods
+        read_actions = util.list_class_methods(read_functions.ReadFunctions)
+        write_actions = util.list_class_methods(write_functions.WriteFunctions)
+        parm_access = {
+            'r': read_actions,
+            'rw': read_actions + write_actions
+        }
+        self.tokens = {token: parm_access[perms] for token, perms in tokens.TOKENS}
+        print(f'Loaded auth tokens: {self.tokens.keys()}')
 
     def run(self):
         self.socket_server.listen(5)
@@ -41,17 +48,22 @@ class DsstServer:
                 data = util.recv_msg(client)
                 request = pickle.loads(data)
                 print(f'Request: {request}')
-                # Validate auth key in request
-                key = request.get('auth_key')
-                if key not in self.key_access:
-                    util.send_msg(client, pickle.dumps({'success': False, 'message': 'Auth Key invalid'}))
-                    print(f'Rejected request from {address}. Auth key invalid ({key})')
+                # Validate auth token in request
+                token = request.get('auth_token')
+                if token not in self.tokens:
+                    util.send_msg(client, pickle.dumps({'success': False, 'message': 'Auth token invalid'}))
+                    print(f'Rejected request from {address}. Auth token invalid ({token})')
                     continue
                 # Check read functions
                 action_name = request.get('action')
-                if action_name in self.key_access[key]:
+                if action_name in self.tokens[token]:
                     action = getattr(FunctionProxy, action_name)
-                    value = action(request.get('args'))
+                    try:
+                        value = action(request.get('args'))
+                    except Exception as e:
+                        response = {'success': False, 'message': f'Exception was thrown on server.\n{e}'}
+                        util.send_msg(client, pickle.dumps(response))
+                        raise
                     response = {'success': True, 'data': value}
                     util.send_msg(client, pickle.dumps(response))
                     continue

dsst/dsst_server/tokens.py

@@ -0,0 +1,5 @@
+# Define access tokens here
+#  i.E: { 'read': ['a', 'b''],
+#         'write': ['a']
+#       }
+TOKENS = [('a', 'rw'), ('b', 'r')]