Add Person model to GUI

piket_client/gui.py

@@ -3,7 +3,6 @@ Provides the graphical front-end for Piket.
 """
 import os
 import sys
-from urllib.parse import urljoin
 
 # pylint: disable=E0611
 from PySide2.QtWidgets import (
@@ -20,7 +19,6 @@ from PySide2.QtGui import QIcon
 from PySide2.QtCore import QSize, Qt
 
 # pylint: enable=E0611
-import requests
 
 try:
     import dbus
@@ -28,6 +26,7 @@ except ImportError:
     dbus = None
 
 from piket_client.sound import PLOP_WAVE
+from piket_client.model import Person
 
 
 def plop() -> None:
@@ -35,46 +34,31 @@ def plop() -> None:
     PLOP_WAVE.play()
 
 
-SERVER_URL = "http://127.0.0.1:5000"
-
-
-def get_people() -> [dict]:
-    """ Request list of active people from the server. """
-    request = requests.get(urljoin(SERVER_URL, "/people"))
-    return request.json()["people"]
-
-
 class NameButton(QPushButton):
     """ Wraps a QPushButton to provide a counter. """
 
-    def __init__(self, person: dict, *args, **kwargs) -> None:
-        self.person_id = person["person_id"]
-        self.name = person["name"]
-        self.count = person["consumptions"]["1"]
+    def __init__(self, person: Person, *args, **kwargs) -> None:
+        self.person = person
+        self.count = person.consumptions["1"]
 
         super().__init__(self.current_label, *args, **kwargs)
         self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
 
-        self.clicked.connect(self.plop)
+        self.clicked.connect(self.process_click)
 
     @property
     def current_label(self) -> str:
         """ Return the label to show on the button. """
-        return f"{self.name} ({self.count})"
+        return f"{self.person.name} ({self.count})"
 
-    def plop(self) -> None:
+    def process_click(self) -> None:
         """ Process a click on this button. """
-        req = requests.post(
-            urljoin(SERVER_URL, f"people/{self.person_id}/add_consumption")
-        )
-        if req.status_code == 200:
-            json = req.json()
-            person = json["person"]
-            self.count = person["consumptions"]["1"]
+        if self.person.add_consumption():
+            self.count = self.person.consumptions["1"]
             self.setText(self.current_label)
             plop()
         else:
-            print("Oh shit kapot")
+            print("Jantoeternuitje, kapot")
 
 
 class NameButtons(QWidget):
@@ -92,7 +76,7 @@ class NameButtons(QWidget):
         for each. """
         self.layout = QGridLayout()
 
-        for index, person in enumerate(get_people()):
+        for index, person in enumerate(Person.get_all()):
             button = NameButton(person)
             self.layout.addWidget(button, index // 2, index % 2)
 
@@ -175,9 +159,8 @@ class PiketMainWindow(QMainWindow):
         )
         self.hide_keyboard()
         if ok and name:
-            req = requests.post(
-                urljoin(SERVER_URL, "people"), json={"person": {"name": name}}
-            )
+            person = Person(name=name)
+            person = person.save()
 
             self.main_widget = NameButtons()
             self.setCentralWidget(self.main_widget)

piket_client/logger.py

@@ -0,0 +1,7 @@
+import logging
+from logging import getLogger
+
+logging.basicConfig(
+        format='%(asctime)s - %(name)s - %(levelname)s: %(message)s',
+        level=logging.INFO
+)

piket_client/model.py

@@ -0,0 +1,125 @@
+'''
+Provides access to the models stored in the database, via the server.
+'''
+from typing import NamedTuple
+from urllib.parse import urljoin
+
+import requests
+
+from . import logger
+
+LOG = logger.getLogger('model')
+
+SERVER_URL = "http://127.0.0.1:5000"
+
+class Person(NamedTuple):
+    ''' Represents a Person, as retrieved from the database. '''
+    name: str
+    person_id: int = None
+    consumptions: dict = {}
+
+    def add_consumption(self) -> bool:
+        ''' Register a consumption for this Person. '''
+        req = requests.post(
+            urljoin(SERVER_URL, f'people/{self.person_id}/add_consumption')
+        )
+        try:
+            data = req.json()
+
+            if 'error' in data:
+                LOG.error(
+                    'Could not add consumption for %s (%s): %s',
+                    self.person_id, req.status_code, data
+                )
+                return False
+
+            self.consumptions.update(data['person']['consumptions'])
+
+            return True
+        except ValueError:
+            LOG.error(
+                'Did not get JSON on adding Consumption (%s): %s',
+                req.status_code, req.content
+            )
+            return False
+
+    def create(self) -> 'Person':
+        ''' Create a new Person from the current attributes. As tuples are
+        immutable, a new Person with the correct id is returned. '''
+        req = requests.post(
+            urljoin(SERVER_URL, "people"), json={"person": {"name": self.name}}
+        )
+
+        try:
+            data = req.json()
+        except ValueError:
+            LOG.error(
+                'Did not get JSON on adding Person (%s): %s',
+                req.status_code, req.content
+            )
+            return None
+
+        if 'error' in data or req.status_code != 201:
+            LOG.error(
+                'Could not create Person (%s): %s',
+                req.status_code, data
+            )
+            return None
+
+        return Person.from_dict(data['person'])
+
+    @classmethod
+    def get(cls, person_id: int) -> 'Person':
+        ''' Retrieve a Person by id. '''
+        req = requests.get(urljoin(SERVER_URL, f'/people/{person_id}'))
+
+        try:
+            data = req.json()
+
+            if 'error' in data:
+                LOG.warning(
+                    'Could not get person %s (%s): %s',
+                    person_id, req.status_code, data
+                )
+                return None
+
+            return Person.from_dict(data['person'])
+
+        except ValueError:
+            LOG.error(
+                'Did not get JSON from server on getting Person (%s): %s',
+                req.status_code, req.content
+            )
+            return None
+
+    @classmethod
+    def get_all(cls) -> ['Person']:
+        ''' Get all active People. '''
+        req = requests.get(urljoin(SERVER_URL, '/people'))
+
+        try:
+            data = req.json()
+
+            if 'error' in data:
+                LOG.warning(
+                    'Could not get people (%s): %s',
+                    req.status_code, data
+                )
+
+            return [Person.from_dict(item) for item in data['people']]
+
+        except ValueError:
+            LOG.error(
+                'Did not get JSON from server on getting People (%s): %s',
+                req.status_code, req.content
+            )
+            return None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Person':
+        ''' Reconstruct a Person object from a dict. '''
+        return Person(
+            name = data['name'],
+            person_id = data['person_id'],
+            consumptions = data['consumptions']
+        )

piket_server/__init__.py

@@ -179,7 +179,7 @@ def add_person():
     except SQLAlchemyError:
         return jsonify({"error": "Invalid arguments for Person."})
 
-    return jsonify(person=person.as_dict)
+    return jsonify(person=person.as_dict), 201
 
 
 @app.route("/people/<int:person_id>/add_consumption", methods=["POST"])
@@ -198,4 +198,4 @@ def add_consumption(person_id: int):
             400,
         )
 
-    return jsonify(person=person.as_dict, consumption=consumption.as_dict)
+    return jsonify(person=person.as_dict, consumption=consumption.as_dict), 201