Expose count info in Settlement

piket_client/model.py

 """
 import datetime
 import logging
-from typing import NamedTuple
+from typing import NamedTuple, Sequence
 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 ServerStatus:
         except requests.ConnectionError as ex:
             return False, ex
 
-    datetime_format = "%Y-%m-%dT%H:%M:%S.%f"
-
     @classmethod
     def unsettled_consumptions(cls) -> dict:
         req = requests.get(urljoin(SERVER_URL, "status"))
 
         if data["unsettled"]["amount"]:
             data["unsettled"]["first"] = datetime.datetime.strptime(
-                data["unsettled"]["first"], cls.datetime_format
+                data["unsettled"]["first"], DATETIME_FORMAT
             )
             data["unsettled"]["last"] = datetime.datetime.strptime(
-                data["unsettled"]["last"], cls.datetime_format
+                data["unsettled"]["last"], DATETIME_FORMAT
             )
 
         return data
         )
 
 
+class Export(NamedTuple):
+    created_at: datetime.datetime
+    settlement_ids: Sequence[int]
+    export_id: int
+    settlements: Sequence["Settlement"] = []
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Export":
+        """ Reconstruct an Export from a dict. """
+        return cls(
+            export_id=data["export_id"],
+            created_at=datetime.datetime.strptime(data["created_at"], DATETIME_FORMAT),
+            settlement_ids=data["settlement_ids"],
+            settlements=data.get("settlements", []),
+        )
+
+    @classmethod
+    def get_all(cls) -> ["Export"]:
+        """ Get a list of all existing Exports. """
+        req = requests.get(urljoin(SERVER_URL, "exports"))
+
+        try:
+            data = req.json()
+        except ValueError:
+            LOG.error(
+                "Did not get JSON on listing Exports (%s): %s",
+                req.status_code,
+                req.content,
+            )
+            return None
+
+        if "error" in data or req.status_code != 200:
+            LOG.error("Could not list Exports (%s): %s", req.status_code, data)
+            return None
+
+        return [cls.from_dict(e) for e in data["exports"]]
+
+    @classmethod
+    def get(cls, export_id: int) -> "Export":
+        """ Retrieve one Export. """
+        req = requests.get(urljoin(SERVER_URL, f"exports/{export_id}"))
+
+        try:
+            data = req.json()
+        except ValueError:
+            LOG.error(
+                "Did not get JSON on getting Export (%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
+
+        data["export"]["settlements"] = data["settlements"]
+
+        return cls.from_dict(data["export"])
+
+    @classmethod
+    def create(cls) -> "Export":
+        """ Create a new Export, containing all un-exported Settlements. """
+        req = requests.post(urljoin(SERVER_URL, "exports"))
+
+        try:
+            data = req.json()
+        except ValueError:
+            LOG.error(
+                "Did not get JSON on adding Export (%s): %s",
+                req.status_code,
+                req.content,
+            )
+            return None
+
+        if "error" in data or req.status_code != 201:
+            LOG.error("Could not create Export (%s): %s", req.status_code, data)
+            return None
+
+        data["export"]["settlements"] = data["settlements"]
+
+        return cls.from_dict(data["export"])
+
+
 class ConsumptionType(NamedTuple):
     """ Represents a stored ConsumptionType. """
 
     @classmethod
     def from_dict(cls, data: dict) -> "Consumption":
         """ Reconstruct a Consumption from a dict. """
-        datetime_format = "%Y-%m-%dT%H:%M:%S.%f"
-        # 2018-08-31T17:30:47.871521
         return cls(
             consumption_id=data["consumption_id"],
             person_id=data["person_id"],
             consumption_type_id=data["consumption_type_id"],
             settlement_id=data["settlement_id"],
-            created_at=datetime.datetime.strptime(data["created_at"], datetime_format),
+            created_at=datetime.datetime.strptime(data["created_at"], DATETIME_FORMAT),
             reversed=data["reversed"],
         )
 
     settlement_id: int
     name: str
     consumption_summary: dict
+    count_info: dict = {}
 
     @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", {}),
         )
 
     @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}"))
+
+        try:
+            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
+
+        data["settlement"]["count_info"] = data["count_info"]
+
+        return cls.from_dict(data["settlement"])

piket_server/__init__.py

         return {
             "export_id": self.export_id,
             "created_at": self.created_at.isoformat(),
-            "settlements": [s.settlement_id for s in self.settlements],
+            "settlement_ids": [s.settlement_id for s in self.settlements],
         }
 
 
 @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)
     Settlement.query.filter_by(export=None).update({"export_id": e.export_id})
     db.session.commit()
 
-    return jsonify(export=e.as_dict), 201
+    ss = [s.as_dict for s in e.settlements]
+
+    return jsonify(export=e.as_dict, settlements=ss), 201