afslutin

piket_client/gui.py

     QApplication,
     QGridLayout,
     QInputDialog,
+    QLineEdit,
     QMainWindow,
     QMessageBox,
     QPushButton,
     dbus = None
 
 from piket_client.sound import PLOP_WAVE, UNDO_WAVE
-from piket_client.model import Person, ConsumptionType, Consumption, ServerStatus
+from piket_client.model import Person, ConsumptionType, Consumption, ServerStatus, Settlement
 import piket_client.logger
 
 LOG = logging.getLogger(__name__)
 
     def process_click(self) -> None:
         """ Process a click on this button. """
+        LOG.debug('Button clicked.')
         result = self.person.add_consumption(self.active_id)
         if result:
             plop()
             self.setText(self.current_label)
             self.consumption_created.emit(result)
         else:
-            print("Jantoeternuitje, kapot")
+            LOG.error("Failed to add consumption", extra={'person':
+                self.person})
 
     def confirm_hide(self) -> None:
+        LOG.debug('Button right-clicked.')
         ok = QMessageBox.warning(
             self.window(),
             "Persoon verbergen?",
     def consumption_type_changed(self, new_id: str):
         """ Process a change of the consumption type and propagate to the
         contained buttons. """
+        LOG.debug('Consumption type updated in NameButtons.',
+                extra={'new_id': new_id})
         self.active_consumption_type_id = new_id
         self.new_id_set.emit(new_id)
 
         """ Initialize UI: build GridLayout, retrieve People and build a button
         for each. """
 
+        LOG.debug('Initializing NameButtons.')
+
         ps = Person.get_all(True)
         num_columns = round(len(ps) / 10) + 1
 
     consumption_type_changed = Signal(str)
 
     def __init__(self) -> None:
+        LOG.debug('Initializing PiketMainWindow.')
         super().__init__()
 
         self.main_widget = None
         self.toolbar = None
         self.osk = None
         self.undo_action = None
-        self.undo_queue = collections.deque([], 20)
+        self.undo_queue = collections.deque([], 15)
         self.init_ui()
 
     def init_ui(self) -> None:
 
     # Load main window
     main_window = PiketMainWindow()
+
+    # Test unsettled consumptions
+    status = ServerStatus.unsettled_consumptions()
+
+    unsettled = status['unsettled']['amount']
+
+    if unsettled > 0:
+        first = status['unsettled']['first']
+        first_date = first.strftime('%c')
+        ok = QMessageBox.information(
+            None,
+            "Onafgesloten lijst",
+            f"Wil je verdergaan met een lijst met {unsettled} onafgesloten "
+            f"consumpties sinds {first_date}?",
+            QMessageBox.Yes,
+            QMessageBox.No
+        )
+        if ok == QMessageBox.No:
+            main_window.show_keyboard()
+            name, ok = QInputDialog.getText(
+                None,
+                "Lijst afsluiten",
+                "Voer een naam in voor de lijst of druk op OK. Laat de datum "
+                "staan.",
+                QLineEdit.Normal,
+                f"{first.strftime('%Y-%m-%d')}"
+            )
+            main_window.hide_keyboard()
+
+            if name and ok:
+                settlement = Settlement.create(name)
+                info = [f'{item["count"]} {item["name"]}' for item in
+                settlement.consumption_summary.values()]
+                info = ', '.join(info)
+                QMessageBox.information(
+                    None,
+                    "Lijst afgesloten",
+                    f"VO! Op deze lijst stonden: {info}"
+                )
+
+                main_window = PiketMainWindow()
+
     main_window.show()
 
     # Let's go

piket_client/model.py

         except requests.ConnectionError as ex:
             return False, ex
 
+    datetime_format = "%Y-%m-%dT%H:%M:%S.%f"
+    @classmethod
+    def unsettled_consumptions(cls) -> dict:
+        req = requests.get(urljoin(SERVER_URL, 'status'))
+
+        data = req.json()
+
+        if data['unsettled']['amount']:
+            data['unsettled']['first'] = datetime.datetime\
+                    .strptime(data['unsettled']['first'],
+                            cls.datetime_format)
+            data['unsettled']['last'] = datetime.datetime\
+                    .strptime(data['unsettled']['last'],
+                            cls.datetime_format)
+
+        return data
+
+
 
 class Person(NamedTuple):
     """ Represents a Person, as retrieved from the database. """
                 req.content,
             )
             return False
