Make a mess but also working consumption type switching

piket_client/gui.py

 
 # pylint: disable=E0611
 from PySide2.QtWidgets import (
+    QAction,
+    QActionGroup,
     QApplication,
     QGridLayout,
     QInputDialog,
     QWidget,
 )
 from PySide2.QtGui import QIcon
-from PySide2.QtCore import QSize, Qt
+from PySide2.QtCore import QSize, Qt, QObject, Signal, Slot
 
 # pylint: enable=E0611
 
     dbus = None
 
 from piket_client.sound import PLOP_WAVE
-from piket_client.model import Person
+from piket_client.model import Person, ConsumptionType
 
 
 def plop() -> None:
 class NameButton(QPushButton):
     """ Wraps a QPushButton to provide a counter. """
 
-    def __init__(self, person: Person, *args, **kwargs) -> None:
+    def __init__(self, person: Person, active_id: str, *args, **kwargs) -> None:
         self.person = person
-        self.count = person.consumptions["1"]
+        self.active_id = active_id
 
         super().__init__(self.current_label, *args, **kwargs)
         self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
 
         self.clicked.connect(self.process_click)
 
+    @Slot(str)
+    def new_active_id(self, new_id: str):
+        self.active_id = new_id
+        self.setText(self.current_label)
+
+    @property
+    def active_consumption_type_id(self) -> str:
+        return self.parent().active_consumption_type_id
+
+    @property
+    def current_count(self) -> int:
+        return self.person.consumptions.get(self.active_id, 0)
+
     @property
     def current_label(self) -> str:
         """ Return the label to show on the button. """
-        return f"{self.person.name} ({self.count})"
+        return f"{self.person.name} ({self.current_count})"
 
     def process_click(self) -> None:
         """ Process a click on this button. """
-        if self.person.add_consumption():
-            self.count = self.person.consumptions["1"]
+        if self.person.add_consumption(self.active_id):
             self.setText(self.current_label)
             plop()
         else:
     """ Main widget responsible for capturing presses and registering them.
     """
 
-    def __init__(self) -> None:
+    new_id_set = Signal(str)
+
+    def __init__(self, consumption_type_id) -> None:
         super().__init__()
 
         self.layout = None
+        self.active_consumption_type_id = consumption_type_id
         self.init_ui()
 
+    @Slot(str)
+    def consumption_type_changed(self, new_id: str):
+        self.active_consumption_type_id = new_id
+        self.new_id_set.emit(new_id)
+
     def init_ui(self) -> None:
         """ Initialize UI: build GridLayout, retrieve People and build a button
         for each. """
         self.layout = QGridLayout()
 
         for index, person in enumerate(Person.get_all()):
-            button = NameButton(person)
+            button = NameButton(person, self.active_consumption_type_id, self)
+            self.new_id_set.connect(button.new_active_id)
             self.layout.addWidget(button, index // 2, index % 2)
 
         self.setLayout(self.layout)
     """ QMainWindow subclass responsible for showing the main application
     window. """
 
+    consumption_type_changed = Signal(str)
+
     def __init__(self) -> None:
         super().__init__()
 
         # Go full screen
         self.setWindowState(Qt.WindowActive | Qt.WindowFullScreen)
 
-        # Initialize main widget
-        self.main_widget = NameButtons()
-        self.setCentralWidget(self.main_widget)
-
         font_metrics = self.fontMetrics()
         icon_size = font_metrics.height() * 2
 
         self.toolbar.addWidget(self.create_spacer())
 
         # Right
-        self.toolbar.addAction(self.load_icon("beer_bottle.svg"), "Bierrr")
+        ag = QActionGroup(self.toolbar)
+        ag.setExclusive(True)
+
+        for ct in ConsumptionType.get_all():
+            action = QAction(
+                self.load_icon(ct.icon or 'beer_bottle.svg'),
+                ct.name,
+                ag
+            )
+            action.setCheckable(True)
+            action.setData(str(ct.consumption_type_id))
+
+        ag.actions()[0].setChecked(True)
+        [self.toolbar.addAction(a) for a in ag.actions()]
+        ag.triggered.connect(self.consumption_type_change)
+
         self.addToolBar(self.toolbar)
 
+        # Initialize main widget
+        self.main_widget = NameButtons(ag.actions()[0].data())
+        self.consumption_type_changed.connect(self.main_widget.consumption_type_changed)
+        self.setCentralWidget(self.main_widget)
+
+
+    @Slot(QAction)
+    def consumption_type_change(self, action: QAction):
+        self.consumption_type_changed.emit(action.data())
+
     def show_keyboard(self) -> None:
         ''' Show the virtual keyboard, if possible. '''
         if self.osk:

piket_client/model.py

     person_id: int = None
     consumptions: dict = {}
 
-    def add_consumption(self) -> bool:
+    def add_consumption(self, type_id: str) -> bool:
         ''' Register a consumption for this Person. '''
         req = requests.post(
-            urljoin(SERVER_URL, f'people/{self.person_id}/add_consumption')
+            urljoin(SERVER_URL,
+                f'people/{self.person_id}/add_consumption/{type_id}')
         )
         try:
             data = req.json()
             person_id = data['person_id'],
             consumptions = data['consumptions']
         )
