piket_client/cli.py

 import click
 from piket_client.model import (
+    AardbeiActivity,
     ServerStatus,
     NetworkError,
     Consumption,
+    AardbeiPeopleDiff,
     Person,
     Settlement,
     ConsumptionType,
     click.echo(click.style(msg, fg="red", bold=True), err=True)
 
 
+@cli.group()
+@click.option("--token", required=True)
+@click.option("--endpoint", default="http://localhost:3000")
+@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/model.py

             return NetworkError.HttpFailure
 
         except ValueError as e:
+            LOG.exception(e)
             return NetworkError.InvalidData
 
     @classmethod
         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_server/aardbei_sync.py

 
     for member in aardbei_members:
         p: Optional[Person] = Person.query.filter_by(
-            aardbei_id=member.aardbei_id
+            aardbei_id=member.person.aardbei_id
         ).one_or_none()
 
         if p is not None:
     """
 
     for match in matches:
-        match.local.aardbei_id = match.remote.aardbei_id
+        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.aardbei_id,
+            match.remote.person.aardbei_id,
         )
 
         db.session.add(match.local)
         pnew = Person(
             full_name=member.person.full_name,
             display_name=member.display_name,
-            aardbei_id=member.aardbei_id,
+            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.aardbei_id,
+            member.person.aardbei_id,
         )
         db.session.add(pnew)
 
         for item in resp.json():
             result.append(SparseAardbeiActivity.from_aardbei_dict(item))
 
-    now = datetime.datetime.now()
+    now = datetime.datetime.now(datetime.timezone.utc)
     result.sort(key=lambda x: SparseAardbeiActivity.distance(x, now))
     return result
 
     activity as active, and all other people as inactive.
     """
     ps = activity.participants
-    pids: List[PersonId] = [p.person.aardbei_id for p in ps]
+    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(

piket_server/routes/aardbei.py

     return match_local_aardbei(aardbei_people)
 
 
-@app.route("/people/aardbei_diff", methods=["POST"])
+@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(
         {
             "num_changes": link.num_changes,
             "new_people": [member.person.full_name for member in link.remote_only],
-            "link_existing": [match.local.name for match in link.matches],
-            "altered_name": [match.local.name for match in link.matches],
+            "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("/people/aardbei_apply", methods=["POST"])
+@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(