Import from e4b104792206ee7ea64bf39c6b7d2c0c230f9d14

1 files changed, 137 insertions, 0 deletions

diff --git a/server/src/rwgps.cppm b/server/src/rwgps.cppm
new file mode 100644
index 0000000..7ad6605
--- /dev/null
+++ b/server/src/rwgps.cppm
@@ -0,0 +1,137 @@
+module;
+
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/json.hpp>
+
+export module routemon:rwgps;
+
+import std;
+import :http.client;
+import :log;
+
+namespace beast = boost::beast;
+namespace bhttp = beast::http;
+namespace net = boost::asio;
+namespace json = boost::json;
+
+namespace routemon::rwgps {
+
+  export struct route_summary {
+    std::int64_t id;
+    std::int64_t user_id;
+    std::string  url;
+    std::string  name;
+    std::string  description;
+  };
+
+  struct pagination {
+    std::size_t record_count;
+    std::size_t page_count;
+    std::size_t page_size;
+    std::optional<std::string> next_page_url;
+  };
+
+  struct get_routes_meta {
+    pagination pagination;
+  };
+
+  struct get_routes_response {
+    std::vector<route_summary> routes;
+    get_routes_meta meta;
+  };
+
+  auto tag_invoke(json::value_to_tag<route_summary> const&, json::value const& jv) -> route_summary {
+    return {
+      .id          = json::value_to<std::int64_t>(jv.at("id")),
+      .user_id     = json::value_to<std::int64_t>(jv.at("user_id")),
+      .url         = json::value_to<std::string>(jv.at("url")),
+      .name        = json::value_to<std::string>(jv.at("name")),
+      .description = json::value_to<std::string>(jv.at("description")),
+    };
+  }
+
+  auto tag_invoke(json::value_to_tag<pagination> const&, json::value const& jv) -> pagination {
+    return {
+      .record_count  = json::value_to<std::size_t>(jv.at("record_count")),
+      .page_count    = json::value_to<std::size_t>(jv.at("page_count")),
+      .page_size     = json::value_to<std::size_t>(jv.at("page_size")),
+      .next_page_url = json::value_to<std::optional<std::string>>(jv.at("next_page_url")),
+    };
+  }
+
+  auto tag_invoke(json::value_to_tag<get_routes_meta> const&, json::value const& jv) -> get_routes_meta {
+    return {
+      .pagination = json::value_to<pagination>(jv.at("pagination")),
+    };
+  }
+
+  auto tag_invoke(json::value_to_tag<get_routes_response> const&, json::value const& jv) -> get_routes_response {
+    return {
+      .routes = json::value_to<std::vector<route_summary>>(jv.at("routes")),
+      .meta   = json::value_to<get_routes_meta>(jv.at("meta")),
+    };
+  }
+
+  auto json_value_to_get_routes_response(json::value const& jv) -> get_routes_response {
+    return json::value_to<get_routes_response>(jv);
+  }
+
+  export class client {
+    log::logger  l_;
+    http::client hc_;
+    std::string  api_key_;
+    std::string  auth_token_;
+
+    static constexpr std::string host = "ridewithgps.com";
+
+    // TODO: handle failure appropriately
+    auto get_routes_page(std::size_t page) -> get_routes_response {
+      auto req = bhttp::request<bhttp::string_body>{
+        bhttp::verb::get,
+        std::format("/api/v1/routes.json?page_size=200?page={}", page),
+        11, // HTTP 1.1
+      };
+      req.set(bhttp::field::host, host);
+      req.set("x-rwgps-api-key", api_key_);
+      req.set("x-rwgps-auth-token", auth_token_);
+
+      auto rsp = hc_.do_request(req);
+      auto p = json::stream_parser{};
+      for (auto const frag : rsp.body().cdata()) {
+        p.write(static_cast<char const*>(frag.data()), frag.size());
+      }
+      assert(p.done());
+      return json_value_to_get_routes_response(p.release());
+    }
+
+  public:
+    explicit client(net::io_context& ioc, log::logger const& l, std::string api_key, std::string auth_token)
+      : l_{l.sub("rwgps-client")}, hc_{ioc}, api_key_{std::move(api_key)}, auth_token_{std::move(auth_token)}
+    {}
+
+    auto get_all_routes() -> std::vector<route_summary> {
+      // TODO: make sure that there are no duplicates here.
+      // What does RWGPS sort on, by default?
+      // Consider using an associative container instead of a vector.
+      auto record_count = 0uz;
+      auto current_page = 0uz;
+      auto routes = std::vector<route_summary>{};
+
+      while (true) {
+        auto rsp = get_routes_page(current_page);
+        if (rsp.meta.pagination.next_page_url)
+          l_.debug("Next page URL: {}", *rsp.meta.pagination.next_page_url);
+        routes.append_range(rsp.routes);
+        if (rsp.meta.pagination.record_count > 0)
+          record_count = rsp.meta.pagination.record_count;
+        if (rsp.routes.empty() || routes.size() >= record_count) {
+          break;
+        }
+      }
+
+      return routes;
+    }
+  };
+
+} // namespace routemon::rwgps