Merge branch 'aardbei-integration'

.gitignore

 # Python egg metadata, regenerated from source files by setuptools.
 /*.egg-info
 /*.egg
+
+# Type checking cache
+.mypy_cache

.isort.cfg

+[settings]
+multi_line_output=3
+include_trailing_comma=True
+force_grid_wrap=0
+use_parentheses=True
+line_length=88

.python-version

+3.7.5

piket_client/cli.py

+from typing import Optional
+
+import click
+from prettytable import PrettyTable
+
+from piket_client.model import (
+    AardbeiActivity,
+    ServerStatus,
+    NetworkError,
+    Consumption,
+    AardbeiPeopleDiff,
+    Person,
+    Settlement,
+    ConsumptionType,
+)
+
+
+@click.group()
+def cli():
+    """Poke coco from the command line."""
+    pass
+
+
+@cli.command()
+def status():
+    """Show the current status of the server."""
+
+    status = ServerStatus.is_server_running()
+
+    if isinstance(status, NetworkError):
+        print_error(f"Failed to get data from server, error {status.value}")
+        return
+
+    print_ok("Server is available.")
+
+    open_consumptions = ServerStatus.unsettled_consumptions()
+
+    if isinstance(open_consumptions, NetworkError):
+        print_error(
+            f"Failed to get unsettled consumptions, error {open_consumptions.value}"
+        )
+        return
+
+    click.echo(f"There are {open_consumptions.amount} unsettled consumptions.")
+
+    if open_consumptions.amount > 0:
+        click.echo(f"First at: {open_consumptions.first_timestamp.strftime('%c')}")
+        click.echo(f"Most recent at: {open_consumptions.last_timestamp.strftime('%c')}")
+
+
+@cli.group()
+def people():
+    pass
+
+
+@people.command("list")
+@click.option("--active/--inactive", default=None)
+def list_people(active: bool) -> None:
+    people = Person.get_all(active=active)
+
+    if isinstance(people, NetworkError):
+        print_error(f"Could not get people: {people.value}")
+        return
+
+    table = PrettyTable()
+    table.field_names = ["ID", "Full name", "Display name", "Active"]
+    table.align["ID"] = "r"
+    table.align["Full name"] = "l"
+    table.align["Display name"] = "l"
+    table.sortby = "Full name"
+
+    for p in people:
+        table.add_row([p.person_id, p.full_name, p.display_name, p.active])
+
+    print(table)
+
+
+@people.command("create")
+@click.option("--display-name", type=click.STRING)
+@click.argument("name", type=click.STRING)
+def create_person(name: str, display_name: str) -> None:
+    """Create a person."""
+    person = Person(full_name=name, display_name=display_name).create()
+
+    if isinstance(person, NetworkError):
+        print_error(f"Could not create Person: {person.value}")
+        return
+
+    print_ok(f'Created person "{name}" with ID {person.person_id}.')
+
+
+@people.command("rename")
+@click.argument("person-id", type=click.INT)
+@click.option("--new-full-name", type=click.STRING)
+@click.option("--new-display-name", type=click.STRING)
+def rename_person(
+    person_id: int, new_full_name: Optional[str], new_display_name: Optional[str],
+) -> None:
+
+    person = Person.get(person_id)
+
+    if person is None:
+        raise click.UsageError(f"Cannot find Person {person_id}!")
+
+    if new_full_name is None and new_display_name is None:
+        raise click.UsageError("No new full name or display name specified!")
+
+    new_person = person.rename(
+        new_full_name=new_full_name, new_display_name=new_display_name
+    )
+
+
+@cli.group()
+def settlements():
+    pass
+
+
+@settlements.command("show")
+@click.argument("settlement_id", type=click.INT)
+def show_settlement(settlement_id: int) -> None:
+    """Get and view the contents of a Settlement."""
+    s = Settlement.get(settlement_id)
+
+    if isinstance(s, NetworkError):
+        print_error(f"Could not get Settlement: {s.value}")
+        return
+
+    output_settlement_info(s)
+
+
+@settlements.command("create")
+@click.argument("name")
+def create_settlement(name: str) -> None:
+    """Create a new Settlement."""
+    s = Settlement.create(name)
+
+    if isinstance(s, NetworkError):
+        print_error(f"Could not create Settlement: {s.value}")
+        return
+
+    output_settlement_info(s)
+
+
+def output_settlement_info(s: Settlement) -> None:
+    click.echo(f'Settlement {s.settlement_id}, "{s.name}"')
+
+    click.echo(f"Summary:")
+    for key, value in s.consumption_summary.items():
+        click.echo(f" - {value['count']} {value['name']} ({key})")
+
+    ct_name_by_id = {key: value["name"] for key, value in s.consumption_summary.items()}
+
+    table = PrettyTable()
+    table.field_names = ["Name", *ct_name_by_id.values()]
+    table.sortby = "Name"
+    table.align = "r"
+    table.align["Name"] = "l"  # type: ignore
+
+    zero_fields = {k: "" for k in ct_name_by_id.values()}
+
+    for item in s.per_person_counts.values():
+        r = {"Name": item["full_name"], **zero_fields}
+        for key, value in item["counts"].items():
+            r[ct_name_by_id[key]] = value
+
+        table.add_row(r.values())
+
+    print(table)
+
+
+@cli.group()
+def consumption_types():
+    pass
+
+
+@consumption_types.command("list")
+def list_consumption_types() -> None:
+    active = ConsumptionType.get_all(active=True)
+    inactive = ConsumptionType.get_all(active=False)
+
+    if isinstance(active, NetworkError) or isinstance(inactive, NetworkError):
+        print_error("Could not get consumption types!")
+        return
+
+    table = PrettyTable()
+    table.field_names = ["ID", "Name", "Active"]
+    table.sortby = "ID"
+
+    for ct in active + inactive:
+        table.add_row([ct.consumption_type_id, ct.name, ct.active])
+
+    print(table)
+
+
+@consumption_types.command("create")
+@click.argument("name")
+def create_consumption_type(name: str) -> None:
+    ct = ConsumptionType(name=name).create()
+
+    if not isinstance(ct, NetworkError):
+        print_ok(f'Created consumption type "{name}" with ID {ct.consumption_type_id}.')
+
+
+@consumption_types.command("activate")
+@click.argument("consumption_type_id", type=click.INT)
+def activate_consumption_type(consumption_type_id: int) -> None:
+    ct = ConsumptionType.get(consumption_type_id)
+
+    if isinstance(ct, NetworkError):
+        print_error(f"Could not get ConsumptionType: {ct.value}")
+        return
+
+    result = ct.set_active(True)
+
+    if not isinstance(result, NetworkError):
+        print_ok(
+            f"Consumption type {ct.consumption_type_id} ({ct.name}) is now active."
+        )
+
+
+@consumption_types.command("deactivate")
+@click.argument("consumption_type_id", type=click.INT)
+def deactivate_consumption_type(consumption_type_id: int) -> None:
+    ct = ConsumptionType.get(consumption_type_id)
+
+    if isinstance(ct, NetworkError):
+        print_error(f"Could not get ConsumptionType: {ct.value}")
+        return
+
+    result = ct.set_active(False)
+
+    if not isinstance(result, NetworkError):
+        print_ok(
+            f"Consumption type {ct.consumption_type_id} ({ct.name}) is now inactive."
+        )
+
+
+def print_ok(msg: str) -> None:
+    click.echo(click.style(msg, fg="green"))
+
+
+def print_error(msg: str) -> None:
+    click.echo(click.style(msg, fg="red", bold=True), err=True)
+
+
+@cli.group()
+@click.option("--token", required=True, envvar="AARDBEI_TOKEN")
+@click.option("--endpoint", default="http://localhost:3000", envvar="AARDBEI_ENDPOINT")
+@click.pass_context
+def aardbei(ctx, token: str, endpoint: str) -> None:
+    ctx.ensure_object(dict)
+    ctx.obj["AardbeiToken"] = token
+    ctx.obj["AardbeiEndpoint"] = endpoint
+
+
+@aardbei.group("activities")
+def aardbei_activities() -> None:
+    pass
+
+
+@aardbei_activities.command("list")
+@click.pass_context
+def aardbei_list_activities(ctx) -> None:
+    acts = AardbeiActivity.get_available(
+        token=ctx.obj["AardbeiToken"], endpoint=ctx.obj["AardbeiEndpoint"]
+    )
+
+    if isinstance(acts, NetworkError):
+        print_error(f"Could not get activities: {acts.value}")
+        return
+
+    table = PrettyTable()
+    table.field_names = ["ID", "Name"]
+    table.align = "l"
+
+    for a in acts:
+        table.add_row([a.aardbei_id, a.name])
+
+    print(table)
+
+
+@aardbei_activities.command("apply")
+@click.argument("activity_id", type=click.INT)
+@click.pass_context
+def aardbei_apply_activity(ctx, activity_id: int) -> None:
+    result = AardbeiActivity.apply_activity(
+        token=ctx.obj["AardbeiToken"],
+        endpoint=ctx.obj["AardbeiEndpoint"],
+        activity_id=activity_id,
+    )
+
+    if isinstance(result, NetworkError):
+        print_error("Failed to apply activity: {result.value}")
+        return
+
+    print_ok(f"Activity applied. There are now {result} active people.")
+
+
+@aardbei.group("people")
+def aardbei_people() -> None:
+    pass
+
+
+@aardbei_people.command("diff")
+@click.pass_context
+def aardbei_diff_people(ctx) -> None:
+    diff = AardbeiPeopleDiff.get_diff(
+        token=ctx.obj["AardbeiToken"], endpoint=ctx.obj["AardbeiEndpoint"]
+    )
+
+    if isinstance(diff, NetworkError):
+        print_error(f"Could not get differences: {diff.value}")
+        return
+
+    if diff.num_changes == 0:
+        print_ok("There are no changes to apply.")
+        return
+
+    click.echo(f"There are {diff.num_changes} pending changes:")
+    show_diff(diff)
+
+
+@aardbei_people.command("sync")
+@click.pass_context
+def aardbei_sync_people(ctx) -> None:
+    diff = AardbeiPeopleDiff.sync(
+        token=ctx.obj["AardbeiToken"], endpoint=ctx.obj["AardbeiEndpoint"]
+    )
+
+    if isinstance(diff, NetworkError):
+        print_error(f"Could not apply differences: {diff.value}")
+        return
+
+    if diff.num_changes == 0:
+        print_ok("There were no changes to apply.")
+        return
+
+    print_ok(f"Applied {diff.num_changes} pending changes:")
+    show_diff(diff)
+
+
+def show_diff(diff: AardbeiPeopleDiff) -> None:
+    for name in diff.new_people:
+        click.echo(f" - Create local Person for {name}")
+
+    for name in diff.link_existing:
+        click.echo(f" - Link local and remote people for {name}")
+
+    for name in diff.altered_name:
+        click.echo(f" - Process name change for {name}")
+
+
+if __name__ == "__main__":
+    cli()

piket_client/gui.py

 Provides the graphical front-end for Piket.
 """
 import collections
+import itertools
 import logging
+import math
 import os
 import sys
+from typing import Deque, Iterator
 
 import qdarkstyle
 
     QWidget,
 )
 from PySide2.QtGui import QIcon
-from PySide2.QtCore import QObject, QSize, Qt, Signal, Slot
+from PySide2.QtCore import QObject, QSize, Qt, Signal, Slot, QUrl
+from PySide2.QtMultimedia import QSoundEffect
 
 # pylint: enable=E0611
 
 except ImportError:
     dbus = None
 
-from piket_client.sound import PLOP_WAVE, UNDO_WAVE
+from piket_client.sound import PLOP_PATH, UNDO_PATH
 from piket_client.model import (
     Person,
     ConsumptionType,
     Consumption,
     ServerStatus,
+    NetworkError,
     Settlement,
 )
 import piket_client.logger
 LOG = logging.getLogger(__name__)
 
 
-def plop() -> None:
-    """ Asynchronously play the plop sound. """
-    PLOP_WAVE.play()
-
-
 class NameButton(QPushButton):
     """ Wraps a QPushButton to provide a counter. """
 
     @Slot()
     def rebuild(self) -> None:
         """ Refresh the Person object and the label. """
-        self.person = self.person.reload()
+        self.person = self.person.reload()  # type: ignore
         self.setText(self.current_label)
 
     @property
         LOG.debug("Button clicked.")
         result = self.person.add_consumption(self.active_id)
         if result:
-            plop()
+            self.window().play_plop()
             self.setText(self.current_label)
             self.consumption_created.emit(result)
         else:
         LOG.debug("Initializing NameButtons.")
 
         ps = Person.get_all(True)
-        num_columns = round(len(ps) / 10) + 1
+        assert not isinstance(ps, NetworkError)
+        num_columns = math.ceil(math.sqrt(len(ps)))
 
         if self.layout:
             LOG.debug("Removing %s widgets for rebuild", self.layout.count())
 
     consumption_type_changed = Signal(str)
 
+    plop_loop: Iterator[QSoundEffect]
+    undo_loop: Iterator[QSoundEffect]
+
     def __init__(self) -> None:
         LOG.debug("Initializing PiketMainWindow.")
         super().__init__()
         self.toolbar = None
         self.osk = None
         self.undo_action = None
-        self.undo_queue = collections.deque([], 15)
+        self.undo_queue: Deque[Consumption] = collections.deque([], 15)
         self.init_ui()
 
     def init_ui(self) -> None:
 
         # Initialize toolbar
         self.toolbar = QToolBar()
+        assert self.toolbar is not None
         self.toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
         self.toolbar.setIconSize(QSize(icon_size, icon_size))
 
         self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu)
         self.toolbar.setFloatable(False)
         self.toolbar.setMovable(False)
-        self.ct_ag = QActionGroup(self.toolbar)
+        self.ct_ag: QActionGroup = QActionGroup(self.toolbar)
         self.ct_ag.setExclusive(True)
 
         cts = ConsumptionType.get_all()
 
         self.addToolBar(self.toolbar)
 
+        # Load sounds
+        plops = [QSoundEffect(self) for _ in range(7)]
+        for qse in plops:
+            qse.setSource(QUrl.fromLocalFile(str(PLOP_PATH)))
+        self.plop_loop = itertools.cycle(plops)
+
+        undos = [QSoundEffect(self) for _ in range(5)]
+        for qse in undos:
+            qse.setSource(QUrl.fromLocalFile(str(UNDO_PATH)))
+        self.undo_loop = itertools.cycle(undos)
+
         # Initialize main widget
         self.main_widget = NameButtons(self.ct_ag.actions()[0].data(), self)
         self.consumption_type_changed.connect(self.main_widget.consumption_type_changed)
         """ Ask for a new Person and register it, then rebuild the central
         widget. """
         inactive_persons = Person.get_all(False)
+        assert not isinstance(inactive_persons, NetworkError)
+
         inactive_persons.sort(key=lambda p: p.name)
         inactive_names = [p.name for p in inactive_persons]
 
                 person.set_active(True)
 
             else:
-                person = Person(name=name)
-                person = person.create()
+                person = Person(full_name=name, display_name=None,)
+                person.create()
 
+            assert self.main_widget is not None
             self.main_widget.init_ui()
 
     def add_consumption_type(self) -> None:
         self.hide_keyboard()
 
         if ok and name:
-            ct = ConsumptionType(name=name)
-            ct = ct.create()
+            ct = ConsumptionType(name=name).create()
+            assert not isinstance(ct, NetworkError)
 
             action = QAction(
                 self.load_icon(ct.icon or "beer_bottle.svg"), ct.name, self.ct_ag
             action.setCheckable(True)
             action.setData(str(ct.consumption_type_id))
 
+            assert self.toolbar is not None
             self.toolbar.addAction(action)
 
     def confirm_quit(self) -> None:
 
     def do_undo(self) -> None:
         """ Undo the last marked consumption. """
-        UNDO_WAVE.play()
+        next(self.undo_loop).play()
 
         to_undo = self.undo_queue.pop()
         LOG.warning("Undoing consumption %s", to_undo)
             self.undo_queue.append(to_undo)
 
         elif not self.undo_queue:
+            assert self.undo_action is not None
             self.undo_action.setDisabled(True)
 
+        assert self.main_widget is not None
         self.main_widget.init_ui()
 
     @Slot(Consumption)
         icon = QIcon(os.path.join(self.icons_dir, filename))
         return icon
 
+    def play_plop(self) -> None:
+        next(self.plop_loop).play()
+
 
 def main() -> None:
     """ Main entry point of GUI client. """
     app.setFont(font)
 
     # Test connectivity
-    server_running, info = ServerStatus.is_server_running()
+    server_running = ServerStatus.is_server_running()
 
-    if not server_running:
-        LOG.critical("Could not connect to server", extra={"info": info})
+    if isinstance(server_running, NetworkError):
+        LOG.critical("Could not connect to server, error %s", server_running.value)
         QMessageBox.critical(
             None,
             "Help er is iets kapot",
             "Kan niet starten omdat de server niet reageert, stuur een foto van "
-            "dit naar Maarten: " + repr(info),
+            "dit naar Maarten: " + repr(server_running.value),
         )
-        return 1
+        return
 
     # Load main window
     main_window = PiketMainWindow()
 
     # Test unsettled consumptions
     status = ServerStatus.unsettled_consumptions()
+    assert not isinstance(status, NetworkError)
 
-    unsettled = status["unsettled"]["amount"]
+    unsettled = status.amount
 
     if unsettled > 0:
-        first = status["unsettled"]["first"]
+        assert status.first_timestamp is not None
+
+        first = status.first_timestamp
         first_date = first.strftime("%c")
         ok = QMessageBox.information(
             None,
             name, ok = QInputDialog.getText(
                 None,
                 "Lijst afsluiten",
-                "Voer een naam in voor de lijst of druk op OK. Laat de datum " "staan.",
+                "Voer een naam in voor de lijst of druk op OK. Laat de datum staan.",
                 QLineEdit.Normal,
                 f"{first.strftime('%Y-%m-%d')}",
             )
                     f'{item["count"]} {item["name"]}'
                     for item in settlement.consumption_summary.values()
                 ]
-                info = ", ".join(info)
+                info2 = ", ".join(info)
                 QMessageBox.information(
-                    None, "Lijst afgesloten", f"VO! Op deze lijst stonden: {info}"
+                    None, "Lijst afgesloten", f"VO! Op deze lijst stonden: {info2}"
                 )
 
                 main_window = PiketMainWindow()

piket_client/model.py

 """
 Provides access to the models stored in the database, via the server.
 """
+from __future__ import annotations
+
 import datetime
+import enum
 import logging
-from typing import NamedTuple, Sequence
+from dataclasses import dataclass
+from typing import Any, Dict, List, NamedTuple, Optional, Sequence, Tuple, Union
 from urllib.parse import urljoin
 
 import requests
 
-
 LOG = logging.getLogger(__name__)
 
 SERVER_URL = "http://127.0.0.1:5000"
 DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%f"
 
 
+class NetworkError(enum.Enum):
+    """Represents errors that might occur when communicating with the server."""
+
+    HttpFailure = "http_failure"
+    """Returned when the server returns a non-successful status code."""
+
+    ConnectionFailure = "connection_failure"
+    """Returned when we can't connect to the server at all."""
+
+    InvalidData = "invalid_data"
+
+
 class ServerStatus:
     """ Provides helper classes to check whether the server is up. """
 
     @classmethod
-    def is_server_running(cls) -> bool:
+    def is_server_running(cls) -> Union[bool, NetworkError]:
         try:
             req = requests.get(urljoin(SERVER_URL, "ping"))
-
-            if req.status_code == 200:
-                return True, req.content
-            return False, req.content
+            req.raise_for_status()
 
         except requests.ConnectionError as ex:
-            return False, ex
+            LOG.exception(ex)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as ex:
+            LOG.exception(ex)
+            return NetworkError.HttpFailure
+
+        return True
+
+    @dataclass(frozen=True)
+    class OpenConsumptions:
+        amount: int
+        first_timestamp: Optional[datetime.datetime]
+        last_timestamp: Optional[datetime.datetime]
 
     @classmethod
-    def unsettled_consumptions(cls) -> dict:
-        req = requests.get(urljoin(SERVER_URL, "status"))
+    def unsettled_consumptions(cls) -> Union[OpenConsumptions, NetworkError]:
+        try:
+            req = requests.get(urljoin(SERVER_URL, "status"))
+            req.raise_for_status()
+            data = req.json()
 
-        data = req.json()
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
 
-        if data["unsettled"]["amount"]:
-            data["unsettled"]["first"] = datetime.datetime.strptime(
-                data["unsettled"]["first"], DATETIME_FORMAT
-            )
-            data["unsettled"]["last"] = datetime.datetime.strptime(
-                data["unsettled"]["last"], DATETIME_FORMAT
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
+
+        amount: int = data["unsettled"]["amount"]
+
+        if amount == 0:
+            return cls.OpenConsumptions(
+                amount=0, first_timestamp=None, last_timestamp=None
             )
 
-        return data
+        first = datetime.datetime.fromisoformat(data["unsettled"]["first"])
+        last = datetime.datetime.fromisoformat(data["unsettled"]["last"])
+
+        return cls.OpenConsumptions(
+            amount=amount, first_timestamp=first, last_timestamp=last
+        )
 
 
 class Person(NamedTuple):
     """ Represents a Person, as retrieved from the database. """
 
-    name: str
+    full_name: str
+    display_name: Optional[str]
     active: bool = True
-    person_id: int = None
+    person_id: Optional[int] = None
     consumptions: dict = {}
 
-    def add_consumption(self, type_id: str) -> bool:
+    @property
+    def name(self) -> str:
+        return self.display_name or self.full_name
+
+    def add_consumption(self, type_id: str) -> Optional[Consumption]:
         """ Register a consumption for this Person. """
         req = requests.post(
             urljoin(SERVER_URL, f"people/{self.person_id}/add_consumption/{type_id}")
                     req.status_code,
                     data,
                 )
-                return False
+                return None
 
             self.consumptions.update(data["person"]["consumptions"])
 
                 req.status_code,
                 req.content,
             )
-            return False
+            return None
 
-    def create(self) -> "Person":
+    def create(self) -> Union[Person, NetworkError]:
         """ 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, "active": True}},
+
+        try:
+            req = requests.post(
+                urljoin(SERVER_URL, "people"),
+                json={
+                    "person": {
+                        "full_name": self.full_name,
+                        "display_name": self.display_name,
+                        "active": True,
+                    }
+                },
+            )
+            req.raise_for_status()
+            data = req.json()
+            return Person.from_dict(data["person"])
+
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
+
+    def rename(
+        self, new_full_name: Optional[str], new_display_name: Optional[str]
+    ) -> Optional[Person]:
+        person_payload: Dict[str, str] = {}
+
+        if new_full_name is not None:
+            person_payload["full_name"] = new_full_name
+
+        if new_display_name is not None:
+            person_payload["display_name"] = new_display_name
+
+        req = requests.patch(
+            urljoin(SERVER_URL, f"people/{self.person_id}"),
+            json={"person": person_payload},
         )
 
         try:
             data = req.json()
         except ValueError:
             LOG.error(
-                "Did not get JSON on adding Person (%s): %s",
+                "Did not get JSON on updating 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)
+        if "error" in data or req.status_code != 200:
+            LOG.error("Could not update Person (%s): %s", req.status_code, data)
             return None
 
         return Person.from_dict(data["person"])
 
-    def set_active(self, new_state=True) -> "Person":
+    def set_active(self, new_state=True) -> Optional[Person]:
         req = requests.patch(
             urljoin(SERVER_URL, f"people/{self.person_id}"),
             json={"person": {"active": new_state}},
         return Person.from_dict(data["person"])
 
     @classmethod
-    def get(cls, person_id: int) -> "Person":
+    def get(cls, person_id: int) -> Optional[Person]:
         """ Retrieve a Person by id. """
         req = requests.get(urljoin(SERVER_URL, f"/people/{person_id}"))
 
             return None
 
     @classmethod
-    def get_all(cls, active=None) -> ["Person"]:
+    def get_all(cls, active=None) -> Union[List[Person], NetworkError]:
         """ Get all active People. """
         params = {}
         if active is not None:
             params["active"] = int(active)
 
-        req = requests.get(urljoin(SERVER_URL, "/people"), params=params)
-
         try:
+            req = requests.get(urljoin(SERVER_URL, "/people"), params=params)
+            req.raise_for_status()
             data = req.json()
+            return [Person.from_dict(item) for item in data["people"]]
 
-            if "error" in data:
-                LOG.warning("Could not get people (%s): %s", req.status_code, data)
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
 
-            return [Person.from_dict(item) for item in data["people"]]
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
 
-        except ValueError:
-            LOG.error(
-                "Did not get JSON from server on getting People (%s): %s",
-                req.status_code,
-                req.content,
-            )
-            return None
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
 
     @classmethod
     def from_dict(cls, data: dict) -> "Person":
         """ Reconstruct a Person object from a dict. """
         return Person(
-            name=data["name"],
+            full_name=data["full_name"],
+            display_name=data["display_name"],
             active=data["active"],
             person_id=data["person_id"],
             consumptions=data["consumptions"],
         )
 
     @classmethod
-    def get_all(cls) -> ["Export"]:
+    def get_all(cls) -> Optional[List[Export]]:
         """ Get a list of all existing Exports. """
         req = requests.get(urljoin(SERVER_URL, "exports"))
 
         return [cls.from_dict(e) for e in data["exports"]]
 
     @classmethod
-    def get(cls, export_id: int) -> "Export":
+    def get(cls, export_id: int) -> Optional[Export]:
         """ Retrieve one Export. """
         req = requests.get(urljoin(SERVER_URL, f"exports/{export_id}"))
 
         return cls.from_dict(data["export"])
 
     @classmethod
-    def create(cls) -> "Export":
+    def create(cls) -> Optional[Export]:
         """ Create a new Export, containing all un-exported Settlements. """
         req = requests.post(urljoin(SERVER_URL, "exports"))
 
     """ Represents a stored ConsumptionType. """
 
     name: str
-    consumption_type_id: int = None
-    icon: str = None
+    consumption_type_id: Optional[int] = None
+    icon: Optional[str] = None
+    active: bool = True
 
-    def create(self) -> "ConsumptionType":
+    def create(self) -> Union[ConsumptionType, NetworkError]:
         """ 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,
+            req = requests.post(
+                urljoin(SERVER_URL, "consumption_types"),
+                json={"consumption_type": {"name": self.name, "icon": self.icon}},
             )
-            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
+            req.raise_for_status()
+            data = req.json()
+            return ConsumptionType.from_dict(data["consumption_type"])
 
-        return ConsumptionType.from_dict(data["consumption_type"])
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
 
     @classmethod
-    def get(cls, consumption_type_id: int) -> "ConsumptionType":
+    def get(cls, consumption_type_id: int) -> Union[ConsumptionType, NetworkError]:
         """ Retrieve a ConsumptionType by id. """
-        req = requests.get(
-            urljoin(SERVER_URL, f"/consumption_types/{consumption_type_id}")
-        )
-
         try:
+            req = requests.get(
+                urljoin(SERVER_URL, f"/consumption_types/{consumption_type_id}")
+            )
+            req.raise_for_status()
             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
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
 
-            return cls.from_dict(data["consumption_type"])
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
 
-        except ValueError:
-            LOG.error(
-                "Did not get JSON from server on getting consumption type (%s): %s",
-                req.status_code,
-                req.content,
-            )
-            return None
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
 
-    @classmethod
-    def get_all(cls) -> ["ConsumptionType"]:
-        """ Get all active ConsumptionTypes. """
-        req = requests.get(urljoin(SERVER_URL, "/consumption_types"))
+        return cls.from_dict(data["consumption_type"])
 
+    @classmethod
+    def get_all(cls, active: bool = True) -> Union[List[ConsumptionType], NetworkError]:
+        """ Get the list of ConsumptionTypes. """
         try:
+            req = requests.get(
+                urljoin(SERVER_URL, "/consumption_types"),
+                params={"active": int(active)},
+            )
+            req.raise_for_status()
+
             data = req.json()
 
-            if "error" in data:
-                LOG.warning(
-                    "Could not get consumption types (%s): %s", req.status_code, data
-                )
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
 
-            return [cls.from_dict(item) for item in data["consumption_types"]]
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
 
-        except ValueError:
-            LOG.error(
-                "Did not get JSON from server on getting ConsumptionTypes (%s): %s",
-                req.status_code,
-                req.content,
-            )
-            return None
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
+
+        return [cls.from_dict(x) for x in data["consumption_types"]]
 
     @classmethod
     def from_dict(cls, data: dict) -> "ConsumptionType":
             name=data["name"],
             consumption_type_id=data["consumption_type_id"],
             icon=data.get("icon"),
+            active=data["active"],
         )
 
+    def set_active(self, active: bool) -> Union[ConsumptionType, NetworkError]:
+        """Update the 'active' attribute."""
+        try:
+            req = requests.patch(
+                urljoin(SERVER_URL, f"/consumption_types/{self.consumption_type_id}"),
+                json={"consumption_type": {"active": active}},
+            )
+            req.raise_for_status()
+            data = req.json()
+
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
+
+        return self.from_dict(data["consumption_type"])
+
 
 class Consumption(NamedTuple):
     """ Represents a stored Consumption. """
     consumption_type_id: int
     created_at: datetime.datetime
     reversed: bool = False
-    settlement_id: int = None
+    settlement_id: Optional[int] = None
 
     @classmethod
     def from_dict(cls, data: dict) -> "Consumption":
             reversed=data["reversed"],
         )
 
-    def reverse(self) -> "Consumption":
+    def reverse(self) -> Optional[Consumption]:
         """ Reverse this consumption. """
         req = requests.delete(
             urljoin(SERVER_URL, f"/consumptions/{self.consumption_id}")
                     req.status_code,
                     data,
                 )
-                return False
+                return None
 
             return Consumption.from_dict(data["consumption"])
 
                 req.status_code,
                 req.content,
             )
-            return False
+            return None
 
 
 class Settlement(NamedTuple):
 
     settlement_id: int
     name: str
-    consumption_summary: dict
-    count_info: dict = {}
+    consumption_summary: Dict[str, Any]
+    count_info: Dict[str, Any] = {}
+    per_person_counts: Dict[str, Any] = {}
 
     @classmethod
     def from_dict(cls, data: dict) -> "Settlement":
             settlement_id=data["settlement_id"],
             name=data["name"],
             consumption_summary=data["consumption_summary"],
-            count_info=data.get("count_info", {}),
+            count_info=data["count_info"],
+            per_person_counts=data["per_person_counts"],
         )
 
     @classmethod
         return cls.from_dict(req.json()["settlement"])
 
     @classmethod
-    def get(cls, settlement_id: int) -> "Settlement":
-        req = requests.get(urljoin(SERVER_URL, f"/settlements/{settlement_id}"))
-
+    def get(cls, settlement_id: int) -> Union[Settlement, NetworkError]:
         try:
+            req = requests.get(urljoin(SERVER_URL, f"/settlements/{settlement_id}"))
+            req.raise_for_status()
             data = req.json()
-        except ValueError:
-            LOG.error(
-                "Did not get JSON on retrieving Settlement (%s): %s",
-                req.status_code,
-                req.content,
-            )
-            return None
 
-        if "error" in data or req.status_code != 200:
-            LOG.error("Could not get Export (%s): %s", req.status_code, data)
-            return None
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
+
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
 
         data["settlement"]["count_info"] = data["count_info"]
 
         return cls.from_dict(data["settlement"])
+
+
+@dataclass(frozen=True)
+class AardbeiActivity:
+    aardbei_id: int
+    name: str
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> AardbeiActivity:
+        return cls(data["activity"]["id"], data["activity"]["name"])
+
+    @classmethod
+    def get_available(
+        cls, token: str, endpoint: str
+    ) -> Union[List[AardbeiActivity], NetworkError]:
+        try:
+            req = requests.post(
+                urljoin(SERVER_URL, "/aardbei/get_activities"),
+                json={"endpoint": endpoint, "token": token},
+            )
+
+            req.raise_for_status()
+            return [cls.from_dict(x) for x in req.json()["activities"]]
+
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
+
+    @classmethod
+    def apply_activity(
+        cls, token: str, endpoint: str, activity_id: int
+    ) -> Union[int, NetworkError]:
+        try:
+            req = requests.post(
+                urljoin(SERVER_URL, "/aardbei/apply_activity"),
+                json={"activity_id": activity_id, "token": token, "endpoint": endpoint},
+            )
+            req.raise_for_status()
+            data = req.json()
+
+            return data["activity"]["response_counts"]["present"]
+
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
+
+
+@dataclass(frozen=True)
+class AardbeiPeopleDiff:
+    altered_name: List[str]
+    link_existing: List[str]
+    new_people: List[str]
+    num_changes: int
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> AardbeiPeopleDiff:
+        return cls(**data)
+
+    @classmethod
+    def get_diff(
+        cls, token: str, endpoint: str
+    ) -> Union[AardbeiPeopleDiff, NetworkError]:
+        try:
+            req = requests.post(
+                urljoin(SERVER_URL, "/aardbei/diff_people"),
+                json={"endpoint": endpoint, "token": token},
+            )
+            req.raise_for_status()
+            data = req.json()
+
+            return cls.from_dict(data)
+
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
+
+    @classmethod
+    def sync(cls, token: str, endpoint: str) -> Union[AardbeiPeopleDiff, NetworkError]:
+        try:
+            req = requests.post(
+                urljoin(SERVER_URL, "/aardbei/sync_people"),
+                json={"endpoint": endpoint, "token": token},
+            )
+            req.raise_for_status()
+            data = req.json()
+
+            return cls.from_dict(data)
+
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData

piket_client/set_active.py

 Provides a helper tool to (de-)activate multiple people at once.
 """
 
+import math
 import sys
 
 # pylint: disable=E0611
+import qdarkstyle
+from PySide2.QtCore import QObject, QSize, Qt, Signal, Slot
+from PySide2.QtGui import QIcon
 from PySide2.QtWidgets import (
     QAction,
     QActionGroup,
     QToolBar,
     QWidget,
 )
-from PySide2.QtGui import QIcon
-from PySide2.QtCore import QObject, QSize, Qt, Signal, Slot
 
-# pylint: enable=E0611
+from piket_client.model import NetworkError, Person, ServerStatus
 
-import qdarkstyle
-
-from piket_client.model import Person, ServerStatus
+# pylint: enable=E0611
 
 
 class ActivationButton(QPushButton):
 
     def init_ui(self) -> None:
         ps = Person.get_all()
-        num_columns = round(len(ps) / 10) + 1
+        assert not isinstance(ps, NetworkError)
+        num_columns = math.ceil(math.sqrt(len(ps)))
 
         for index, person in enumerate(ps):
             button = ActivationButton(person, self)
     def __init__(self) -> None:
         super().__init__()
 
-        self.toolbar = None
+        self.toolbar = QToolBar()
 
         self.init_ui()
 
         icon_size = font_metrics.height() * 1.45
 
         # Toolbar
-        self.toolbar = QToolBar()
         self.toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
         self.toolbar.setIconSize(QSize(icon_size, icon_size))
 
     app.setFont(font)
 
     # Test connectivity
-    server_running, info = ServerStatus.is_server_running()
+    server_running = ServerStatus.is_server_running()
 
-    if not server_running:
-        LOG.critical("Could not connect to server", extra={"info": info})
+    if not isinstance(server_running, bool):
         QMessageBox.critical(
             None,
             "Help er is iets kapot",
             "Kan niet starten omdat de server niet reageert, stuur een foto van "
-            "dit naar Maarten: " + repr(info),
+            "dit naar Maarten: " + repr(server_running.value),
         )
-        return 1
+        return
 
     # Load main window
     main_window = ActiveStateMainWindow()

piket_client/sound.py

 Provides functions related to playing sounds.
 """
 
-import os
+import pathlib
 
-import simpleaudio as sa
 
-
-SOUNDS_DIR = os.path.join(os.path.dirname(__file__), "sounds")
+SOUND_PATH = pathlib.Path(__file__).parent / "sounds"
 """ Contains the absolute path to the sounds directory. """
 
-PLOP_WAVE = sa.WaveObject.from_wave_file(os.path.join(SOUNDS_DIR, "plop.wav"))
-""" SimpleAudio WaveObject containing the plop sound. """
+PLOP_PATH = SOUND_PATH / "plop.wav"
+""" Path to the "plop" sound. """
 
-UNDO_WAVE = sa.WaveObject.from_wave_file(os.path.join(SOUNDS_DIR, "undo.wav"))
-""" SimpleAudio WaveObject containing the undo sound. """
+UNDO_PATH = SOUND_PATH / "undo.wav"
+""" Path to the "undo" sound". """

piket_server/__init__.py

 Piket server, handles events generated by the client.
 """
 
-import datetime
-import os
-
-from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy import func
-from flask import Flask, jsonify, abort, request
-from flask_sqlalchemy import SQLAlchemy
-
-
-DATA_HOME = os.environ.get("XDG_DATA_HOME", "~/.local/share")
-CONFIG_DIR = os.path.join(DATA_HOME, "piket_server")
-DB_PATH = os.path.expanduser(os.path.join(CONFIG_DIR, "database.sqlite3"))
-DB_URL = f"sqlite:///{DB_PATH}"
-
-app = Flask("piket_server")
-app.config["SQLALCHEMY_DATABASE_URI"] = DB_URL
-app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
-db = SQLAlchemy(app)
-
-
-# ---------- Models ----------
-class Person(db.Model):
-    """ Represents a person to be shown on the lists. """
-
-    __tablename__ = "people"
-
-    person_id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String, nullable=False)
-    active = db.Column(db.Boolean, nullable=False, default=False)
-
-    consumptions = db.relationship("Consumption", backref="person", lazy=True)
-
-    def __repr__(self) -> str:
-        return f"<Person {self.person_id}: {self.name}>"
-
-    @property
-    def as_dict(self) -> dict:
-        return {
-            "person_id": self.person_id,
-            "active": self.active,
-            "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()
-                for ct in ConsumptionType.query.all()
-            },
-        }
-
-
-class Export(db.Model):
-    """ Represents a set of exported Settlements. """
-
-    __tablename__ = "exports"
-
-    export_id = db.Column(db.Integer, primary_key=True)
-    created_at = db.Column(
-        db.DateTime, default=datetime.datetime.utcnow, nullable=False
-    )
-
-    settlements = db.relationship("Settlement", backref="export", lazy=True)
-
-    @property
-    def as_dict(self) -> dict:
-        return {
-            "export_id": self.export_id,
-            "created_at": self.created_at.isoformat(),
-            "settlement_ids": [s.settlement_id for s in self.settlements],
-        }
-
-
-class Settlement(db.Model):
-    """ Represents a settlement of the list. """
-
-    __tablename__ = "settlements"
-
-    settlement_id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String, nullable=False)
-    export_id = db.Column(db.Integer, db.ForeignKey("exports.export_id"), nullable=True)
-
-    consumptions = db.relationship("Consumption", backref="settlement", lazy=True)
-
-    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,
-            "unique_people": self.unique_people,
-        }
-
-    @property
-    def unique_people(self) -> int:
-        q = (
-            Consumption.query.filter_by(settlement=self)
-            .filter_by(reversed=False)
-            .group_by(Consumption.person_id)
-            .count()
-        )
-        return q
-
-    @property
-    def consumption_summary(self) -> dict:
-        q = (
-            Consumption.query.filter_by(settlement=self)
-            .filter_by(reversed=False)
-            .group_by(Consumption.consumption_type_id)
-            .order_by(ConsumptionType.name)
-            .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}
-
-    @property
-    def per_person(self) -> dict:
-        # Get keys of seen consumption_types
-        c_types = self.consumption_summary.keys()
-
-        result = {}
-        for type in c_types:
-            c_type = ConsumptionType.query.get(type)
-            result[type] = {"consumption_type": c_type.as_dict, "counts": {}}
-
-            q = (
-                Consumption.query.filter_by(settlement=self)
-                .filter_by(reversed=False)
-                .filter_by(consumption_type=c_type)
-                .group_by(Consumption.person_id)
-                .order_by(Person.name)
-                .outerjoin(Person)
-                .with_entities(
-                    Person.person_id,
-                    Person.name,
-                    func.count(Consumption.consumption_id),
-                )
-                .all()
-            )
-
-            for row in q:
-                result[type]["counts"][row[0]] = {"name": row[1], "count": row[2]}
-
-        return result
-
-
-class ConsumptionType(db.Model):
-    """ Represents a type of consumption to be counted. """
-
-    __tablename__ = "consumption_types"
-
-    consumption_type_id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String, nullable=False)
-    icon = db.Column(db.String)
-    active = db.Column(db.Boolean, default=True)
-
-    consumptions = db.relationship("Consumption", backref="consumption_type", lazy=True)
-
-    def __repr__(self) -> str:
-        return f"<ConsumptionType: {self.name}>"
-
-    @property
-    def as_dict(self) -> dict:
-        return {
-            "consumption_type_id": self.consumption_type_id,
-            "name": self.name,
-            "icon": self.icon,
-        }
-
-
-class Consumption(db.Model):
-    """ Represent one consumption to be counted. """
-
-    __tablename__ = "consumptions"
-
-    consumption_id = db.Column(db.Integer, primary_key=True)
-    person_id = db.Column(db.Integer, db.ForeignKey("people.person_id"), nullable=True)
-    consumption_type_id = db.Column(
-        db.Integer,
-        db.ForeignKey("consumption_types.consumption_type_id"),
-        nullable=False,
-    )
-    settlement_id = db.Column(
-        db.Integer, db.ForeignKey("settlements.settlement_id"), nullable=True
-    )
-    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,
-        }
-
-
-# ---------- Models ----------
-
-
-@app.route("/ping")
-def ping() -> None:
-    """ 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"])
-def get_people():
-    """ Return a list of currently known people. """
-    people = Person.query.order_by(Person.name).all()
-    q = Person.query.order_by(Person.name)
-    if request.args.get("active"):
-        active_status = request.args.get("active", type=int)
-        q = q.filter_by(active=active_status)
-    people = q.all()
-    result = [person.as_dict for person in people]
-    return jsonify(people=result)
-
-
-@app.route("/people/<int:person_id>", methods=["GET"])
-def get_person(person_id: int):
-    person = Person.query.get_or_404(person_id)
-
-    return jsonify(person=person.as_dict)
-
-
-@app.route("/people", methods=["POST"])
-def add_person():
-    """
-    Add a new person.
-
-    Required parameters:
-    - name (str)
-    """
-    json = request.get_json()
-
-    if not json:
-        return jsonify({"error": "Could not parse JSON."}), 400
-
-    data = json.get("person") or {}
-    person = Person(name=data.get("name"), active=data.get("active", False))
-
-    try:
-        db.session.add(person)
-        db.session.commit()
-    except SQLAlchemyError:
-        return jsonify({"error": "Invalid arguments for Person."}), 400
-
-    return jsonify(person=person.as_dict), 201
-
-
-@app.route("/people/<int:person_id>/add_consumption", methods=["POST"])
-def add_consumption(person_id: int):
-    person = Person.query.get_or_404(person_id)
-
-    consumption = Consumption(person=person, consumption_type_id=1)
-    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
-
-
-@app.route("/people/<int:person_id>", methods=["PATCH"])
-def update_person(person_id: int):
-    person = Person.query.get_or_404(person_id)
-
-    data = request.json["person"]
-
-    if "active" in data:
-        person.active = data["active"]
-
-        db.session.add(person)
-        db.session.commit()
-
-        return jsonify(person=person.as_dict)
-
-
-@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
-
-
-@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():
-    """ Return a list of currently active consumption types. """
-    ctypes = ConsumptionType.query.filter_by(active=True).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
-
-
-# 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/<int:settlement_id>", methods=["GET"])
-def get_settlement(settlement_id: int):
-    """ Show full details for a single Settlement. """
-    s = Settlement.query.get_or_404(settlement_id)
-
-    per_person = s.per_person
-
-    return jsonify(settlement=s.as_dict, count_info=per_person)
-
-
-@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)
-
-
-# Export
-@app.route("/exports", methods=["GET"])
-def get_exports():
-    """ Return a list of the created Exports. """
-    result = Export.query.all()
-    return jsonify(exports=[e.as_dict for e in result])
-
-
-@app.route("/exports/<int:export_id>", methods=["GET"])
-def get_export(export_id: int):
-    """ Return an overview for the given Export. """
-    e = Export.query.get_or_404(export_id)
-
-    ss = [s.as_dict for s in e.settlements]
-
-    return jsonify(export=e.as_dict, settlements=ss)
-
-
-@app.route("/exports", methods=["POST"])
-def add_export():
-    """ Create an Export, and link all un-exported Settlements to it. """
-    # Assert that there are Settlements to be exported.
-    s_count = Settlement.query.filter_by(export=None).count()
-    if s_count == 0:
-        return jsonify(error="No un-exported Settlements."), 403
-
-    e = Export()
-
-    db.session.add(e)
-    db.session.commit()
-
-    Settlement.query.filter_by(export=None).update({"export_id": e.export_id})
-    db.session.commit()
-
-    ss = [s.as_dict for s in e.settlements]
-
-    return jsonify(export=e.as_dict, settlements=ss), 201
+from piket_server.flask import app
+
+import piket_server.routes.general
+import piket_server.routes.people
+import piket_server.routes.consumptions
+import piket_server.routes.consumption_types
+import piket_server.routes.settlements
+import piket_server.routes.exports
+import piket_server.routes.aardbei

piket_server/aardbei_sync.py

+from __future__ import annotations
+
+import datetime
+import json
+import logging
+import sys
+from dataclasses import asdict, dataclass
+from enum import Enum
+from typing import Any, Dict, List, NewType, Optional, Tuple, Union
+
+import requests
+
+from piket_server.flask import db
+from piket_server.models import Person
+from piket_server.util import fmt_datetime
+
+# AARDBEI_ENDPOINT = "https://aardbei.app"
+AARDBEI_ENDPOINT = "http://localhost:3000"
+log = logging.getLogger(__name__)
+
+ActivityId = NewType("ActivityId", int)
+PersonId = NewType("PersonId", int)
+MemberId = NewType("MemberId", int)
+ParticipantId = NewType("ParticipantId", int)
+
+
+@dataclass(frozen=True)
+class AardbeiPerson:
+    """
+    Contains the data on a Person as exposed by Aardbei.
+
+    A Person represents a person in the real world, and maps to a Person in the local database.
+    """
+
+    aardbei_id: PersonId
+    full_name: str
+
+    @classmethod
+    def from_aardbei_dict(cls, data: Dict[str, Any]) -> AardbeiPerson:
+        """
+        Load from a dictionary provided by Aardbei.
+
+        >>> AardbeiPerson.from_aardbei_dict(
+          {"person": {"aardbei_id": 1, "full_name": "Henkie Kraggelwenk"}}
+        )
+        AardbeiPerson(aardbei_id=AardbeiId(1), full_name="Henkie Kraggelwenk")
+        """
+
+        d = data["person"]
+        return cls(full_name=d["full_name"], aardbei_id=PersonId(d["id"]))
+
+    @property
+    def as_json_dict(self) -> Dict[str, Any]:
+        """
+        Serialize to a dictionary as provided by Aardbei.
+
+        >>> AardbeiPerson(aardbei_id=AardbeiId(1), full_name="Henkie Kraggelwenk").as_json_dict
+        {"person": {"id": 1, "full_name": "Henkie Kraggelwenk"}}
+        """
+
+        return {"person": {"id": self.aardbei_id, "full_name": self.full_name}}
+
+
+@dataclass(frozen=True)
+class AardbeiMember:
+    """
+    Contains the data on a Member exposed by Aardbei.
+
+    A Member represents the membership of a Person in a Group in Aardbei.
+    """
+
+    person: AardbeiPerson
+    aardbei_id: MemberId
+    is_leader: bool
+    display_name: str
+
+    @classmethod
+    def from_aardbei_dict(cls, data: Dict[str, Any]) -> AardbeiMember:
+        """
+        Load from a dictionary provided by Aardbei.
+
+        >>> from_aardbei_dict({
+            "member": {
+                "person": {
+                    "full_name": "Roer Kuggelvork",
+                    "id": 2,
+                },
+                "id": 23,
+                "is_leader": False,
+                "display_name": "Roer",
+            },
+        })
+        AardbeiMember(
+            person=AardbeiPerson(aardbei_id=PersonId(2), full_name="Roer Kuggelvork"),
+            aardbei_id=MemberId(23),
+            is_leader=False,
+            display_name="Roer",
+        )
+        """
+
+        d = data["member"]
+        person = AardbeiPerson.from_aardbei_dict(d)
+        return cls(
+            person=person,
+            aardbei_id=MemberId(d["id"]),
+            is_leader=d["is_leader"],
+            display_name=d["display_name"],
+        )
+
+    @property
+    def as_json_dict(self) -> Dict[str, Any]:
+        """
+        Serialize to a dict as provided by Aardbei.
+
+        >>> AardbeiMember(
+            person=AardbeiPerson(aardbei_id=PersonId(2), full_name="Roer Kuggelvork"),
+            aardbei_id=MemberId(23),
+            is_leader=False,
+            display_name="Roer",
+        )
+        {
+            "member": {
+                "person": {
+                    "full_name": "Roer Kuggelvork",
+                    "id": 2,
+                },
+                "id": 23,
+                "is_leader": False,
+                "display_name": "Roer",
+            }
+        }
+        """
+        res = {
+            "id": self.aardbei_id,
+            "is_leader": self.is_leader,
+            "display_name": self.display_name,
+        }
+        res.update(self.person.as_json_dict)
+        return res
+
+
+@dataclass(frozen=True)
+class AardbeiParticipant:
+    """
+    Represents a Participant as exposed by Aardbei.
+
+    A Participant represents the participation of a Person (optionally as a Member in a Group) in an Activity.
+    """
+
+    person: AardbeiPerson
+    member: Optional[AardbeiMember]
+    aardbei_id: ParticipantId
+    attending: bool
+    is_organizer: bool
+    notes: Optional[str]
+
+    @property
+    def name(self) -> str:
+        """
+        Return the name to show for this Participant.
+        This is the display_name if a Member is present, else the Participant's Person's full name.
+        """
+        if self.member is not None:
+            return self.member.display_name
+
+        return self.person.full_name
+
+    @classmethod
+    def from_aardbei_dict(cls, data: Dict[str, Any]) -> AardbeiParticipant:
+        """
+        Load from a dictionary as provided by Aardbei.
+        """
+        d = data["participant"]
+        person = AardbeiPerson.from_aardbei_dict(d)
+
+        member: Optional[AardbeiMember] = None
+        if d["member"] is not None:
+            member = AardbeiMember.from_aardbei_dict(d)
+
+        aardbei_id = ParticipantId(d["id"])
+
+        return cls(
+            person=person,
+            member=member,
+            aardbei_id=aardbei_id,
+            attending=d["attending"],
+            is_organizer=d["is_organizer"],
+            notes=d["notes"],
+        )
+
+    @property
+    def as_json_dict(self) -> Dict[str, Any]:
+        """
+        Serialize to a dict as provided by Aardbei.
+        """
+        res = {
+            "participant": {
+                "id": self.aardbei_id,
+                "attending": self.attending,
+                "is_organizer": self.is_organizer,
+                "notes": self.notes,
+            }
+        }
+        res.update(self.person.as_json_dict)
+        if self.member is not None:
+            res.update(self.member.as_json_dict)
+
+        return res
+
+
+class NoResponseAction(Enum):
+    """Represents the "no response action" attribute of Activities in Aardbei."""
+
+    Present = "present"
+    Absent = "absent"
+
+
+@dataclass(frozen=True)
+class ResponseCounts:
+    """Represents the "response counts" attribute of Activities in Aardbei."""
+
+    present: int
+    absent: int
+    unknown: int
+
+    @classmethod
+    def from_aardbei_dict(cls, data: Dict[str, int]) -> ResponseCounts:
+        """Load from a dict as provided by Aardbei."""
+        return cls(
+            present=data["present"], absent=data["absent"], unknown=data["unknown"]
+        )
+
+    @property
+    def as_json_dict(self) -> Dict[str, int]:
+        """Serialize to a dict as provided by Aardbei."""
+        return {"present": self.present, "absent": self.absent, "unknown": self.unknown}
+
+
+@dataclass(frozen=True)
+class SparseAardbeiActivity:
+    aardbei_id: ActivityId
+    name: str
+    description: str
+    location: str
+    start: datetime.datetime
+    end: Optional[datetime.datetime]
+    deadline: Optional[datetime.datetime]
+    reminder_at: Optional[datetime.datetime]
+    no_response_action: NoResponseAction
+    response_counts: ResponseCounts
+
+    def distance(self, reference: datetime.datetime) -> datetime.timedelta:
+        """Calculate how long ago this Activity ended / how much time until it starts."""
+        if self.end is not None:
+            if reference > self.start and reference < self.end:
+                return datetime.timedelta(seconds=0)
+
+            elif reference < self.start:
+                return self.start - reference
+
+            elif reference > self.end:
+                return reference - self.end
+
+        if reference > self.start:
+            return reference - self.start
+
+        return self.start - reference
+
+    @classmethod
+    def from_aardbei_dict(cls, data: Dict[str, Any]) -> SparseAardbeiActivity:
+        """Load from a dict as provided by Aardbei."""
+        start: datetime.datetime = datetime.datetime.fromisoformat(
+            data["activity"]["start"]
+        )
+        end: Optional[datetime.datetime] = None
+
+        if data["activity"]["end"] is not None:
+            end = datetime.datetime.fromisoformat(data["activity"]["end"])
+
+        deadline: Optional[datetime.datetime] = None
+        if data["activity"]["deadline"] is not None:
+            deadline = datetime.datetime.fromisoformat(data["activity"]["deadline"])
+
+        reminder_at: Optional[datetime.datetime] = None
+        if data["activity"]["reminder_at"] is not None:
+            reminder_at = datetime.datetime.fromisoformat(
+                data["activity"]["reminder_at"]
+            )
+
+        no_response_action = NoResponseAction(data["activity"]["no_response_action"])
+
+        response_counts = ResponseCounts.from_aardbei_dict(
+            data["activity"]["response_counts"]
+        )
+
+        return cls(
+            aardbei_id=ActivityId(data["activity"]["id"]),
+            name=data["activity"]["name"],
+            description=data["activity"]["description"],
+            location=data["activity"]["location"],
+            start=start,
+            end=end,
+            deadline=deadline,
+            reminder_at=reminder_at,
+            no_response_action=no_response_action,
+            response_counts=response_counts,
+        )
+
+    @property
+    def as_json_dict(self) -> Dict[str, Any]:
+        """Serialize to a dict as provided by Aardbei."""
+        return {
+            "activity": {
+                "id": self.aardbei_id,
+                "name": self.name,
+                "description": self.description,
+                "location": self.location,
+                "start": fmt_datetime(self.start),
+                "end": fmt_datetime(self.end),
+                "deadline": fmt_datetime(self.deadline),
+                "reminder_at": fmt_datetime(self.reminder_at),
+                "no_response_action": self.no_response_action.value,
+                "response_counts": self.response_counts.as_json_dict,
+            }
+        }
+
+
+@dataclass(frozen=True)
+class AardbeiActivity(SparseAardbeiActivity):
+    """Contains the data of an Activity as exposed by Aardbei."""
+
+    participants: List[AardbeiParticipant]
+
+    @classmethod
+    def from_aardbei_dict(cls, data: Dict[str, Any]) -> AardbeiActivity:
+        """Load from a dict as provided by Aardbei."""
+        # Ugly: This is a copy of the Sparse variant with added participants.
+        # This is not ideal, but I don't care enough to fix this right now.
+        participants: List[AardbeiParticipant] = [
+            AardbeiParticipant.from_aardbei_dict(x)
+            for x in data["activity"]["participants"]
+        ]
+
+        start: datetime.datetime = datetime.datetime.fromisoformat(
+            data["activity"]["start"]
+        )
+        end: Optional[datetime.datetime] = None
+
+        if data["activity"]["end"] is not None:
+            end = datetime.datetime.fromisoformat(data["activity"]["end"])
+
+        deadline: Optional[datetime.datetime] = None
+        if data["activity"]["deadline"] is not None:
+            deadline = datetime.datetime.fromisoformat(data["activity"]["deadline"])
+
+        reminder_at: Optional[datetime.datetime] = None
+        if data["activity"]["reminder_at"] is not None:
+            reminder_at = datetime.datetime.fromisoformat(
+                data["activity"]["reminder_at"]
+            )
+
+        no_response_action = NoResponseAction(data["activity"]["no_response_action"])
+
+        response_counts = ResponseCounts.from_aardbei_dict(
+            data["activity"]["response_counts"]
+        )
+
+        return cls(
+            aardbei_id=ActivityId(data["activity"]["id"]),
+            name=data["activity"]["name"],
+            description=data["activity"]["description"],
+            location=data["activity"]["location"],
+            start=start,
+            end=end,
+            deadline=deadline,
+            reminder_at=reminder_at,
+            no_response_action=no_response_action,
+            response_counts=response_counts,
+            participants=participants,
+        )
+
+    @property
+    def as_json_dict(self) -> Dict[str, Any]:
+        """Serialize to a dict as provided by Aardbei."""
+        res = super().as_json_dict
+        res["participants"] = [p.as_json_dict for p in self.participants]
+        return res
+
+
+@dataclass(frozen=True)
+class AardbeiMatch:
+    """Represents a match between a local Person and a Person present in Aardbei's data."""
+
+    local: Person
+    remote: AardbeiMember
+
+
+@dataclass(frozen=True)
+class AardbeiLink:
+    """Represents a set of differences between the local state and Aardbei's set of people."""
+
+    matches: List[AardbeiMatch]
+    """People that exist on both sides, but aren't linked in the people table."""
+    altered_name: List[AardbeiMatch]
+    """People that are already linked but changed one of their names."""
+    remote_only: List[AardbeiMember]
+    """People that only exist on the remote."""
+
+    @property
+    def num_changes(self) -> int:
+        """Return the amount of mismatching people between Aardbei and the local state."""
+        return len(self.matches) + len(self.altered_name) + len(self.remote_only)
+
+
+class AardbeiSyncError(Enum):
+    """Represents errors that might occur when retrieving data from Aardbei."""
+
+    CantConnect = "connect_fail"
+    HTTPError = "http_fail"
+
+
+def get_aardbei_people(
+    token: str, endpoint: str = AARDBEI_ENDPOINT
+) -> Union[List[AardbeiMember], AardbeiSyncError]:
+    """Retrieve the set of People in a Group from Aardbei, and parse this to
+    AardbeiPerson objects. Return a AardbeiSyncError if something fails."""
+    try:
+        resp: requests.Response = requests.get(
+            f"{endpoint}/api/groups/0/",
+            headers={"Authorization": f"Group {token}"},
+        )
+        resp.raise_for_status()
+
+    except requests.ConnectionError as e:
+        log.exception("Can't connect to endpoint %s", endpoint)
+        return AardbeiSyncError.CantConnect
+
+    except requests.HTTPError:
+        return AardbeiSyncError.HTTPError
+
+    members = resp.json()["group"]["members"]
+
+    return [AardbeiMember.from_aardbei_dict(x) for x in members]
+
+
+def match_local_aardbei(aardbei_members: List[AardbeiMember]) -> AardbeiLink:
+    """Inspect the local state and compare it with the set of given
+    AardbeiMembers (containing AardbeiPersons). Return a AardbeiLink that
+    indicates which local people don't match the remote state."""
+
+    matches: List[AardbeiMatch] = []
+    altered_name: List[AardbeiMatch] = []
+    remote_only: List[AardbeiMember] = []
+
+    for member in aardbei_members:
+        p: Optional[Person] = Person.query.filter_by(
+            aardbei_id=member.person.aardbei_id
+        ).one_or_none()
+
+        if p is not None:
+            if (
+                p.full_name != member.person.full_name
+                or p.display_name != member.display_name
+            ):
+                altered_name.append(AardbeiMatch(p, member))
+
+            else:
+                logging.info(
+                    "OK: %s / %s (L%s/R%s)",
+                    p.full_name,
+                    p.display_name,
+                    p.person_id,
+                    p.aardbei_id,
+                )
+
+            continue
+
+        p = Person.query.filter_by(full_name=member.person.full_name).one_or_none()
+
+        if p is not None:
+            matches.append(AardbeiMatch(p, member))
+        else:
+            remote_only.append(member)
+
+    return AardbeiLink(matches, altered_name, remote_only)
+
+
+def link_matches(matches: List[AardbeiMatch]) -> None:
+    """
+    Update local people to add the remote ID to the local state.
+    This only enqueues the changes in the local SQLAlchemy session, committing
+    needs to be done separately.
+    """
+
+    for match in matches:
+        match.local.aardbei_id = match.remote.person.aardbei_id
+        match.local.display_name = match.remote.display_name
+        logging.info(
+            "Linking local %s (%s) to remote %s (%s)",
+            match.local.full_name,
+            match.local.person_id,
+            match.remote.display_name,
+            match.remote.person.aardbei_id,
+        )
+
+        db.session.add(match.local)
+
+
+def create_missing(missing: List[AardbeiMember]) -> None:
+    """
+    Create local people for all remote people that don't exist locally.
+    This only enqueues the changes in the local SQLAlchemy session, committing
+    needs to be done separately.
+    """
+
+    for member in missing:
+        pnew = Person(
+            full_name=member.person.full_name,
+            display_name=member.display_name,
+            aardbei_id=member.person.aardbei_id,
+            active=False,
+        )
+        logging.info(
+            "Creating new person for %s / %s (%s)",
+            member.person.full_name,
+            member.display_name,
+            member.person.aardbei_id,
+        )
+        db.session.add(pnew)
+
+
+def update_names(matches: List[AardbeiMatch]) -> None:
+    """
+    Update the local full and display names of people that were already linked
+    to a remote person, and who changed names on the remote.
+
+    This only enqueues the changes in the local SQLAlchemy session, committing
+    needs to be done separately.
+    """
+
+    for match in matches:
+        p = match.local
+        member = match.remote
+        aardbei_person = member.person
+
+        changed = False
+
+        if p.full_name != aardbei_person.full_name:
+            logging.info(
+                "Updating %s (L%s/R%s) full name %s to %s",
+                aardbei_person.full_name,
+                p.person_id,
+                aardbei_person.aardbei_id,
+                p.full_name,
+                aardbei_person.full_name,
+            )
+            p.full_name = aardbei_person.full_name
+            changed = True
+
+        if p.display_name != member.display_name:
+            logging.info(
+                "Updating %s (L%s/R%s) display name %s to %s",
+                p.full_name,
+                p.person_id,
+                aardbei_person.aardbei_id,
+                p.display_name,
+                member.display_name,
+            )
+            p.display_name = member.display_name
+            changed = True
+
+        assert changed, "got match but didn't update anything"
+
+        db.session.add(p)
+
+
+def get_activities(
+    token: str, endpoint: str = AARDBEI_ENDPOINT
+) -> Union[List[SparseAardbeiActivity], AardbeiSyncError]:
+    """
+    Get the list of activities present on the remote and return these
+    activities, ordered by the temporal distance to the current time.
+    """
+
+    result: List[SparseAardbeiActivity] = []
+
+    for category in ("upcoming", "current", "previous"):
+        try:
+            resp = requests.get(
+                f"{endpoint}/api/groups/0/{category}_activities",
+                headers={"Authorization": f"Group {token}"},
+            )
+
+            resp.raise_for_status()
+
+        except requests.HTTPError as e:
+            log.exception(e)
+            return AardbeiSyncError.HTTPError
+
+        except requests.ConnectionError as e:
+            log.exception(e)
+            return AardbeiSyncError.CantConnect
+
+        for item in resp.json():
+            result.append(SparseAardbeiActivity.from_aardbei_dict(item))
+
+    now = datetime.datetime.now(datetime.timezone.utc)
+    result.sort(key=lambda x: SparseAardbeiActivity.distance(x, now))
+    return result
+
+
+def get_activity(
+    activity_id: ActivityId, token: str, endpoint: str
+) -> Union[AardbeiActivity, AardbeiSyncError]:
+    """
+    Get all data (including participants) from the remote about one activity
+    with a given ID.
+    """
+
+    try:
+        resp = requests.get(
+            f"{endpoint}/api/activities/{activity_id}",
+            headers={"Authorization": f"Group {token}"},
+        )
+
+        resp.raise_for_status()
+
+    except requests.HTTPError as e:
+        log.exception(e)
+        return AardbeiSyncError.HTTPError
+
+    except requests.ConnectionError as e:
+        return AardbeiSyncError.CantConnect
+
+    return AardbeiActivity.from_aardbei_dict(resp.json())
+
+
+def match_activity(activity: AardbeiActivity) -> None:
+    """
+    Update the local state to have mark all people present at the given
+    activity as active, and all other people as inactive.
+    """
+    ps = activity.participants
+    pids: List[PersonId] = [p.person.aardbei_id for p in ps if p.attending]
+
+    Person.query.update(values={"active": False})
+    Person.query.filter(Person.aardbei_id.in_(pids)).update(
+        values={"active": True}, synchronize_session="fetch"
+    )
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG)
+
+    token = input("Token: ")
+    aardbei_people = get_aardbei_people(token)
+
+    if isinstance(aardbei_people, AardbeiSyncError):
+        logging.error("Could not get people: %s", aardbei_people.value)
+        sys.exit(1)
+
+    activities = get_activities(token)
+
+    if isinstance(activities, AardbeiSyncError):
+        logging.error("Could not get activities: %s", activities.value)
+        sys.exit(1)
+
+    link = match_local_aardbei(aardbei_people)
+
+    link_matches(link.matches)
+    create_missing(link.remote_only)
+    update_names(link.altered_name)
+
+    confirm = input("Commit? Y/N")
+    if confirm.lower() == "y":
+        print("Committing.")
+        db.session.commit()
+    else:
+        print("Not committing.")

piket_server/alembic/env.py

 # This line sets up loggers basically.
 fileConfig(config.config_file_name)
 
-# add your model's MetaData object here
-# for 'autogenerate' support
-# from myapp import mymodel
-# target_metadata = mymodel.Base.metadata
-import piket_server
-
-target_metadata = piket_server.db.Model.metadata
-
 # other values from the config, defined by the needs of env.py,
 # can be acquired:
 # my_important_option = config.get_main_option("my_important_option")
 # ... etc.
-from piket_server import CONFIG_DIR, DB_URL
+from piket_server.flask import CONFIG_DIR, DB_URL, db
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = db.Model.metadata
 
 os.makedirs(os.path.expanduser(CONFIG_DIR), mode=0o744, exist_ok=True)
 
 config.file_config["alembic"]["sqlalchemy.url"] = DB_URL
 
 
-def run_migrations_offline():
+def run_migrations_offline() -> None:
     """Run migrations in 'offline' mode.
 
     This configures the context with just a URL
         context.run_migrations()
 
 
-def run_migrations_online():
+def run_migrations_online() -> None:
     """Run migrations in 'online' mode.
 
     In this scenario we need to create an Engine

piket_server/alembic/versions/6a5989118ee3_enable_unique_constraints.py

+"""Enable unique constraints
+
+Revision ID: 6a5989118ee3
+Revises: cca57457a0a6
+Create Date: 2019-09-22 17:04:01.945713
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "6a5989118ee3"
+down_revision = "cca57457a0a6"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("consumption_types") as batch_op:
+        batch_op.create_unique_constraint("uc_consumption_types_name", ["name"])
+
+    with op.batch_alter_table("people") as batch_op2:
+        batch_op2.create_unique_constraint("uc_people_aardbei_id", ["aardbei_id"])
+        batch_op2.create_unique_constraint("uc_people_full_name", ["full_name"])
+        batch_op2.create_unique_constraint("uc_people_display_name", ["display_name"])
+
+
+def downgrade():
+    with op.batch_alter_table("people") as batch_op2:
+        batch_op2.drop_constraint("uc_people_display_name", type_="unique")
+        batch_op2.drop_constraint("uc_people_full_name", type_="unique")
+        batch_op2.drop_constraint("uc_people_aardbei_id", type_="unique")
+
+    with op.batch_alter_table("consumption_types") as batch_op:
+        batch_op.drop_constraint("uc_consumption_types_name", type_="unique")

piket_server/alembic/versions/cca57457a0a6_add_aardbei_fields.py

+"""Add Aardbei fields
+
+Revision ID: cca57457a0a6
+Revises: 2f3a49058a67
+Create Date: 2019-09-05 21:38:28.489281
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "cca57457a0a6"
+down_revision = "2f3a49058a67"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("people") as batch_op:
+        batch_op.alter_column("name", new_column_name="full_name")
+        batch_op.add_column(sa.Column("aardbei_id", sa.Integer(), nullable=True))
+        batch_op.add_column(sa.Column("display_name", sa.String(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table("people") as batch_op:
+        batch_op.alter_column("full_name", new_column_name="name")
+        batch_op.drop_column("aardbei_id")
+        batch_op.drop_column("display_name")

piket_server/flask.py

+"""
+Defines the Flask object used to run the server.
+"""
+
+import os
+from typing import Any
+
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy  # type: ignore
+
+DATA_HOME = os.environ.get("XDG_DATA_HOME", "~/.local/share")
+CONFIG_DIR = os.path.join(DATA_HOME, "piket_server")
+DB_PATH = os.path.expanduser(os.path.join(CONFIG_DIR, "database.sqlite3"))
+DB_URL = f"sqlite:///{DB_PATH}"
+
+app = Flask("piket_server")
+app.config["SQLALCHEMY_DATABASE_URI"] = DB_URL
+app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+db: Any = SQLAlchemy(app)

piket_server/models.py

+"""
+Defines database models used by the server.
+"""
+
+import datetime
+from typing import List, Dict, Any
+from collections import defaultdict
+
+from sqlalchemy import func
+from sqlalchemy.exc import SQLAlchemyError
+
+from piket_server.flask import db
+
+
+class Person(db.Model):
+    """ Represents a person to be shown on the lists. """
+
+    __tablename__ = "people"
+
+    person_id = db.Column(db.Integer, primary_key=True)
+    full_name = db.Column(db.String, nullable=False, unique=True)
+    display_name = db.Column(db.String, nullable=True, unique=True)
+    aardbei_id = db.Column(db.Integer, nullable=True, unique=True)
+    active = db.Column(db.Boolean, nullable=False, default=False)
+
+    consumptions = db.relationship("Consumption", backref="person", lazy=True)
+
+    def __repr__(self) -> str:
+        return f"<Person {self.person_id}: {self.full_name}>"
+
+    @property
+    def as_dict(self) -> dict:
+        return {
+            "person_id": self.person_id,
+            "active": self.active,
+            "full_name": self.full_name,
+            "display_name": self.display_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()
+                for ct in ConsumptionType.query.all()
+            },
+        }
+
+
+class Export(db.Model):
+    """ Represents a set of exported Settlements. """
+
+    __tablename__ = "exports"
+
+    export_id = db.Column(db.Integer, primary_key=True)
+    created_at = db.Column(
+        db.DateTime, default=datetime.datetime.utcnow, nullable=False
+    )
+
+    settlements = db.relationship("Settlement", backref="export", lazy=True)
+
+    @property
+    def as_dict(self) -> dict:
+        return {
+            "export_id": self.export_id,
+            "created_at": self.created_at.isoformat(),
+            "settlement_ids": [s.settlement_id for s in self.settlements],
+        }
+
+
+class Settlement(db.Model):
+    """ Represents a settlement of the list. """
+
+    __tablename__ = "settlements"
+
+    settlement_id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String, nullable=False)
+    export_id = db.Column(db.Integer, db.ForeignKey("exports.export_id"), nullable=True)
+
+    consumptions = db.relationship("Consumption", backref="settlement", lazy=True)
+
+    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,
+            "unique_people": self.unique_people,
+            "per_person_counts": self.per_person_counts,
+            "count_info": self.per_person,
+        }
+
+    @property
+    def unique_people(self) -> int:
+        q = (
+            Consumption.query.filter_by(settlement=self)
+            .filter_by(reversed=False)
+            .group_by(Consumption.person_id)
+            .count()
+        )
+        return q
+
+    @property
+    def consumption_summary(self) -> dict:
+        q = (
+            Consumption.query.filter_by(settlement=self)
+            .filter_by(reversed=False)
+            .group_by(Consumption.consumption_type_id)
+            .order_by(ConsumptionType.name)
+            .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}
+
+    @property
+    def per_person(self) -> dict:
+        # Get keys of seen consumption_types
+        c_types = self.consumption_summary.keys()
+
+        result = {}
+        for type in c_types:
+            c_type = ConsumptionType.query.get(type)
+            result[type] = {"consumption_type": c_type.as_dict, "counts": {}}
+
+            q = (
+                Consumption.query.filter_by(settlement=self)
+                .filter_by(reversed=False)
+                .filter_by(consumption_type=c_type)
+                .group_by(Consumption.person_id)
+                .order_by(Person.full_name)
+                .outerjoin(Person)
+                .with_entities(
+                    Person.person_id,
+                    Person.full_name,
+                    func.count(Consumption.consumption_id),
+                )
+                .all()
+            )
+
+            for row in q:
+                result[type]["counts"][row[0]] = {"name": row[1], "count": row[2]}
+
+        return result
+
+    @property
+    def per_person_counts(self) -> Dict[int, Any]:
+        """
+        Output a more usable dict containing for each person in the settlement
+        how many of each consumption type was counted.
+        """
+
+        q = (
+            Consumption.query.filter_by(settlement=self)
+            .filter_by(reversed=False)
+            .group_by(Consumption.person_id)
+            .group_by(Consumption.consumption_type_id)
+            .group_by(Person.full_name)
+            .outerjoin(Person)
+            .with_entities(
+                Consumption.person_id,
+                Person.full_name,
+                Consumption.consumption_type_id,
+                func.count(Consumption.consumption_id),
+            )
+            .all()
+        )
+
+        res: Dict[int, Any] = defaultdict(dict)
+
+        for row in q:
+            item = res[row[0]]
+            item["full_name"] = row[1]
+            if not item.get("counts"):
+                item["counts"] = {}
+
+            item["counts"][row[2]] = row[3]
+
+        return res
+
+
+
+
+class ConsumptionType(db.Model):
+    """ Represents a type of consumption to be counted. """
+
+    __tablename__ = "consumption_types"
+
+    consumption_type_id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String, nullable=False, unique=True)
+    icon = db.Column(db.String)
+    active = db.Column(db.Boolean, default=True)
+
+    consumptions = db.relationship("Consumption", backref="consumption_type", lazy=True)
+
+    def __repr__(self) -> str:
+        return f"<ConsumptionType: {self.name}>"
+
+    @property
+    def as_dict(self) -> dict:
+        return {
+            "consumption_type_id": self.consumption_type_id,
+            "name": self.name,
+            "icon": self.icon,
+            "active": self.active,
+        }
+
+
+class Consumption(db.Model):
+    """ Represent one consumption to be counted. """
+
+    __tablename__ = "consumptions"
+
+    consumption_id = db.Column(db.Integer, primary_key=True)
+    person_id = db.Column(db.Integer, db.ForeignKey("people.person_id"), nullable=True)
+    consumption_type_id = db.Column(
+        db.Integer,
+        db.ForeignKey("consumption_types.consumption_type_id"),
+        nullable=False,
+    )
+    settlement_id = db.Column(
+        db.Integer, db.ForeignKey("settlements.settlement_id"), nullable=True
+    )
+    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.full_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,
+        }

piket_server/routes/aardbei.py

+from typing import Any, Dict, List, Tuple, Union
+
+from flask import request
+
+from piket_server.aardbei_sync import (
+    AARDBEI_ENDPOINT,
+    ActivityId,
+    get_activity,
+    AardbeiLink,
+    AardbeiSyncError,
+    create_missing,
+    get_aardbei_people,
+    match_activity,
+    get_activities,
+    link_matches,
+    match_local_aardbei,
+    update_names,
+)
+from piket_server.flask import app, db
+
+
+def common_prepare_aardbei_sync(
+    token: str, endpoint: str
+) -> Union[AardbeiSyncError, AardbeiLink]:
+    aardbei_people = get_aardbei_people(token, endpoint)
+
+    if isinstance(aardbei_people, AardbeiSyncError):
+        return aardbei_people
+
+    aardbei_activities = get_activities(token, endpoint)
+
+    if isinstance(aardbei_activities, AardbeiSyncError):
+        return aardbei_activities
+
+    return match_local_aardbei(aardbei_people)
+
+
+@app.route("/aardbei/diff_people", methods=["POST"])
+def aardbei_diff() -> Tuple[Dict[str, Any], int]:
+    data: Dict[str, str] = request.json
+    link = common_prepare_aardbei_sync(
+        data["token"], data.get("endpoint", AARDBEI_ENDPOINT)
+    )
+
+    if isinstance(link, AardbeiSyncError):
+        return {"error": link.value}, 503
+
+    return (
+        {
+            "num_changes": link.num_changes,
+            "new_people": [member.person.full_name for member in link.remote_only],
+            "link_existing": [match.local.full_name for match in link.matches],
+            "altered_name": [match.local.full_name for match in link.matches],
+        },
+        200,
+    )
+
+
+@app.route("/aardbei/sync_people", methods=["POST"])
+def aardbei_apply() -> Union[Tuple[Dict[str, Any], int]]:
+    data: Dict[str, str] = request.json
+    link = common_prepare_aardbei_sync(
+        data["token"], data.get("endpoint", AARDBEI_ENDPOINT)
+    )
+
+    if isinstance(link, AardbeiSyncError):
+        return {"error": link.value}, 503
+
+    link_matches(link.matches)
+    create_missing(link.remote_only)
+    update_names(link.altered_name)
+
+    db.session.commit()
+
+    return (
+        {
+            "num_changes": link.num_changes,
+            "new_people": [member.person.full_name for member in link.remote_only],
+            "link_existing": [match.local.full_name for match in link.matches],
+            "altered_name": [match.local.full_name for match in link.altered_name],
+        },
+        200,
+    )
+
+
+@app.route("/aardbei/get_activities", methods=["POST"])
+def aardbei_get_activities() -> Tuple[Dict[str, object], int]:
+    data: Dict[str, str] = request.json
+    activities = get_activities(data["token"], data.get("endpoint", AARDBEI_ENDPOINT))
+
+    if isinstance(activities, AardbeiSyncError):
+        return {"error": activities.value}, 503
+
+    return {"activities": [x.as_json_dict for x in activities]}, 200
+
+
+@app.route("/aardbei/apply_activity", methods=["POST"])
+def aardbei_apply_activity() -> Tuple[Dict[str, Any], int]:
+    data: Dict[str, Union[str, int]] = request.json
+    aid = data["activity_id"]
+    token = data["token"]
+    endpoint = data["endpoint"]
+
+    if not isinstance(aid, int):
+        return {"error": "nonnumeric_activity_id"}, 400
+
+    if not isinstance(token, str):
+        return {"error": "illtyped_token"}, 400
+
+    if not isinstance(endpoint, str):
+        return {"error": "illtyped_endpoint"}, 400
+
+    activity = get_activity(activity_id=ActivityId(aid), token=token, endpoint=endpoint)
+
+    if isinstance(activity, AardbeiSyncError):
+        return {"error": activity.value}, 503
+
+    match_activity(activity)
+    db.session.commit()
+
+    return (activity.as_json_dict, 200)

piket_server/routes/consumption_types.py

+"""
+Provides routes related to managing ConsumptionType objects.
+"""
+
+from sqlalchemy.exc import SQLAlchemyError
+from flask import jsonify, request
+
+from piket_server.models import ConsumptionType
+from piket_server.flask import app, db
+
+
+@app.route("/consumption_types", methods=["GET"])
+def get_consumption_types():
+    """ Return a list of currently active consumption types. """
+    try:
+        active = int(request.args.get("active", 1))
+
+    except ValueError:
+        return {}, 400
+
+    ctypes = ConsumptionType.query.filter_by(active=active).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
+
+
+@app.route("/consumption_types/<int:consumption_type_id>", methods=["PATCH"])
+def activate_consumption_type(consumption_type_id: int):
+    ct = ConsumptionType.query.get_or_404(consumption_type_id)
+
+    data = request.json["consumption_type"]
+    new_active = data.get("active", True)
+
+    ct.active = new_active
+    db.session.add(ct)
+    db.session.commit()
+
+    return jsonify(consumption_type=ct.as_dict), 200

piket_server/routes/consumptions.py

+"""
+Provides routes related to Consumption objects.
+"""
+
+from flask import jsonify
+from sqlalchemy.exc import SQLAlchemyError
+
+from piket_server.flask import app, db
+from piket_server.models import Consumption
+
+
+@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

piket_server/routes/exports.py

+"""
+Provides routes for managing Export objects.
+"""
+
+from flask import jsonify
+from sqlalchemy.exc import SQLAlchemyError
+
+from piket_server.flask import app, db
+from piket_server.models import Export, Settlement
+
+@app.route("/exports", methods=["GET"])
+def get_exports():
+    """ Return a list of the created Exports. """
+    result = Export.query.all()
+    return jsonify(exports=[e.as_dict for e in result])
+
+
+@app.route("/exports/<int:export_id>", methods=["GET"])
+def get_export(export_id: int):
+    """ Return an overview for the given Export. """
+    e = Export.query.get_or_404(export_id)
+
+    ss = [s.as_dict for s in e.settlements]
+
+    return jsonify(export=e.as_dict, settlements=ss)
+
+
+@app.route("/exports", methods=["POST"])
+def add_export():
+    """ Create an Export, and link all un-exported Settlements to it. """
+    # Assert that there are Settlements to be exported.
+    s_count = Settlement.query.filter_by(export=None).count()
+    if s_count == 0:
+        return jsonify(error="No un-exported Settlements."), 403
+
+    e = Export()
+
+    db.session.add(e)
+    db.session.commit()
+
+    Settlement.query.filter_by(export=None).update({"export_id": e.export_id})
+    db.session.commit()
+
+    ss = [s.as_dict for s in e.settlements]
+
+    return jsonify(export=e.as_dict, settlements=ss), 201

piket_server/routes/general.py

+"""
+Provides general routes.
+"""
+
+from flask import jsonify
+
+from piket_server.flask import app
+from piket_server.models import Consumption
+
+
+@app.route("/ping")
+def ping() -> str:
+    """ Return a status ping. """
+    return "Pong"
+
+
+@app.route("/status")
+def status():
+    """ 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}})

piket_server/routes/people.py

+"""
+Provides routes related to managing Person objects.
+"""
+
+from flask import jsonify, request
+from sqlalchemy.exc import SQLAlchemyError
+
+from piket_server.models import Consumption, Person
+from piket_server.flask import app, db
+
+
+@app.route("/people", methods=["GET"])
+def get_people():
+    """ Return a list of currently known people. """
+    people = Person.query.order_by(Person.full_name).all()
+    q = Person.query.order_by(Person.full_name)
+    if request.args.get("active"):
+        active_status = request.args.get("active", type=int)
+        q = q.filter_by(active=active_status)
+    people = q.all()
+    result = [person.as_dict for person in people]
+    return jsonify(people=result)
+
+
+@app.route("/people/<int:person_id>", methods=["GET"])
+def get_person(person_id: int):
+    person = Person.query.get_or_404(person_id)
+
+    return jsonify(person=person.as_dict)
+
+
+@app.route("/people", methods=["POST"])
+def add_person():
+    """
+    Add a new person.
+
+    Required parameters:
+    - name (str)
+    """
+    json = request.get_json()
+
+    if not json:
+        return jsonify({"error": "Could not parse JSON."}), 400
+
+    data = json.get("person") or {}
+    person = Person(
+        full_name=data.get("full_name"),
+        active=data.get("active", False),
+        display_name=data.get("display_name", None),
+    )
+
+    try:
+        db.session.add(person)
+        db.session.commit()
+    except SQLAlchemyError:
+        return jsonify({"error": "Invalid arguments for Person."}), 400
+
+    return jsonify(person=person.as_dict), 201
+
+
+@app.route("/people/<int:person_id>", methods=["PATCH"])
+def update_person(person_id: int):
+    person = Person.query.get_or_404(person_id)
+
+    data = request.json["person"]
+    changed = False
+
+    if "active" in data:
+        person.active = data["active"]
+        changed = True
+
+    if "full_name" in data:
+        person.full_name = data["full_name"]
+        changed = True
+
+    if "display_name" in data:
+        person.display_name = data["display_name"]
+        changed = True
+
+    if changed:
+        db.session.add(person)
+        db.session.commit()
+
+    return jsonify(person=person.as_dict)
+
+
+@app.route("/people/<int:person_id>/add_consumption", methods=["POST"])
+def add_consumption(person_id: int):
+    person = Person.query.get_or_404(person_id)
+
+    consumption = Consumption(person=person, consumption_type_id=1)
+    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
+
+
+@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

piket_server/routes/settlements.py

+"""
+Provides routes for managing Settlement objects.
+"""
+
+from sqlalchemy.exc import SQLAlchemyError
+from flask import jsonify, request
+
+from piket_server.flask import app, db
+from piket_server.models import Consumption, 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/<int:settlement_id>", methods=["GET"])
+def get_settlement(settlement_id: int):
+    """ Show full details for a single Settlement. """
+    s = Settlement.query.get_or_404(settlement_id)
+
+    per_person = s.per_person
+
+    return jsonify(settlement=s.as_dict, count_info=per_person)
+
+
+@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, count_info=s.per_person)

piket_server/seed.py

 import csv
 import os
 
-from piket_server import db, Person, Settlement, ConsumptionType, Consumption
+from piket_server.models import Person, Settlement, ConsumptionType, Consumption
+from piket_server.flask import db
 
 
 def main():
         print("All data removed. Recreating database...")
         db.create_all()
 
-        from alembic.config import Config
-        from alembic import command
+        from alembic.config import Config  # type: ignore
+        from alembic import command  # type: ignore
 
         alembic_cfg = Config(os.path.join(os.path.dirname(__file__), "alembic.ini"))
         command.stamp(alembic_cfg, "head")

piket_server/util.py

+import datetime
+from typing import Optional
+
+
+def fmt_datetime(x: Optional[datetime.datetime]) -> Optional[str]:
+    """Format a datetime as ISO 8601, if it's not None."""
+    if x is not None:
+        return x.isoformat()
+
+    return None

setup.py

     entry_points={
         "console_scripts": [
             "piket-client=piket_client.gui:main",
+            "piket-cli=piket_client.cli:cli",
             "piket-seed=piket_server.seed:main",
         ]
     },
     install_requires=[],
     extras_require={
-        "dev": ["black", "pylint"],
+        "dev": ["black", "pylint", "mypy", "isort"],
         "server": ["Flask", "SQLAlchemy", "Flask-SQLAlchemy", "alembic", "uwsgi"],
-        "client": ["PySide2", "qdarkstyle>=2.6.0", "requests", "simpleaudio"],
+        "client": ["PySide2", "qdarkstyle>=2.6.0", "requests", "simpleaudio", "click", "prettytable"],
         "osk": ["dbus-python"],
         "sentry": ["raven"],
     },