Add event list to new frontend

ofdb-boundary/Cargo.toml

@@ -12,10 +12,14 @@ rust-version.workspace = true
 
 [dependencies]
 serde = { version = "1.0.188", features = ["derive"] }
-time = { version = "0.3.28", features = ["serde"] }
+
+[dependencies.time]
+version = "0.3.28"
+default-features = false
+features = ["serde"]
 
 [dependencies.ofdb-entities]
-version = "0.12.0"
+version = "0.12.6"
 path = "../ofdb-entities"
 optional = true
 
@@ -24,10 +28,10 @@ version = "1.0.48"
 optional = true
 
 [features]
-default = ["entity-conversions", "thiserror"]
-extra-derive = ["thiserror"]
-entity-conversions = ["ofdb-entities"]
-wasm-bindgen = ["ofdb-entities/wasm-bindgen"]
+default = ["entity-conversions", "dep:thiserror"]
+extra-derive = ["dep:thiserror"]
+entity-conversions = ["dep:ofdb-entities"]
+wasm-bindgen = ["ofdb-entities/wasm-bindgen", "time/wasm-bindgen"]
 
 [badges]
 maintenance = { status = "actively-developed" }

ofdb-boundary/src/lib.rs

@@ -32,6 +32,19 @@ pub struct UnixTimeMillis(i64);
 #[cfg_attr(feature = "extra-derive", derive(Debug, Clone, Copy, Eq, PartialEq))]
 pub struct UnixTimeSeconds(i64);
 
+impl From<time::OffsetDateTime> for UnixTimeSeconds {
+    fn from(from: time::OffsetDateTime) -> Self {
+        Self(from.unix_timestamp())
+    }
+}
+
+impl TryFrom<UnixTimeSeconds> for time::OffsetDateTime {
+    type Error = time::error::ComponentRange;
+    fn try_from(from: UnixTimeSeconds) -> Result<Self, Self::Error> {
+        Self::from_unix_timestamp(from.0)
+    }
+}
+
 #[rustfmt::skip]
 #[derive(Serialize, Deserialize)]
 #[cfg_attr(feature = "extra-derive", derive(Debug, Clone, PartialEq))]

ofdb-frontend-api/Cargo.toml

@@ -12,6 +12,7 @@ rust-version.workspace = true
 [dependencies]
 percent-encoding = "2.3.0"
 serde = "1.0.188"
+serde_json = "1.0.107"
 thiserror = "1.0.48"
 
 [dependencies.gloo-net]

ofdb-frontend-api/src/lib.rs

@@ -25,13 +25,25 @@ impl From<gloo_net::Error> for Error {
     }
 }
 
