piket_client/cli.py

     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}.')
+
+
 @cli.group()
 def settlements():
     pass

piket_client/gui.py

 """
 import collections
 import logging
+import math
 import os
 import sys
+from typing import Deque
 
 import qdarkstyle
 
     @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("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())
         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()
         """ 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:
             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)
                     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

             )
             return None
 
-    def create(self) -> Optional[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:
-            data = req.json()
-        except ValueError:
-            LOG.error(
-                "Did not get JSON on adding Person (%s): %s",
-                req.status_code,
-                req.content,
+            req = requests.post(
+                urljoin(SERVER_URL, "people"),
+                json={
+                    "person": {
+                        "full_name": self.full_name,
+                        "display_name": self.display_name,
+                        "active": True,
+                    }
+                },
             )
-            return None
+            req.raise_for_status()
+            data = req.json()
+            return Person.from_dict(data["person"])
 
-        if "error" in data or req.status_code != 201:
-            LOG.error("Could not create Person (%s): %s", req.status_code, data)
-            return None
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
 
-        return Person.from_dict(data["person"])
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
 
     def set_active(self, new_state=True) -> Optional[Person]:
         req = requests.patch(

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/models.py

     __tablename__ = "people"
 
     person_id = db.Column(db.Integer, primary_key=True)
-    full_name = db.Column(db.String, nullable=False)
-    display_name = db.Column(db.String, nullable=True)
-    aardbei_id = db.Column(db.Integer, nullable=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)
     __tablename__ = "consumption_types"
 
     consumption_type_id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String, nullable=False)
+    name = db.Column(db.String, nullable=False, unique=True)
     icon = db.Column(db.String)
     active = db.Column(db.Boolean, default=True)
 

piket_server/routes/people.py

         return jsonify({"error": "Could not parse JSON."}), 400
 
     data = json.get("person") or {}
-    person = Person(name=data.get("name"), active=data.get("active", False))
+    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)

setup.py

     entry_points={
         "console_scripts": [
             "piket-client=piket_client.gui:main",
+            "piket-cli=piket_client.cli:cli",
             "piket-seed=piket_server.seed:main",
         ]
     },