+
+class ConsumptionType(NamedTuple):
+    ''' Represents a stored ConsumptionType. '''
+
+    name: str
+    consumption_type_id: int = None
+    icon: str = None
+
+    def create(self) -> 'Person':
+        ''' Create a new ConsumptionType from the current attributes. As tuples
+        are immutable, a new ConsumptionType with the correct id is returned.
+        '''
+        req = requests.post(
+            urljoin(SERVER_URL, "consumption_types"), json={"consumption_type":
+                {"name": self.name, "icon": self.icon}}
+        )
+
+        try:
+            data = req.json()
+        except ValueError:
+            LOG.error(
+                'Did not get JSON on adding ConsumptionType (%s): %s',
+                req.status_code, req.content
+            )
+            return None
+
+        if 'error' in data or req.status_code != 201:
+            LOG.error(
+                'Could not create ConsumptionType (%s): %s',
+                req.status_code, data
+            )
+            return None
+
+        return Person.from_dict(data['consumption_type'])
+
+    @classmethod
+    def get(cls, consumption_type_id: int) -> 'ConsumptionType':
+        ''' Retrieve a ConsumptionType by id. '''
+        req = requests.get(urljoin(SERVER_URL,
+            f'/consumption_types/{consumption_type_id}'))
+
+        try:
+            data = req.json()
+
+            if 'error' in data:
+                LOG.warning(
+                    'Could not get consumption type %s (%s): %s',
+                    consumption_type_id, req.status_code, data
+                )
+                return None
+
+            return cls.from_dict(data['consumption_type'])
+
+        except ValueError:
+            LOG.error(
+                'Did not get JSON from server on getting consumption type (%s): %s',
+                req.status_code, req.content
+            )
+            return None
+
+    @classmethod
+    def get_all(cls) -> ['ConsumptionType']:
+        ''' Get all active ConsumptionTypes. '''
+        req = requests.get(urljoin(SERVER_URL, '/consumption_types'))
+
+        try:
+            data = req.json()
+
+            if 'error' in data:
+                LOG.warning(
+                    'Could not get consumption types (%s): %s',
+                    req.status_code, data
+                )
+
+            return [cls.from_dict(item) for item in data['consumption_types']]
+
+        except ValueError:
+            LOG.error(
+                'Did not get JSON from server on getting ConsumptionTypes (%s): %s',
+                req.status_code, req.content
+            )
+            return None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ConsumptionType':
+        ''' Reconstruct a ConsumptionType from a dict. '''
+        return ConsumptionType(
+            name = data['name'],
+            consumption_type_id = data['consumption_type_id'],
+            icon = data.get('icon')
+        )

piket_server/__init__.py

 NEXT_ID = len(PEOPLE)
 
 
+# Person
 @app.route("/people", methods=["GET"])
 def get_people():
     """ Return a list of currently known people. """
         db.session.add(person)
         db.session.commit()
     except SQLAlchemyError:
-        return jsonify({"error": "Invalid arguments for Person."})
+        return jsonify({"error": "Invalid arguments for Person."}), 400
 
     return jsonify(person=person.as_dict), 201
 
         )
 
     return jsonify(person=person.as_dict, consumption=consumption.as_dict), 201
+
+@app.route("/people/<int:person_id>/add_consumption/<int:ct_id>", methods=["POST"])
+def add_consumption2(person_id: int, ct_id: int):
+    person = Person.query.get_or_404(person_id)
+
+    consumption = Consumption(person=person, consumption_type_id=ct_id)
+    try:
+        db.session.add(consumption)
+        db.session.commit()
+    except SQLAlchemyError:
+        return (
+            jsonify(
+                {"error": "Invalid Consumption parameters.", "person": person.as_dict}
+            ),
+            400,
+        )
+
+    return jsonify(person=person.as_dict, consumption=consumption.as_dict), 201
+
+
+# ConsumptionType
+@app.route("/consumption_types", methods=["GET"])
+def get_consumption_types():
+    ''' Return a list of currently active consumption types. '''
+    ctypes = ConsumptionType.query.all()
+    result = [ct.as_dict for ct in ctypes]
+    return jsonify(consumption_types=result)
+
+@app.route("/consumption_types/<int:consumption_type_id>", methods=["GET"])
+def get_consumption_type(consumption_type_id: int):
+    ct = ConsumptionType.query.get_or_404(consumption_type_id)
+
+    return jsonify(consumption_type=ct.as_dict)
+
+@app.route("/consumption_types", methods=["POST"])
+def add_consumption_type():
+    """ Add a new ConsumptionType.  """
+    json = request.get_json()
+
+    if not json:
+        return jsonify({"error": "Could not parse JSON."}), 400
+
+    data = json.get('consumption_type') or {}
+    ct = ConsumptionType(
+        name=data.get('name'),
+        icon=data.get('icon')
+    )
+
+    try:
+        db.session.add(ct)
+        db.session.commit()
+    except SQLAlchemyError:
+        return jsonify({'error': 'Invalid arguments for ConsumptionType.'}), 400
+
+    return jsonify(consumption_type=ct.as_dict), 201