+impl From<serde_json::Error> for Error {
+    fn from(err: serde_json::Error) -> Self {
+        Self::Fetch(format!("{err}"))
+    }
+}
+
 pub async fn into_json<T>(response: Response) -> Result<T>
 where
     T: DeserializeOwned,
 {
     // ensure we've got 2xx status
     if response.ok() {
-        Ok(response.json().await?)
+        let data = if response.status() == 204 {
+            // No content
+            serde_json::from_value(serde_json::Value::Null)?
+        } else {
+            response.json().await?
+        };
+        Ok(data)
     } else {
         Err(response.json::<ofdb_boundary::Error>().await?.into())
     }

ofdb-frontend-api/src/public.rs

@@ -1,8 +1,9 @@
 use gloo_net::http::Request;
-use ofdb_boundary::*;
 use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
 use web_sys::RequestCredentials;
 
+use ofdb_boundary::*;
+
 use crate::{into_json, Result, UserApi};
 
 /// Public OpenFairDB API
@@ -11,15 +12,52 @@ pub struct PublicApi {
     url: &'static str,
 }
 
+#[derive(Debug, Clone, Default)]
+pub struct EventQuery {
+    pub bbox: Option<MapBbox>,
+    pub limit: Option<u64>,
+    pub tags: Vec<String>,
+    pub start_min: Option<i64>,
+    pub start_max: Option<i64>,
+    pub end_min: Option<i64>,
+    pub end_max: Option<i64>,
+    pub text: Option<String>,
+    pub created_by: Option<String>,
+}
+
+impl EventQuery {
+    pub fn is_empty(&self) -> bool {
+        let Self {
+            bbox,
+            limit,
+            tags,
+            start_min,
+            start_max,
+            end_min,
+            end_max,
+            text,
+            created_by,
+        } = self;
+        bbox.is_none()
+            && limit.is_none()
+            && tags.is_empty()
+            && start_min.is_none()
+            && start_max.is_none()
+            && end_min.is_none()
+            && end_max.is_none()
+            && text.is_none()
+            && created_by.is_none()
+    }
+}
+
 impl PublicApi {
     pub const fn new(url: &'static str) -> Self {
         Self { url }
     }
     pub async fn search(&self, text: &str, bbox: &MapBbox) -> Result<SearchResponse> {
         let encoded_txt = utf8_percent_encode(text, NON_ALPHANUMERIC);
-        let MapBbox { sw, ne } = bbox;
-        let bbox_str = format!("{},{},{},{}", sw.lat, sw.lng, ne.lat, ne.lng);
-        let url = format!("{}/search?text={encoded_txt}&bbox={bbox_str}", self.url);
+        let bbox_string = bbox_string(bbox);
+        let url = format!("{}/search?text={encoded_txt}&bbox={bbox_string}", self.url);
         let response = Request::get(&url).send().await?;
         into_json(response).await
     }
@@ -51,6 +89,68 @@ impl PublicApi {
         let response = Request::get(&url).send().await?;
         into_json(response).await
     }
+    pub async fn events(&self, query: &EventQuery) -> Result<Vec<Event>> {
+        let mut url = format!("{}/events", self.url);
+        if !query.is_empty() {
+            let EventQuery {
+                bbox,
+                limit,
+                tags,
+                start_min,
+                start_max,
+                end_min,
+                end_max,
+                text,
+                created_by,
+            } = query;
+            let mut params = vec![];
+
+            if let Some(bbox) = bbox {
+                let bbox_string = bbox_string(bbox);
+                params.push(("bbox", bbox_string));
+            }
+            if let Some(limit) = limit {
+                params.push(("limit", limit.to_string()));
+            }
+            if !tags.is_empty() {
+                params.push(("tag", tags.join(",")));
+            }
+            if let Some(start_min) = start_min {
+                params.push(("start_min", start_min.to_string()));
+            }
+            if let Some(start_max) = start_max {
+                params.push(("start_max", start_max.to_string()));
+            }
+            if let Some(end_min) = end_min {
+                params.push(("end_min", end_min.to_string()));
+            }
+            if let Some(end_max) = end_max {
+                params.push(("end_max", end_max.to_string()));
+            }
+            if let Some(text) = text {
+                let encoded_text = utf8_percent_encode(text, NON_ALPHANUMERIC);
+                params.push(("text", encoded_text.to_string()));
+            }
+            if let Some(email) = created_by {
+                let encoded_email = utf8_percent_encode(email.as_str(), NON_ALPHANUMERIC);
+                params.push(("created_by", encoded_email.to_string()));
+            }
+            let params = params
+                .into_iter()
+                .map(|(key, value)| [key, &value].join("="))
+                .collect::<Vec<_>>()
+                .join("&");
+            url = format!("{url}?{params}");
+        }
+        let response = Request::get(&url).send().await?;
+        into_json(response).await
+    }
+    pub async fn event(&self, id: &str) -> Result<Event> {
+        let url = format!("{}/events/{id}", self.url);
+        let request = Request::get(&url);
+        let response = request.send().await?;
+        into_json(response).await
+    }
     pub async fn create_place(&self, place: &NewPlace) -> Result<()> {
         let url = format!("{}/entries", self.url);
         let request = Request::post(&url).json(place)?;
@@ -107,3 +207,8 @@ impl PublicApi {
         into_json(response).await
     }
 }
+
+fn bbox_string(bbox: &MapBbox) -> String {
+    let MapBbox { sw, ne } = bbox;
+    format!("{},{},{},{}", sw.lat, sw.lng, ne.lat, ne.lng)
+}

ofdb-frontend-api/src/user.rs

@@ -1,8 +1,9 @@
 use gloo_net::http::{Request, RequestBuilder};
-use ofdb_boundary::*;
 use serde::de::DeserializeOwned;
 use web_sys::RequestCredentials;
 
+use ofdb_boundary::*;
+
 use crate::{into_json, Result};
 
 /// Authorized OpenFairDB API
@@ -32,8 +33,8 @@ impl UserApi {
     }
     pub async fn user_info(&self) -> Result<User> {
         let url = format!("{}/users/current", self.url);
-        self.send(Request::get(&url).credentials(RequestCredentials::Include))
-            .await
+        let request = Request::get(&url).credentials(RequestCredentials::Include);
+        self.send(request).await
     }
     pub async fn bbox_subscriptions(&self) -> Result<Vec<BboxSubscription>> {
         let url = format!("{}/bbox-subscriptions", self.url);
@@ -45,10 +46,15 @@ impl UserApi {
     }
     pub async fn logout(&self) -> Result<()> {
         let url = format!("{}/logout", self.url);
-        self.send(Request::post(&url).credentials(RequestCredentials::Include))
-            .await
+        let request = Request::post(&url).credentials(RequestCredentials::Include);
+        self.send(request).await
     }
     pub fn token(&self) -> &JwtToken {
         &self.token
     }
+    pub async fn archive_events(&self, ids: &[&str]) -> Result<()> {
+        let url = format!("{}/events/{}/archive", self.url, ids.join(","));
+        let request = Request::post(&url).credentials(RequestCredentials::Include);
+        self.send(request).await
+    }
 }