+
+class Settlement(NamedTuple):
+    """ Represents a stored Settlement. """
+    settlement_id: int
+    name: str
+    consumption_summary: dict
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Settlement":
+        return Settlement(
+            settlement_id=data['settlement_id'],
+            name=data['name'],
+            consumption_summary=data['consumption_summary']
+        )
+
+    @classmethod
+    def create(cls, name: str) -> "Settlement":
+        req = requests.post(
+            urljoin(SERVER_URL, '/settlements'),
+            json={'settlement': {'name': name}}
+        )
+
+        return cls.from_dict(req.json()['settlement'])

piket_server/__init__.py

 import os
 
 from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy import func
 from flask import Flask, jsonify, abort, request
 from flask_sqlalchemy import SQLAlchemy
 
             "name": self.name,
             "consumptions": {
                 ct.consumption_type_id: Consumption.query.filter_by(person=self)
+                .filter_by(settlement=None)
                 .filter_by(consumption_type=ct)
                 .filter_by(reversed=False)
                 .count()
     def __repr__(self) -> str:
         return f"<Settlement {self.settlement_id}: {self.name}>"
 
+    @property
+    def as_dict(self) -> dict:
+        return {
+            'settlement_id': self.settlement_id,
+            'name': self.name,
+            'consumption_summary': self.consumption_summary
+        }
+
+    @property
+    def consumption_summary(self) -> dict:
+        q = Consumption.\
+                query.\
+                filter_by(settlement=self).\
+                group_by(Consumption.consumption_type_id).\
+                outerjoin(ConsumptionType).\
+                with_entities(
+                    Consumption.consumption_type_id,
+                    ConsumptionType.name,
+                    func.count(Consumption.consumption_id),
+                ).\
+                all()
+
+        return {r[0]: {'name': r[1], 'count': r[2]} for r in q}
+
 
 class ConsumptionType(db.Model):
     """ Represents a type of consumption to be counted. """
     """ Return a status ping. """
     return "Pong"
 
+@app.route("/status")
+def status() -> None:
+    """ Return a status dict with info about the database. """
+    unsettled_q = Consumption.query.\
+            filter_by(settlement=None).\
+            filter_by(reversed=False)
+
+    unsettled = unsettled_q.count()
+
+    first = None
+    last = None
+    if unsettled:
+        last = unsettled_q.\
+                order_by(Consumption.created_at.desc()).\
+                first().\
+                created_at.isoformat()
+        first = unsettled_q.\
+                order_by(Consumption.created_at.asc())\
+                .first()\
+                .created_at.isoformat()
+
+    return jsonify({
+        'unsettled': {
+            'amount': unsettled,
+            'first': first,
+            'last': last,
+        },
+    })
+
 
 # Person
 @app.route("/people", methods=["GET"])
         return jsonify({"error": "Invalid arguments for ConsumptionType."}), 400
 
     return jsonify(consumption_type=ct.as_dict), 201
+
+# Settlement
+@app.route("/settlements", methods=["GET"])
+def get_settlements():
+    """ Return a list of the active Settlements. """
+    result = Settlement.query.all()
+    return jsonify(settlements=[s.as_dict for s in result])
+
+@app.route("/settlements", methods=["POST"])
+def add_settlement():
+    """ Create a Settlement, and link all un-settled Consumptions to it. """
+    json = request.get_json()
+
+    if not json:
+        return jsonify({"error": "Could not parse JSON."}), 400
+
+    data = json.get('settlement') or {}
+    s = Settlement(name=data['name'])
+
+    db.session.add(s)
+    db.session.commit()
+
+    Consumption.query.filter_by(settlement=None).update({'settlement_id':
+        s.settlement_id})
+
+    db.session.commit()
+
+    return jsonify(settlement=s.as_dict)