diff --git a/.gitignore b/.gitignore
index 53eaa21..cd0db6b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,4 @@
+.*
+!.gitignore
/target
**/*.rs.bk
diff --git a/.idea/ServiceTest.iml b/.idea/ServiceTest.iml
deleted file mode 100644
index 40b1bef..0000000
--- a/.idea/ServiceTest.iml
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/.idea/encodings.xml b/.idea/encodings.xml
deleted file mode 100644
index 15a15b2..0000000
--- a/.idea/encodings.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-
-
-
-
\ No newline at end of file
diff --git a/.idea/mercator_service.iml b/.idea/mercator_service.iml
new file mode 100644
index 0000000..b7b4242
--- /dev/null
+++ b/.idea/mercator_service.iml
@@ -0,0 +1,14 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
index a62b77a..e3ae8eb 100644
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@@ -2,7 +2,7 @@
-
+
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 332317b..c29bf28 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -12,11 +12,7 @@
-
-
-
-
-
+
@@ -28,163 +24,45 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-
-
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- CoresAnswer
- cores::
- ResponseHeader
- Requ
- params
- type
- generate_context
- builtin
- BasicContext
- set_
- set_params
- generate_context|generate_context|generate_context|generate_context|generate_context|generate_context|generate_context|generate_context|generate_context|generate_context|generate_context|generate_context
- resolve
- context
- MultiValued
- get<
- cookie
- K: Hash
- HasQueryParams
- lock
- i32
-
-
- cores::Response
- HeaderResponse
- MultiValuedRequestsContext
- Ctx
- K: Hash + Eq
- HasQueryParams<K, V>
- SharedState
-
-
-
+
+
+
+
-
-
+
+
-
@@ -194,19 +72,26 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-
-
-
+
+
+
+
+
+
+
+
-
-
+
+
-
-
-
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
diff --git a/src/main.rs b/src/main.rs
index 1261366..d369bd3 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -11,7 +11,7 @@ extern crate pretty_env_logger;
use std::sync::Arc;
use std::sync::RwLock;
-mod solr_api;
+mod rest_api;
/*
fn into_bool(string: &str) -> bool {
@@ -20,7 +20,7 @@ fn into_bool(string: &str) -> bool {
*/
fn main() {
- std::env::set_var("RUST_LOG", "info");
+// std::env::set_var("RUST_LOG", "info");
pretty_env_logger::init();
//TODO Retrieve from environment values, with fall back to defaults if unset.
@@ -28,5 +28,5 @@ fn main() {
let base = "/spatial-search";
let port = 8888;
- solr_api::run(hostname, port, base, Arc::new(RwLock::new(0)));
+ rest_api::run(hostname, port, base, Arc::new(RwLock::new(0)));
}
diff --git a/src/rest_api/actions.rs b/src/rest_api/actions.rs
new file mode 100644
index 0000000..4515c34
--- /dev/null
+++ b/src/rest_api/actions.rs
@@ -0,0 +1,41 @@
+use super::AppState;
+
+use actix_web::http::StatusCode;
+use actix_web::{fs, HttpRequest, HttpResponse, Path, Result};
+
+pub fn health(_req: &HttpRequest) -> HttpResponse {
+ HttpResponse::Ok().finish()
+}
+
+pub fn query(_req: &HttpRequest) -> Result {
+ info!("query Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::super::tests::*;
+
+ #[test]
+ fn health() {
+ let ep = get_path("/health".into());
+ expect_200(http::Method::GET, ep.clone());
+
+ expect_400(http::Method::POST, ep.clone());
+ expect_400(http::Method::PUT, ep.clone());
+ expect_400(http::Method::PATCH, ep.clone());
+ expect_400(http::Method::DELETE, ep.clone());
+ }
+
+ #[test]
+ fn query() {
+ let ep = get_path("/query".into());
+ expect_200(http::Method::POST, ep.clone());
+ expect_422(http::Method::POST, ep.clone());
+
+ expect_400(http::Method::GET, ep.clone());
+ expect_400(http::Method::PUT, ep.clone());
+ expect_400(http::Method::PATCH, ep.clone());
+ expect_400(http::Method::DELETE, ep.clone());
+ }
+}
diff --git a/src/rest_api/dataset.rs b/src/rest_api/dataset.rs
new file mode 100644
index 0000000..e06d8ee
--- /dev/null
+++ b/src/rest_api/dataset.rs
@@ -0,0 +1,85 @@
+use super::AppState;
+
+use actix_web::http::StatusCode;
+use actix_web::{fs, HttpRequest, Path, Result};
+
+/*
+pub fn post(_req: &HttpRequest) -> Result {
+ info!("POST Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+*/
+
+pub fn put((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("PUT Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn get((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("GET Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn patch((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("PATCH Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn delete((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("DELETE Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::super::tests::*;
+
+ const INSTANCE_EXISTS: &str = "/datasets/42";
+ const INSTANCE_INVALID: &str = "/datasets/21";
+
+ // FIXME: Add Body to request to see difference between (in)valid bodied requests
+
+ #[test]
+ fn put() {
+ json::expect_200(http::Method::PUT, get_path(INSTANCE_EXISTS), "".to_string());
+ json::expect_422(http::Method::PUT, get_path(INSTANCE_EXISTS), "".to_string());
+ json::expect_200(
+ http::Method::PUT,
+ get_path(INSTANCE_INVALID),
+ "".to_string(),
+ );
+ }
+
+ #[test]
+ fn patch() {
+ json::expect_200(
+ http::Method::PATCH,
+ get_path(INSTANCE_EXISTS),
+ "".to_string(),
+ );
+ json::expect_422(
+ http::Method::PATCH,
+ get_path(INSTANCE_EXISTS),
+ "".to_string(),
+ );
+ expect_400(http::Method::PATCH, get_path(INSTANCE_INVALID));
+ }
+
+ #[test]
+ fn get() {
+ expect_200(http::Method::GET, get_path(INSTANCE_EXISTS));
+ expect_404(http::Method::GET, get_path(INSTANCE_INVALID));
+ }
+
+ #[test]
+ fn delete() {
+ expect_200(http::Method::DELETE, get_path(INSTANCE_EXISTS));
+ expect_404(http::Method::DELETE, get_path(INSTANCE_INVALID));
+ }
+
+ #[test]
+ fn post() {
+ expect_400(http::Method::POST, get_path(INSTANCE_EXISTS));
+ expect_400(http::Method::POST, get_path(INSTANCE_INVALID));
+ }
+}
diff --git a/src/rest_api/datasets.rs b/src/rest_api/datasets.rs
new file mode 100644
index 0000000..940ce41
--- /dev/null
+++ b/src/rest_api/datasets.rs
@@ -0,0 +1,81 @@
+use super::AppState;
+
+use actix_web::http::StatusCode;
+use actix_web::{fs, HttpRequest, Path, Result};
+
+pub fn post(_req: &HttpRequest) -> Result {
+ info!("POST Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn put(_state: &HttpRequest) -> Result {
+ info!("PUT Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+/*
+pub fn get(_state: &HttpRequest) -> Result {
+ info!("GET Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}*/
+
+pub fn patch(_state: &HttpRequest) -> Result {
+ info!("PATCH Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn delete(_state: &HttpRequest) -> Result {
+ info!("DELETE Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::super::tests::*;
+
+ const COLLECTION: &str = "/datasets";
+
+ // FIXME: Add Body to request to see difference between (in)valid bodied requests
+
+ #[test]
+ fn post() {
+ expect_200(http::Method::POST, get_path(COLLECTION));
+ json::expect_200(http::Method::POST, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::POST, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::POST, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn put() {
+ json::expect_200(http::Method::PUT, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::PUT, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::PUT, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn patch() {
+ json::expect_200(http::Method::PATCH, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::PATCH, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::PATCH, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn delete() {
+ json::expect_200(http::Method::DELETE, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::DELETE, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::DELETE, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn get() {
+ expect_400(http::Method::GET, get_path(COLLECTION));
+ }
+}
diff --git a/src/rest_api/default.rs b/src/rest_api/default.rs
new file mode 100644
index 0000000..4b8edcd
--- /dev/null
+++ b/src/rest_api/default.rs
@@ -0,0 +1,87 @@
+use super::AppState;
+
+use actix_web::http::StatusCode;
+use actix_web::{fs, HttpRequest, Result};
+
+pub fn page_400(_req: &HttpRequest) -> Result {
+ info!("Default 400 Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn page_400_no_state(_req: &HttpRequest) -> Result {
+ info!("Default 400 Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+pub fn page_404(_req: &HttpRequest) -> Result {
+ info!("Default 404 (no state) Triggered!");
+ Ok(fs::NamedFile::open("static/404.html")?.set_status_code(StatusCode::NOT_FOUND))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ use std::sync::Arc;
+ use std::sync::RwLock;
+
+ use actix_web::http;
+ use actix_web::test::TestRequest;
+
+ #[test]
+ fn page_400() {
+ let response = TestRequest::with_state(AppState {
+ shared: Arc::new(RwLock::new(0)),
+ })
+ .run(&super::page_400)
+ .unwrap();
+ assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
+ }
+
+ #[test]
+ fn page_400_no_state() {
+ let response = TestRequest::default()
+ .run(&super::page_400_no_state)
+ .unwrap();
+ assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
+ }
+ #[test]
+ fn page_404() {
+ let response = TestRequest::default().run(&super::page_404).unwrap();
+ assert_eq!(response.status(), http::StatusCode::NOT_FOUND);
+ }
+}
+
+#[cfg(test)]
+mod routing {
+ use super::super::tests::*;
+
+ #[test]
+ fn default_no_path() {
+ expect_404(http::Method::GET, "".into());
+ }
+
+ #[test]
+ fn default_slash() {
+ expect_404(http::Method::GET, "/".into());
+ expect_404(http::Method::GET, "//".into());
+ expect_404(http::Method::GET, "/ /".into());
+ expect_404(http::Method::GET, "/ //".into());
+ expect_404(http::Method::GET, "// ".into());
+ }
+
+ #[test]
+ fn default_invalid_prefix() {
+ expect_404(http::Method::GET, "/test".into());
+ expect_404(http::Method::GET, format!("{}test", PREFIX));
+ }
+
+ #[test]
+ fn default_prefix_no_slash() {
+ expect_400(http::Method::GET, PREFIX.into());
+ }
+
+ #[test]
+ fn default_prefix_final_slash() {
+ expect_400(http::Method::GET, format!("{}/", PREFIX));
+ }
+}
diff --git a/src/rest_api/generated/models.rs b/src/rest_api/generated/models.rs
new file mode 100755
index 0000000..ccf1ee0
--- /dev/null
+++ b/src/rest_api/generated/models.rs
@@ -0,0 +1,540 @@
+#![allow(unused_imports, unused_qualifications, unused_extern_crates)]
+extern crate chrono;
+extern crate uuid;
+
+
+use serde::ser::Serializer;
+
+use std::collections::HashMap;
+use models;
+use swagger;
+
+
+/// Defines the properties of an axis. The origin and unit vectors or defined within the universe space, but this does NOT imply a linear conversion is possible, this only provide anchoring of the axis as well as its absolute direction.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Axis {
+ /// Unit of the values, on this axis, for example [mm], [s], [um].
+ #[serde(rename = "measurement_unit")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub measurement_unit: Option,
+
+ #[serde(rename = "coordinates")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub coordinates: Option,
+
+ #[serde(rename = "origin")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub origin: Option>,
+
+ #[serde(rename = "unit_vector")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub unit_vector: Option>,
+
+}
+
+impl Axis {
+ pub fn new() -> Axis {
+ Axis {
+ measurement_unit: None,
+ coordinates: None,
+ origin: None,
+ unit_vector: None,
+ }
+ }
+}
+
+/// Collection of Spatial Objects, stored in one or more Reference Spaces.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct DataSet {
+ #[serde(rename = "name")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub name: Option,
+
+ #[serde(rename = "version")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub version: Option,
+
+ /// Scale factors used to generate less precise, coarser indexes in order to speed up queries over large volumes of the space. Values are expressed as powers of two, in the range [0;n]. For each scale, a whole vector providing values for each axis MUST be provided. Values, which are equal, and whose coordinates gets merged are merged as well, to reduce the number of results. Distinct values whose coordinates are merged are recorded, thus allowing the user to move from one scale factor to another, with a finer resolution smoothly.
+ #[serde(rename = "scales")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub scales: Option>>,
+
+}
+
+impl DataSet {
+ pub fn new() -> DataSet {
+ DataSet {
+ name: None,
+ version: None,
+ scales: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Datasets {
+ #[serde(rename = "list")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub list: Option>,
+
+}
+
+impl Datasets {
+ pub fn new() -> Datasets {
+ Datasets {
+ list: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Datasets1 {
+ #[serde(rename = "list")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub list: Option>,
+
+}
+
+impl Datasets1 {
+ pub fn new() -> Datasets1 {
+ Datasets1 {
+ list: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Filters {
+ #[serde(rename = "filter")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub filter: Option,
+
+ #[serde(rename = "ids_only")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub ids_only: Option,
+
+}
+
+impl Filters {
+ pub fn new() -> Filters {
+ Filters {
+ filter: None,
+ ids_only: Some(false),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct InlineResponse200 {
+ #[serde(rename = "previous")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub previous: Option,
+
+ #[serde(rename = "current")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub current: Option,
+
+}
+
+impl InlineResponse200 {
+ pub fn new() -> InlineResponse200 {
+ InlineResponse200 {
+ previous: None,
+ current: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct InlineResponse2001 {
+ #[serde(rename = "previous")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub previous: Option,
+
+ #[serde(rename = "current")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub current: Option,
+
+}
+
+impl InlineResponse2001 {
+ pub fn new() -> InlineResponse2001 {
+ InlineResponse2001 {
+ previous: None,
+ current: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct InlineResponse2002 {
+ #[serde(rename = "previous")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub previous: Option,
+
+ #[serde(rename = "current")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub current: Option,
+
+}
+
+impl InlineResponse2002 {
+ pub fn new() -> InlineResponse2002 {
+ InlineResponse2002 {
+ previous: None,
+ current: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct PartialUpdate {
+ /// Identifier or name of the instance to update.
+ #[serde(rename = "name")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub name: Option,
+
+ /// Valid selector / attribute name of the instance.
+ // Note: inline enums are not fully supported by swagger-codegen
+ #[serde(rename = "attribute")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub attribute: Option,
+
+ /// JSON-serialized value to use to replace the value of the selected attribute.
+ #[serde(rename = "value")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub value: Option,
+
+}
+
+impl PartialUpdate {
+ pub fn new() -> PartialUpdate {
+ PartialUpdate {
+ name: None,
+ attribute: None,
+ value: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct PartialUpdate1 {
+ /// Identifier or name of the instance to update.
+ #[serde(rename = "name")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub name: Option,
+
+ /// Valid selector / attribute name of the instance.
+ // Note: inline enums are not fully supported by swagger-codegen
+ #[serde(rename = "attribute")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub attribute: Option,
+
+ /// JSON-serialized value to use to replace the value of the selected attribute.
+ #[serde(rename = "value")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub value: Option,
+
+}
+
+impl PartialUpdate1 {
+ pub fn new() -> PartialUpdate1 {
+ PartialUpdate1 {
+ name: None,
+ attribute: None,
+ value: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct PartialUpdate2 {
+ /// Identifier or name of the instance to update.
+ #[serde(rename = "id")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub id: Option,
+
+ /// Valid selector / attribute name of the instance.
+ // Note: inline enums are not fully supported by swagger-codegen
+ #[serde(rename = "attribute")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub attribute: Option,
+
+ /// JSON-serialized value to use to replace the value of the selected attribute.
+ #[serde(rename = "value")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub value: Option,
+
+}
+
+impl PartialUpdate2 {
+ pub fn new() -> PartialUpdate2 {
+ PartialUpdate2 {
+ id: None,
+ attribute: None,
+ value: None,
+ }
+ }
+}
+
+/// One valid value for each axes of the reference space this point is used in.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Point(Vec);
+
+impl ::std::convert::From> for Point {
+ fn from(x: Vec) -> Self {
+ Point(x)
+ }
+}
+
+impl ::std::convert::From for Vec {
+ fn from(x: Point) -> Self {
+ x.0
+ }
+}
+
+impl ::std::iter::FromIterator for Point {
+ fn from_iter>(u: U) -> Self {
+ Point(Vec::::from_iter(u))
+ }
+}
+
+impl ::std::iter::IntoIterator for Point {
+ type Item = Number;
+ type IntoIter = ::std::vec::IntoIter;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.0.into_iter()
+ }
+}
+
+impl<'a> ::std::iter::IntoIterator for &'a Point {
+ type Item = &'a Number;
+ type IntoIter = ::std::slice::Iter<'a, Number>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ (&self.0).into_iter()
+ }
+}
+
+impl<'a> ::std::iter::IntoIterator for &'a mut Point {
+ type Item = &'a mut Number;
+ type IntoIter = ::std::slice::IterMut<'a, Number>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ (&mut self.0).into_iter()
+ }
+}
+
+impl ::std::ops::Deref for Point {
+ type Target = Vec;
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl ::std::ops::DerefMut for Point {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+
+/// Properties tied to a shape, in other words properties valid for the whole content of the shape.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Properties {
+ #[serde(rename = "id")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub id: Option,
+
+ /// Label defining the kind of the spatial object.
+ #[serde(rename = "type")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub _type: Option,
+
+}
+
+impl Properties {
+ pub fn new() -> Properties {
+ Properties {
+ id: None,
+ _type: None,
+ }
+ }
+}
+
+/// Geometric shape defined in a reference space.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Shape {
+ /// Name of the shape class described by the vertices, this can be used for specific types to reduce the number of vertices required to define the shape.
+ // Note: inline enums are not fully supported by swagger-codegen
+ #[serde(rename = "type")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub _type: Option,
+
+ /// List of vertices composing the contour of the shape.
+ #[serde(rename = "vertices")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub vertices: Option>,
+
+ /// Name of a valid reference space. This is the space in which the vertices are defined
+ #[serde(rename = "space")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub space: Option,
+
+}
+
+impl Shape {
+ pub fn new() -> Shape {
+ Shape {
+ _type: None,
+ vertices: None,
+ space: None,
+ }
+ }
+}
+
+/// Definition of a space, in which objects are described.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Space {
+ /// Unique Id for the space, which can also be used to generate a link to the user documentation describing the space, explaining the semantic meaning of the values stored, as well as the definitions of the axes.
+ #[serde(rename = "name")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub name: Option,
+
+ /// The order of the axes matter and MUST be kept, as this is also linked to the definition found in the documentation. Coordinate of a point MUST always be expressed using the same order as defined here.
+ #[serde(rename = "axes")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub axes: Option>,
+
+}
+
+impl Space {
+ pub fn new() -> Space {
+ Space {
+ name: None,
+ axes: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Spaces {
+ #[serde(rename = "list")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub list: Option>,
+
+}
+
+impl Spaces {
+ pub fn new() -> Spaces {
+ Spaces {
+ list: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Spaces1 {
+ #[serde(rename = "list")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub list: Option>,
+
+}
+
+impl Spaces1 {
+ pub fn new() -> Spaces1 {
+ Spaces1 {
+ list: None,
+ }
+ }
+}
+
+/// Collection of positions in a space, which share a common set of properties.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct SpatialObject {
+ /// List of shapes, overlapping or not, which define the whole space covered by this spatial object.
+ #[serde(rename = "shape")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub shape: Option>,
+
+ #[serde(rename = "properties")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub properties: Option,
+
+}
+
+impl SpatialObject {
+ pub fn new() -> SpatialObject {
+ SpatialObject {
+ shape: None,
+ properties: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct SpatialObjects {
+ #[serde(rename = "list")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub list: Option>,
+
+}
+
+impl SpatialObjects {
+ pub fn new() -> SpatialObjects {
+ SpatialObjects {
+ list: None,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct SpatialObjects1 {
+ #[serde(rename = "list")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub list: Option>,
+
+}
+
+impl SpatialObjects1 {
+ pub fn new() -> SpatialObjects1 {
+ SpatialObjects1 {
+ list: None,
+ }
+ }
+}
+
+/// Definition of the valid coordinate values which can be used on this axis.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ValidNumbersOnThisAxis {
+ /// Valid numbers as defined by the usual mathematical sets, for example N=Natural, Z=Integers, Q=Rational, R=Real.
+ // Note: inline enums are not fully supported by swagger-codegen
+ #[serde(rename = "set")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub set: Option,
+
+ #[serde(rename = "minimum")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub minimum: Option,
+
+ #[serde(rename = "maximum")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub maximum: Option,
+
+ #[serde(rename = "steps")]
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub steps: Option,
+
+}
+
+impl ValidNumbersOnThisAxis {
+ pub fn new() -> ValidNumbersOnThisAxis {
+ ValidNumbersOnThisAxis {
+ set: None,
+ minimum: None,
+ maximum: None,
+ steps: None,
+ }
+ }
+}
diff --git a/src/rest_api/mod.rs b/src/rest_api/mod.rs
new file mode 100644
index 0000000..5c8d73a
--- /dev/null
+++ b/src/rest_api/mod.rs
@@ -0,0 +1,227 @@
+use std::sync::Arc;
+use std::sync::RwLock;
+
+use actix_web::http::Method;
+use actix_web::server::{HttpHandler, HttpHandlerTask};
+use actix_web::{pred, server, App};
+
+pub type SharedState = i32;
+
+// Application shared state
+pub struct AppState {
+ shared: Arc>,
+}
+
+/* EXAMPLE FOR STATE USAGE
+// simple handle
+fn index(req: &HttpRequest) -> HttpResponse {
+ println!("{:?}", req);
+ {
+ // So that we release ASAP the exclusive lock.
+ *(req.state().shared.write().unwrap()) += 1;
+ }
+
+ HttpResponse::BadRequest().body(format!(
+ "Num of requests: {}",
+ req.state().shared.read().unwrap()
+ ))
+}
+*/
+
+mod actions;
+
+mod space;
+mod spaces;
+
+mod dataset;
+mod datasets;
+
+mod spatial_object;
+mod spatial_objects;
+
+mod default;
+
+fn get_app(
+ prefix: &'static str,
+ state: Arc>,
+) -> Vec>>> {
+ vec![
+ App::with_state(AppState { shared: state })
+ .prefix(format!("{}", prefix))
+ // ACTIONS -------------------------------------------------------------------
+ .resource("/health", |r| {
+ r.method(Method::GET).f(actions::health);
+ r.route()
+ .filter(pred::Not(pred::Get()))
+ .f(default::page_400);
+ })
+ .resource("/queries", |r| {
+ r.method(Method::POST).f(actions::query);
+ r.route()
+ .filter(pred::Not(pred::Post()))
+ .f(default::page_400);
+ })
+ // SPACES -------------------------------------------------------------------
+ .resource("/spaces", |r| {
+ r.method(Method::POST).f(spaces::post);
+ r.method(Method::PUT).f(spaces::put);
+ r.method(Method::PATCH).f(spaces::patch);
+ r.method(Method::DELETE).f(spaces::delete);
+ })
+ .resource("/spaces/{name}", |r| {
+ r.method(Method::PUT).with(space::put);
+ r.method(Method::PATCH).with(space::patch);
+ r.method(Method::GET).with(space::get);
+ r.method(Method::DELETE).with(space::delete);
+ })
+ // DATASETS -------------------------------------------------------------------
+ .resource("/datasets", |r| {
+ r.method(Method::POST).f(&datasets::post);
+ r.method(Method::PUT).f(&datasets::put);
+ r.method(Method::PATCH).f(&datasets::patch);
+ r.method(Method::DELETE).f(&datasets::delete);
+ })
+ .resource("/datasets/{name}", |r| {
+ r.method(Method::PUT).with(dataset::put);
+ r.method(Method::GET).with(dataset::get);
+ r.method(Method::PATCH).with(dataset::patch);
+ r.method(Method::DELETE).with(dataset::delete);
+ })
+ // SPATIAL OBJECTS -------------------------------------------------------------------
+ .resource("/dataset/{name}/spatial_objects", |r| {
+ r.method(Method::POST).with(spatial_objects::post);
+ r.method(Method::PUT).with(spatial_objects::put);
+ r.method(Method::PATCH).with(spatial_objects::patch);
+ r.method(Method::DELETE).with(spatial_objects::delete);
+ })
+ .resource("/dataset/{name}/spatial_objects/{id}", |r| {
+ r.method(Method::PUT).with(spatial_object::put);
+ r.method(Method::GET).with(spatial_object::get);
+ r.method(Method::PATCH).with(spatial_object::patch);
+ r.method(Method::DELETE).with(spatial_object::delete);
+ })
+ // DEFAULT -------------------------------------------------------------------
+ .default_resource(|r| {
+ r.f(default::page_400);
+ })
+ .boxed(),
+ App::new()
+ .default_resource(|r| {
+ // 404 for GET request
+ r.method(Method::GET).f(default::page_404);
+
+ // all requests that are not `GET`
+ r.route()
+ .filter(pred::Not(pred::Get()))
+ .f(default::page_400_no_state);
+ })
+ .boxed(),
+ ]
+}
+
+pub fn run(
+ host: &'static str,
+ port: u16,
+ prefix: &'static str,
+ state: Arc>,
+) -> () {
+ info!("Initializing server...");
+
+ let sys = actix::System::new("spatial-search");
+
+ server::new(move || get_app(prefix, state.clone()))
+ .bind(format!("{}:{}", host, port))
+ .unwrap()
+ .start();
+
+ info!("Started http server: {}:{}{}", host, port, prefix);
+
+ let _ = sys.run();
+}
+
+#[cfg(test)]
+mod tests {
+ use super::get_app;
+ use super::{Arc, RwLock, SharedState};
+
+ pub use actix_web::http;
+ pub use actix_web::http::Method;
+ pub use actix_web::test::TestServer;
+
+ pub const PREFIX: &str = "spatial-search";
+
+ fn get_start_state() -> Arc> {
+ Arc::new(RwLock::new(0))
+ }
+
+ pub fn get_test_server() -> TestServer {
+ TestServer::with_factory(move || get_app(PREFIX, get_start_state().clone()))
+ }
+
+ pub fn get_path(path: &str) -> String {
+ format!("{}{}", PREFIX, path)
+ }
+
+ pub fn expect_200(method: Method, path: String) -> () {
+ let mut srv = get_test_server();
+ let req = srv.client(method, path.as_str()).finish().unwrap();
+ let response = srv.execute(req.send()).unwrap();
+ assert_eq!(http::StatusCode::OK, response.status());
+ }
+
+ pub fn expect_400(method: Method, path: String) -> () {
+ let mut srv = get_test_server();
+ let req = srv.client(method, path.as_str()).finish().unwrap();
+ let response = srv.execute(req.send()).unwrap();
+ assert_eq!(http::StatusCode::BAD_REQUEST, response.status());
+ }
+
+ pub fn expect_404(method: Method, path: String) -> () {
+ let mut srv = get_test_server();
+ let req = srv.client(method, path.as_str()).finish().unwrap();
+ let response = srv.execute(req.send()).unwrap();
+ assert_eq!(http::StatusCode::NOT_FOUND, response.status());
+ }
+
+ pub fn expect_422(method: Method, path: String) -> () {
+ let mut srv = get_test_server();
+ let req = srv.client(method, path.as_str()).finish().unwrap();
+ let response = srv.execute(req.send()).unwrap();
+ assert_eq!(http::StatusCode::UNPROCESSABLE_ENTITY, response.status());
+ }
+
+ pub mod json {
+ use super::*;
+
+ pub fn expect_200(method: Method, path: String, json: String) -> () {
+ let mut srv = get_test_server();
+ let req = srv.client(method, path.as_str()).json(json).unwrap();
+ let response = srv.execute(req.send()).unwrap();
+ assert_eq!(http::StatusCode::OK, response.status());
+ }
+
+ /*
+ pub fn expect_400(method: Method, path: String, json: String) -> () {
+ let mut srv = get_test_server();
+ let req = srv.client(method, path.as_str()).json(json).unwrap();
+ let response = srv.execute(req.send()).unwrap();
+ assert_eq!(http::StatusCode::BAD_REQUEST, response.status());
+ }
+ */
+
+ pub fn expect_404(method: Method, path: String, json: String) -> () {
+ let mut srv = get_test_server();
+ let req = srv.client(method, path.as_str()).json(json).unwrap();
+ let response = srv.execute(req.send()).unwrap();
+ assert_eq!(http::StatusCode::NOT_FOUND, response.status());
+ }
+
+ pub fn expect_422(method: Method, path: String, json: String) -> () {
+ let mut srv = get_test_server();
+ let req = srv.client(method, path.as_str()).json(json).unwrap();
+ let response = srv.execute(req.send()).unwrap();
+ assert_eq!(http::StatusCode::UNPROCESSABLE_ENTITY, response.status());
+ }
+
+ }
+}
diff --git a/src/rest_api/space.rs b/src/rest_api/space.rs
new file mode 100644
index 0000000..b4c7dac
--- /dev/null
+++ b/src/rest_api/space.rs
@@ -0,0 +1,85 @@
+use super::AppState;
+
+use actix_web::http::StatusCode;
+use actix_web::{fs, HttpRequest, Path, Result};
+
+/*
+pub fn post(_req: &HttpRequest) -> Result {
+ info!("POST Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+*/
+
+pub fn put((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("PUT Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn get((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("GET Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn patch((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("PATCH Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn delete((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("DELETE Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::super::tests::*;
+
+ const INSTANCE_EXISTS: &str = "/spaces/42";
+ const INSTANCE_INVALID: &str = "/spaces/21";
+
+ // FIXME: Add Body to request to see difference between (in)valid bodied requests
+
+ #[test]
+ fn put() {
+ json::expect_200(http::Method::PUT, get_path(INSTANCE_EXISTS), "".to_string());
+ json::expect_422(http::Method::PUT, get_path(INSTANCE_EXISTS), "".to_string());
+ json::expect_200(
+ http::Method::PUT,
+ get_path(INSTANCE_INVALID),
+ "".to_string(),
+ );
+ }
+
+ #[test]
+ fn patch() {
+ json::expect_200(
+ http::Method::PATCH,
+ get_path(INSTANCE_EXISTS),
+ "".to_string(),
+ );
+ json::expect_422(
+ http::Method::PATCH,
+ get_path(INSTANCE_EXISTS),
+ "".to_string(),
+ );
+ expect_400(http::Method::PATCH, get_path(INSTANCE_INVALID));
+ }
+
+ #[test]
+ fn get() {
+ expect_200(http::Method::GET, get_path(INSTANCE_EXISTS));
+ expect_404(http::Method::GET, get_path(INSTANCE_INVALID));
+ }
+
+ #[test]
+ fn delete() {
+ expect_200(http::Method::DELETE, get_path(INSTANCE_EXISTS));
+ expect_404(http::Method::DELETE, get_path(INSTANCE_INVALID));
+ }
+
+ #[test]
+ fn post() {
+ expect_400(http::Method::POST, get_path(INSTANCE_EXISTS));
+ expect_400(http::Method::POST, get_path(INSTANCE_INVALID));
+ }
+}
diff --git a/src/rest_api/spaces.rs b/src/rest_api/spaces.rs
new file mode 100644
index 0000000..235a6bc
--- /dev/null
+++ b/src/rest_api/spaces.rs
@@ -0,0 +1,81 @@
+use super::AppState;
+
+use actix_web::http::StatusCode;
+use actix_web::{fs, HttpRequest, Path, Result};
+
+pub fn post(_req: &HttpRequest) -> Result {
+ info!("POST Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn put(_state: &HttpRequest) -> Result {
+ info!("PUT Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+/*
+pub fn get(_state: &HttpRequest) -> Result {
+ info!("GET Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}*/
+
+pub fn patch(_state: &HttpRequest) -> Result {
+ info!("PATCH Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn delete(_state: &HttpRequest) -> Result {
+ info!("DELETE Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::super::tests::*;
+
+ const COLLECTION: &str = "/spaces";
+
+ // FIXME: Add Body to request to see difference between (in)valid bodied requests
+
+ #[test]
+ fn post() {
+ expect_200(http::Method::POST, get_path(COLLECTION));
+ json::expect_200(http::Method::POST, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::POST, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::POST, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn put() {
+ json::expect_200(http::Method::PUT, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::PUT, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::PUT, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn patch() {
+ json::expect_200(http::Method::PATCH, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::PATCH, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::PATCH, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn delete() {
+ json::expect_200(http::Method::DELETE, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::DELETE, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::DELETE, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn get() {
+ expect_400(http::Method::GET, get_path(COLLECTION));
+ }
+}
diff --git a/src/rest_api/spatial_object.rs b/src/rest_api/spatial_object.rs
new file mode 100644
index 0000000..72f0de0
--- /dev/null
+++ b/src/rest_api/spatial_object.rs
@@ -0,0 +1,85 @@
+use super::AppState;
+
+use actix_web::http::StatusCode;
+use actix_web::{fs, HttpRequest, Path, Result};
+
+/*
+pub fn post((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("POST Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+*/
+
+pub fn put((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("PUT Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn get((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("GET Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn patch((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("PATCH Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn delete((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("DELETE Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::super::tests::*;
+
+ const INSTANCE_EXISTS: &str = "/datasets/42/spatial_objects/42";
+ const INSTANCE_INVALID: &str = "/datasets/42/spatial_objects/21";
+
+ // FIXME: Add Body to request to see difference between (in)valid bodied requests
+
+ #[test]
+ fn put() {
+ json::expect_200(http::Method::PUT, get_path(INSTANCE_EXISTS), "".to_string());
+ json::expect_422(http::Method::PUT, get_path(INSTANCE_EXISTS), "".to_string());
+ json::expect_200(
+ http::Method::PUT,
+ get_path(INSTANCE_INVALID),
+ "".to_string(),
+ );
+ }
+
+ #[test]
+ fn patch() {
+ json::expect_200(
+ http::Method::PATCH,
+ get_path(INSTANCE_EXISTS),
+ "".to_string(),
+ );
+ json::expect_422(
+ http::Method::PATCH,
+ get_path(INSTANCE_EXISTS),
+ "".to_string(),
+ );
+ expect_400(http::Method::PATCH, get_path(INSTANCE_INVALID));
+ }
+
+ #[test]
+ fn get() {
+ expect_200(http::Method::GET, get_path(INSTANCE_EXISTS));
+ expect_404(http::Method::GET, get_path(INSTANCE_INVALID));
+ }
+
+ #[test]
+ fn delete() {
+ expect_200(http::Method::DELETE, get_path(INSTANCE_EXISTS));
+ expect_404(http::Method::DELETE, get_path(INSTANCE_INVALID));
+ }
+
+ #[test]
+ fn post() {
+ expect_400(http::Method::POST, get_path(INSTANCE_EXISTS));
+ expect_400(http::Method::POST, get_path(INSTANCE_INVALID));
+ }
+}
diff --git a/src/rest_api/spatial_objects.rs b/src/rest_api/spatial_objects.rs
new file mode 100644
index 0000000..decb1ec
--- /dev/null
+++ b/src/rest_api/spatial_objects.rs
@@ -0,0 +1,82 @@
+use super::AppState;
+
+use actix_web::http::StatusCode;
+use actix_web::{fs, HttpRequest, Path, Result};
+
+pub fn post((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("POST Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn put((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("PUT Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+/*
+pub fn get((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("GET Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+*/
+
+pub fn patch((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("PATCH Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+pub fn delete((_path, _state): (Path, HttpRequest)) -> Result {
+ info!("DELETE Triggered!");
+ Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::super::tests::*;
+
+ const COLLECTION: &str = "/datasets/42/spatial_objects";
+
+ // FIXME: Add Body to request to see difference between (in)valid bodied requests
+
+ #[test]
+ fn post() {
+ expect_200(http::Method::POST, get_path(COLLECTION));
+ json::expect_200(http::Method::POST, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::POST, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::POST, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn put() {
+ json::expect_200(http::Method::PUT, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::PUT, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::PUT, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn patch() {
+ json::expect_200(http::Method::PATCH, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::PATCH, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::PATCH, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn delete() {
+ json::expect_200(http::Method::DELETE, get_path(COLLECTION), "".to_string());
+
+ json::expect_422(http::Method::DELETE, get_path(COLLECTION), "".to_string());
+
+ expect_400(http::Method::DELETE, get_path(COLLECTION));
+ }
+
+ #[test]
+ fn get() {
+ expect_400(http::Method::GET, get_path(COLLECTION));
+ }
+}
diff --git a/src/solr_api/mod.rs b/src/solr_api/mod.rs
deleted file mode 100644
index 2819f56..0000000
--- a/src/solr_api/mod.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-use std::sync::Arc;
-use std::sync::RwLock;
-
-use actix_web::http::{Method, StatusCode};
-use actix_web::server::{HttpHandler, HttpHandlerTask};
-use actix_web::{fs, pred, server, App, HttpRequest, HttpResponse, Result};
-
-pub type SharedState = i32;
-
-// Application shared state
-struct AppState {
- /*host: &'static str,
- port: u16,
- prefix: &'static str,*/
- shared: Arc>,
-}
-
-// simple handle
-fn index(req: &HttpRequest) -> HttpResponse {
- println!("{:?}", req);
- {
- // So that we release ASAP the exclusive lock.
- *(req.state().shared.write().unwrap()) += 1;
- }
-
- HttpResponse::BadRequest().body(format!(
- "Num of requests: {}",
- req.state().shared.read().unwrap()
- ))
-}
-
-/// 400 handler
-fn page_400(_req: &HttpRequest) -> Result {
- Ok(fs::NamedFile::open("static/400.html")?.set_status_code(StatusCode::BAD_REQUEST))
-}
-
-/// 404 handler
-fn page_404(_req: &HttpRequest) -> Result {
- Ok(fs::NamedFile::open("static/404.html")?.set_status_code(StatusCode::NOT_FOUND))
-}
-
-fn get_app(
- prefix: &'static str,
- state: Arc>,
-) -> Vec>>> {
- vec![
- App::with_state(AppState { shared: state })
- .prefix(format!("{}", prefix))
- // register simple handler, handle all methods
- .resource("/", |r| r.f(index))
- // default
- .default_resource(|r| {
- // 400 for GET request
- r.f(page_400);
- })
- .boxed(),
- App::new()
- .default_resource(|r| {
- // 404 for GET request
- r.method(Method::GET).f(page_404);
-
- // all requests that are not `GET`
- r.route()
- .filter(pred::Not(pred::Get()))
- .f(|_req| HttpResponse::MethodNotAllowed());
- })
- .boxed(),
- ]
-}
-
-pub fn run(
- host: &'static str,
- port: u16,
- prefix: &'static str,
- state: Arc>,
-) -> () {
- info!("Initializing server...");
-
- let sys = actix::System::new("spatial-search");
-
- server::new(move || get_app(prefix, state.clone()))
- .bind(format!("{}:{}", host, port))
- .unwrap()
- .start();
-
- info!("Started http server: {}:{}{}", host, port, prefix);
-
- let _ = sys.run();
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use actix_web::http;
- use actix_web::test::{TestRequest, TestServer};
-
- const PREFIX: &str = "spatial-search";
-
- fn get_test_server() -> TestServer {
- let state = Arc::new(RwLock::new(0));
- TestServer::with_factory(move || get_app(PREFIX, state.clone()))
- }
-
- fn expect_200(path: &str) -> () {
- let mut srv = get_test_server();
- let req = srv.client(http::Method::GET, path).finish().unwrap();
- let response = srv.execute(req.send()).unwrap();
- assert_eq!(http::StatusCode::OK, response.status());
- }
-
- fn expect_400(path: &str) -> () {
- let mut srv = get_test_server();
- let req = srv.client(http::Method::GET, path).finish().unwrap();
- let response = srv.execute(req.send()).unwrap();
- assert_eq!(http::StatusCode::BAD_REQUEST, response.status());
- }
-
- fn expect_404(path: &str) -> () {
- let mut srv = get_test_server();
- let req = srv.client(http::Method::GET, path).finish().unwrap();
- let response = srv.execute(req.send()).unwrap();
- assert_eq!(http::StatusCode::NOT_FOUND, response.status());
- }
-
- #[test]
- fn page_400() {
- let response = TestRequest::with_state(AppState {
- shared: Arc::new(RwLock::new(0)),
- })
- .run(&super::page_400)
- .unwrap();
- assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
- }
-
- #[test]
- fn page_404() {
- let response = TestRequest::default().run(&super::page_404).unwrap();
- assert_eq!(response.status(), http::StatusCode::NOT_FOUND);
- }
-
- #[test]
- fn default_no_path() {
- expect_404("");
- }
-
- #[test]
- fn default_slash() {
- expect_404("/");
- expect_404("//");
- expect_404("/ /");
- expect_404("/ //");
- expect_404("// ");
- }
-
- #[test]
- fn default_invalid_prefix() {
- expect_404("/test");
- expect_404(format!("{}test", PREFIX).as_str());
- }
-
- #[test]
- fn default_prefix_no_slash() {
- expect_400(PREFIX);
- }
-
- #[test]
- fn default_prefix_final_slash() {
- expect_400(format!("{}/", PREFIX).as_str());
- }
-
-}