Implement v3 areas endpoints

Author: bubelov

src/area/mod.rs

@@ -3,3 +3,4 @@ pub use model::Area;
 pub use model::AreaRepo;
 pub mod admin;
 pub mod v2;
+pub mod v3;

src/area/v3.rs

@@ -0,0 +1,195 @@
+use crate::area::Area;
+use crate::area::AreaRepo;
+use crate::Error;
+use actix_web::get;
+use actix_web::web::Data;
+use actix_web::web::Json;
+use actix_web::web::Query;
+use serde::Deserialize;
+use serde::Serialize;
+use serde_json::Map;
+use serde_json::Value;
+use time::OffsetDateTime;
+
+#[derive(Deserialize)]
+pub struct GetArgs {
+    #[serde(with = "time::serde::rfc3339")]
+    updated_since: OffsetDateTime,
+    limit: i64,
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+pub struct GetItem {
+    pub id: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tags: Option<Map<String, Value>>,
+    #[serde(with = "time::serde::rfc3339")]
+    pub updated_at: OffsetDateTime,
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(with = "time::serde::rfc3339::option")]
+    pub deleted_at: Option<OffsetDateTime>,
+}
+
+impl Into<GetItem> for Area {
+    fn into(self) -> GetItem {
+        let tags = if self.deleted_at.is_none() && !self.tags.is_empty() {
+            Some(self.tags)
+        } else {
+            None
+        };
+        GetItem {
+            id: self.id,
+            tags,
+            updated_at: self.updated_at,
+            deleted_at: self.deleted_at,
+        }
+    }
+}
+
+impl Into<Json<GetItem>> for Area {
+    fn into(self) -> Json<GetItem> {
+        Json(self.into())
+    }
+}
+
+#[get("")]
+async fn get(args: Query<GetArgs>, repo: Data<AreaRepo>) -> Result<Json<Vec<GetItem>>, Error> {
+    Ok(Json(
+        repo.select_updated_since(&args.updated_since, Some(args.limit))
+            .await?
+            .into_iter()
+            .map(|it| it.into())
+            .collect(),
+    ))
+}
+
+#[cfg(test)]
+mod test {
+    use crate::element::ElementRepo;
+    use crate::error::{self, ApiError};
+    use crate::test::mock_state;
+    use crate::Result;
+    use actix_web::test::TestRequest;
+    use actix_web::web::{scope, Data, QueryConfig};
+    use actix_web::{test, App};
+    use http::StatusCode;
+    use serde_json::Map;
+    use time::macros::datetime;
+
+    #[test]
+    async fn get_no_updated_since() -> Result<()> {
+        let app = test::init_service(
+            App::new()
+                .app_data(QueryConfig::default().error_handler(error::query_error_handler))
+                .app_data(Data::new(ElementRepo::mock()))
+                .service(scope("/").service(super::get)),
+        )
+        .await;
+        let req = TestRequest::get().uri("/?limit=1").to_request();
+        let res: ApiError = test::try_call_and_read_body_json(&app, req).await.unwrap();
+        assert_eq!(StatusCode::BAD_REQUEST.as_u16(), res.http_code);
+        assert!(res.message.contains("missing field `updated_since`"));
+        Ok(())
+    }
+
+    #[test]
+    async fn get_no_limit() -> Result<()> {
+        let app = test::init_service(
+            App::new()
+                .app_data(QueryConfig::default().error_handler(error::query_error_handler))
+                .app_data(Data::new(ElementRepo::mock()))
+                .service(scope("/").service(super::get)),
+        )
+        .await;
+        let req = TestRequest::get()
+            .uri("/?updated_since=2020-01-01T00:00:00Z")
+            .to_request();
+        let res: ApiError = test::try_call_and_read_body_json(&app, req).await.unwrap();
+        assert_eq!(StatusCode::BAD_REQUEST.as_u16(), res.http_code);
+        assert!(res.message.contains("missing field `limit`"));
+        Ok(())
+    }
+
+    #[test]
+    async fn get_empty_array() -> Result<()> {
+        let state = mock_state().await;
+        let app = test::init_service(
+            App::new()
+                .app_data(Data::new(state.area_repo))
+                .service(scope("/").service(super::get)),
+        )
+        .await;
+        let req = TestRequest::get()
+            .uri("/?updated_since=2020-01-01T00:00:00Z&limit=1")
+            .to_request();
+        let res: Vec<super::GetItem> = test::call_and_read_body_json(&app, req).await;
+        assert_eq!(res.len(), 0);
+        Ok(())
+    }
+
+    #[test]
+    async fn get_not_empty_array() -> Result<()> {
+        let state = mock_state().await;
+        let area = state.area_repo.insert(&Map::new()).await?;
+        let app = test::init_service(
+            App::new()
+                .app_data(Data::new(state.area_repo))
+                .service(scope("/").service(super::get)),
+        )
+        .await;
+        let req = TestRequest::get()
+            .uri("/?updated_since=2020-01-01T00:00:00Z&limit=1")
+            .to_request();
+        let res: Vec<super::GetItem> = test::call_and_read_body_json(&app, req).await;
+        assert_eq!(res, vec![area.into()]);
+        Ok(())
+    }
+
+    #[test]
+    async fn get_with_limit() -> Result<()> {
+        let state = mock_state().await;
+        let area_1 = state.area_repo.insert(&Map::new()).await?;
+        let area_2 = state.area_repo.insert(&Map::new()).await?;
+        let _area_3 = state.area_repo.insert(&Map::new()).await?;
+        let app = test::init_service(
+            App::new()
+                .app_data(Data::new(state.area_repo))
+                .service(scope("/").service(super::get)),
+        )
+        .await;
+        let req = TestRequest::get()
+            .uri("/?updated_since=2020-01-01T00:00:00Z&limit=2")
+            .to_request();
+        let res: Vec<super::GetItem> = test::call_and_read_body_json(&app, req).await;
+        assert_eq!(res, vec![area_1.into(), area_2.into()]);
+        Ok(())
+    }
+
+    #[test]
+    async fn get_updated_since() -> Result<()> {
+        let state = mock_state().await;
+        let area_1 = state.area_repo.insert(&Map::new()).await?;
+        state
+            .area_repo
+            .set_updated_at(area_1.id, &datetime!(2022-01-05 00:00 UTC))
+            .await?;
+        let area_2 = state.area_repo.insert(&Map::new()).await?;
+        let area_2 = state
+            .area_repo
+            .set_updated_at(area_2.id, &datetime!(2022-02-05 00:00 UTC))
+            .await?;
+        let app = test::init_service(
+            App::new()
+                .app_data(Data::new(state.area_repo))
+                .service(scope("/").service(super::get)),
+        )
+        .await;
+        let req = TestRequest::get()
+            .uri("/?updated_since=2022-01-10T00:00:00Z&limit=100")
+            .to_request();
+        let res: Vec<super::GetItem> = test::call_and_read_body_json(&app, req).await;
+        assert_eq!(res, vec![area_2.into()]);
+        Ok(())
+    }
+}

src/server/mod.rs

@@ -143,6 +143,13 @@ pub async fn run() -> Result<()> {
                         scope("events")
                             .service(event::v3::get)
                             .service(event::v3::get_by_id),
+                    )
+                    .service(
+                        scope("areas")
+                            .service(area::admin::post)
+                            .service(area::admin::patch)
+                            .service(area::admin::delete)
+                            .service(area::v3::get),
                     ),
             )
             .service(