Reversal

piket_client/TODO

+- Undo werkend
+- Rebuild werkend, refreshknop
+- CT toevoegen werkend, koppelen aan refresh

piket_client/gui.py

 """
 Provides the graphical front-end for Piket.
 """
+import collections
 import logging
 import os
 import sys
 except ImportError:
     dbus = None
 
-from piket_client.sound import PLOP_WAVE
-from piket_client.model import Person, ConsumptionType
+from piket_client.sound import PLOP_WAVE, UNDO_WAVE
+from piket_client.model import Person, ConsumptionType, Consumption
 import piket_client.logger
 
 LOG = logging.getLogger(__name__)
 class NameButton(QPushButton):
     """ Wraps a QPushButton to provide a counter. """
 
+    consumption_created = Signal(Consumption)
+
     def __init__(self, person: Person, active_id: str, *args, **kwargs) -> None:
         self.person = person
         self.active_id = active_id
 
         super().__init__(self.current_label, *args, **kwargs)
         self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.consumption_created.connect(self.window().consumption_added)
 
         self.clicked.connect(self.process_click)
 
 
     def process_click(self) -> None:
         """ Process a click on this button. """
-        if self.person.add_consumption(self.active_id):
+        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")
 
 
     new_id_set = Signal(str)
 
-    def __init__(self, consumption_type_id: str) -> None:
-        super().__init__()
+    def __init__(self, consumption_type_id: str, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
 
         self.layout = None
         self.layout = QGridLayout()
         self.main_widget = None
         self.toolbar = None
         self.osk = None
+        self.undo_action = None
+        self.undo_queue = collections.deque([], 20)
         self.init_ui()
 
     def init_ui(self) -> None:
         self.toolbar.addAction(
             self.load_icon("add_person.svg"), "Nieuw persoon", self.add_person
         )
-        self.toolbar.addAction(self.load_icon("undo.svg"), "Oeps")
+        self.undo_action = self.toolbar.addAction(
+            self.load_icon("undo.svg"), "Oeps", self.do_undo
+        )
+        self.undo_action.setDisabled(True)
 
         self.toolbar.addAction(
             self.load_icon("quit.svg"), "Afsluiten", self.confirm_quit
         self.addToolBar(self.toolbar)
 
         # Initialize main widget
-        self.main_widget = NameButtons(ag.actions()[0].data())
+        self.main_widget = NameButtons(ag.actions()[0].data(), self)
         self.consumption_type_changed.connect(self.main_widget.consumption_type_changed)
         self.setCentralWidget(self.main_widget)
 
             LOG.warning("Shutdown by user.")
             QApplication.instance().quit()
 
+    def do_undo(self) -> None:
+        """ Undo the last marked consumption. """
+        UNDO_WAVE.play()
+
+        to_undo = self.undo_queue.pop()
+        LOG.warning("Undoing consumption %s", to_undo)
+
+        result = to_undo.reverse()
+
+        if not result or not result.reversed:
+            LOG.error("Reversed consumption %s but was not reversed!", to_undo)
+            self.undo_queue.append(to_undo)
+
+        elif not self.undo_queue:
+            self.undo_action.setDisabled(True)
+
+        self.main_widget.init_ui()
+
+    @Slot(Consumption)
+    def consumption_added(self, consumption):
+        """ Mark an added consumption in the queue. """
+
+        self.undo_queue.append(consumption)
+        self.undo_action.setDisabled(False)
+
     @staticmethod
     def create_spacer() -> QWidget:
         """ Return an empty QWidget that automatically expands. """

piket_client/model.py

 """
 Provides access to the models stored in the database, via the server.
 """
+import datetime
 from typing import NamedTuple
 from urllib.parse import urljoin
 
 
             self.consumptions.update(data["person"]["consumptions"])
 
-            return True
+            return Consumption.from_dict(data["consumption"])
         except ValueError:
             LOG.error(
                 "Did not get JSON on adding Consumption (%s): %s",
             consumption_type_id=data["consumption_type_id"],
             icon=data.get("icon"),
         )
+
+
+class Consumption(NamedTuple):
+    """ Represents a stored Consumption. """
+
+    consumption_id: int
+    person_id: int
+    consumption_type_id: int
+    created_at: datetime.datetime
+    reversed: bool = False
+    settlement_id: int = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Consumption":
+        """ Reconstruct a Consumption from a dict. """
+        return cls(
+            consumption_id=data["consumption_id"],
+            person_id=data["person_id"],
+            consumption_type_id=data["consumption_type_id"],
+            settlement_id=data["settlement_id"],
+            created_at=datetime.datetime.fromisoformat(data["created_at"]),
+            reversed=data["reversed"],
+        )
+
+    def reverse(self) -> "Consumption":
+        """ Reverse this consumption. """
+        req = requests.delete(
+            urljoin(SERVER_URL, f"/consumptions/{self.consumption_id}")
+        )
+
+        try:
+            data = req.json()
+
+            if "error" in data:
+                LOG.error(
+                    "Could not reverse consumption %s (%s): %s",
+                    self.consumption_id,
+                    req.status_code,
+                    data,
+                )
+                return False
+
+            return Consumption.from_dict(data["consumption"])
+
+        except ValueError:
+            LOG.error(
+                "Did not get JSON on reversing Consumption (%s): %s",
+                req.status_code,
+                req.content,
+            )
+            return False

piket_client/sound.py

 
 PLOP_WAVE = sa.WaveObject.from_wave_file(os.path.join(SOUNDS_DIR, "plop.wav"))
 """ SimpleAudio WaveObject containing the plop sound. """
+
+UNDO_WAVE = sa.WaveObject.from_wave_file(os.path.join(SOUNDS_DIR, "undo.wav"))
+""" SimpleAudio WaveObject containing the undo sound. """

piket_server/__init__.py

             "consumptions": {
                 ct.consumption_type_id: Consumption.query.filter_by(person=self)
                 .filter_by(consumption_type=ct)
+                .filter_by(reversed=False)
                 .count()
                 for ct in ConsumptionType.query.all()
             },
     created_at = db.Column(
         db.DateTime, default=datetime.datetime.utcnow, nullable=False
     )
+    reversed = db.Column(db.Boolean, default=False, nullable=False)
 
     def __repr__(self) -> str:
         return f"<Consumption: {self.consumption_type.name} for {self.person.name}>"
     @property
     def as_dict(self) -> dict:
         return {
+            "consumption_id": self.consumption_id,
             "person_id": self.person_id,
             "consumption_type_id": self.consumption_type_id,
             "settlement_id": self.settlement_id,
             "created_at": self.created_at.isoformat(),
+            "reversed": self.reversed,
         }
 
 
     return jsonify(person=person.as_dict, consumption=consumption.as_dict), 201
 
 
+@app.route("/consumptions/<int:consumption_id>", methods=["DELETE"])
+def reverse_consumption(consumption_id: int):
+    """ Reverse a consumption. """
+    consumption = Consumption.query.get_or_404(consumption_id)
+
+    if consumption.reversed:
+        return (
+            jsonify(
+                {
+                    "error": "Consumption already reversed",
+                    "consumption": consumption.as_dict,
+                }
+            ),
+            409,
+        )
+
+    try:
+        consumption.reversed = True
+        db.session.add(consumption)
+        db.session.commit()
+
+    except SQLAlchemyError:
+        return jsonify({"error": "Database error."}), 500
+
+    return jsonify(consumption=consumption.as_dict), 200
+
+
 # ConsumptionType
 @app.route("/consumption_types", methods=["GET"])
 def get_consumption_types():

piket_server/alembic/versions/491bb980d1d7_add_settlement_allow_null_person_on_.py

-"""Add Settlements
-
-Revision ID: 491bb980d1d7
-Revises: de101d627237
-Create Date: 2018-08-22 22:37:49.467438
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = "491bb980d1d7"
-down_revision = "de101d627237"
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    op.create_table(
-        "settlements",
-        sa.Column("settlement_id", sa.Integer, primary_key=True),
-        sa.Column("name", sa.String, nullable=False),
-    )
-
-    op.add_column(
-        "consumptions",
-        sa.Column(
-            "settlement_id",
-            sa.Integer,
-            sa.ForeignKey("settlements.settlement_id"),
-            nullable=True,
-        ),
-    )
-
-
-def downgrade():
-    op.drop_column("consumptions", "settlement_id")
-
-    op.drop_table("settlements")

piket_server/alembic/versions/de101d627237_create_consumptions_consumption_types.py

-"""Create consumptions, consumption_types
+"""Create consumptions, consumption_types, settlements
 
 Revision ID: de101d627237
 Revises: a09086bfe84c
     )
 
     op.create_table(
+        "settlements",
+        sa.Column("settlement_id", sa.Integer, primary_key=True),
+        sa.Column("name", sa.String, nullable=False),
+    )
+
+    op.create_table(
         "consumptions",
         sa.Column("consumption_id", sa.Integer, primary_key=True),
         sa.Column("person_id", sa.Integer, nullable=True),
         sa.Column("consumption_type_id", sa.Integer, nullable=False),
         sa.Column("created_at", sa.DateTime, nullable=False),
+        sa.Column("settlement_id", sa.Integer, nullable=True),
+        sa.Column("reversed", sa.Boolean, nullable=False, server_default="FALSE"),
         sa.ForeignKeyConstraint(
             ["consumption_type_id"], ["consumption_types.consumption_type_id"]
         ),
         sa.ForeignKeyConstraint(["person_id"], ["people.person_id"]),
+        sa.ForeignKeyConstraint(["settlement_id"], ["settlements.settlement_id"]),
         sa.PrimaryKeyConstraint("consumption_id"),
     )
 
 
 def downgrade():
     op.drop_table("consumptions")
+    op.drop_table("settlements")
     op.drop_table("consumption_types")

piket_server/seed.py

 
 import argparse
 import csv
+import os
 
 from piket_server import db, Person, Settlement, ConsumptionType, Consumption
 
         print("All data removed. Recreating database...")
         db.create_all()
 
+        from alembic.config import Config
+        from alembic import command
+
+        alembic_cfg = Config(os.path.join(os.path.dirname(__file__), "alembic.ini"))
+        command.stamp(alembic_cfg, "head")
+
         print("Done.")
         return
 
-    else:
-        print("Aborting.")
+    print("Aborting.")
 
 
 if __name__ == "__main__":