Add delete handler and json-payload error response

src/handlers/errors.rs

@@ -1,16 +1,21 @@
+use actix_web::http::StatusCode;
+use actix_web::HttpResponse;
 use serde::ser::SerializeStruct;
 use serde::{Serialize, Serializer};
 
 pub enum HandlerError {
-    BadUidError,
+    BadUid,
+    ProtectedSchedule
 }
 
 impl HandlerError {
-    fn to_code(&self) -> u32 {
+    fn get_code(&self) -> StatusCode {
         match self {
-            HandlerError::BadUidError => 400
+            HandlerError::BadUid => StatusCode::BAD_REQUEST,
+            HandlerError::ProtectedSchedule => StatusCode::FORBIDDEN,
         }
     }
+
 }
 
 impl Serialize for HandlerError {
@@ -19,7 +24,7 @@ impl Serialize for HandlerError {
             S: Serializer,
     {
         let mut s = serializer.serialize_struct("error", 2)?;
-        s.serialize_field("code", &self.to_code())?;
+        s.serialize_field("code", &self.get_code().as_u16())?;
         s.serialize_field("description", &String::from(self))?;
         s.end()
     }
@@ -28,7 +33,14 @@ impl Serialize for HandlerError {
 impl From<&HandlerError> for String {
     fn from(err: &HandlerError) -> Self {
         match err {
-            HandlerError::BadUidError => String::from("the uid is in a bad format"),
+            HandlerError::BadUid => String::from("the uid is in a bad format"),
+            HandlerError::ProtectedSchedule => String::from("the targeted schedule is protected"),
         }
     }
 }
+
+impl From<HandlerError> for HttpResponse {
+    fn from(err: HandlerError) -> Self {
+        HttpResponse::build(err.get_code()).json(err)
+    }
+}

src/handlers/mod.rs

@@ -1,2 +1,38 @@
+use actix_web::{error, Error, HttpRequest, HttpResponse};
+use serde::ser::SerializeStruct;
+use serde::{Serialize, Serializer};
+
+pub(crate) mod errors;
 pub mod v1;
-mod errors;
+
+enum EmgauwaJsonPayLoadError {
+    Error(error::JsonPayloadError),
+}
+
+impl Serialize for EmgauwaJsonPayLoadError {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut s = serializer.serialize_struct("error", 3)?;
+        s.serialize_field("type", "json-payload-error")?;
+        s.serialize_field("code", &400)?;
+        s.serialize_field(
+            "description",
+            &match self {
+                EmgauwaJsonPayLoadError::Error(err) => format!("{}", err),
+            }
+        )?;
+        s.end()
+    }
+}
+
+pub fn json_error_handler(err: error::JsonPayloadError, _: &HttpRequest) -> Error {
+    error::InternalError::from_response(
+        "",
+        HttpResponse::BadRequest()
+            .content_type("application/json")
+            .json(EmgauwaJsonPayLoadError::Error(err)),
+    )
+    .into()
+}

src/handlers/v1/schedules.rs

@@ -1,7 +1,6 @@
-use std::str::FromStr;
-use actix_web::{HttpResponse, Responder, web, get};
+use std::convert::TryFrom;
+use actix_web::{HttpResponse, Responder, web, get, delete};
 use serde::{Serialize, Deserialize};
-use uuid::Uuid;
 
 use crate::db;
 use crate::db::models::Periods;
@@ -22,26 +21,18 @@ pub async fn index() -> impl Responder {
 #[get("/api/v1/schedules/{schedule_id}")]
 pub async fn show(web::Path((schedule_uid,)): web::Path<(String,)>) -> impl Responder {
 
-    let emgauwa_uid = match schedule_uid.as_str() {
-        "on" => Ok(EmgauwaUid::On),
-        "off" => Ok(EmgauwaUid::Off),
-        any => match Uuid::from_str(any) {
-            Ok(uuid) => Ok(EmgauwaUid::Any(uuid)),
-            Err(_) => Err(HandlerError::BadUidError)
-        }
-    };
+    let emgauwa_uid = EmgauwaUid::try_from(schedule_uid.as_str()).or(Err(HandlerError::BadUid));
 
     match emgauwa_uid {
         Ok(uid) => {
             let schedule = db::get_schedule_by_uid(uid);
             match schedule {
                 Ok(ok) => HttpResponse::Ok().json(ok),
-                Err(err) => HttpResponse::NotFound().json(err),
+                Err(err) => HttpResponse::from(err),
             }
         },
-        Err(err) => HttpResponse::BadRequest().json(err)
+        Err(err) => HttpResponse::from(err)
     }
-
 }
 
 pub async fn add(post: web::Json<RequestSchedule>) -> impl Responder {
@@ -49,10 +40,25 @@ pub async fn add(post: web::Json<RequestSchedule>) -> impl Responder {
 
     match new_schedule {
         Ok(ok) => HttpResponse::Created().json(ok),
-        Err(err) => HttpResponse::InternalServerError().json(err),
+        Err(err) => HttpResponse::from(err),
     }
 }
 
-pub async fn delete() -> impl Responder {
-    "hello from delete schedule"
+#[delete("/api/v1/schedules/{schedule_id}")]
+pub async fn delete(web::Path((schedule_uid,)): web::Path<(String,)>) -> impl Responder {
+    let emgauwa_uid = EmgauwaUid::try_from(schedule_uid.as_str()).or(Err(HandlerError::BadUid));
+
+    match emgauwa_uid {
+        Ok(uid) => match uid {
+            EmgauwaUid::Off => HttpResponse::from(HandlerError::ProtectedSchedule),
+            EmgauwaUid::On => HttpResponse::from(HandlerError::ProtectedSchedule),
+            EmgauwaUid::Any(_) => {
+                match db::delete_schedule_by_uid(uid) {
+                    Ok(_) => HttpResponse::Ok().json("schedule got deleted"),
+                    Err(err) => HttpResponse::from(err)
+                }
+            }
+        },
+        Err(err) => HttpResponse::from(err)
+    }
 }