From 3a7af37527c7752b42d518ec719a479254d6ba96 Mon Sep 17 00:00:00 2001
From: Vika <vika@fireburn.ru>
Date: Sun, 10 Jul 2022 14:52:43 +0300
Subject: micropub: move MicropubError into kittybox-util

Looks like this shared data structure will be useful to me later when
splitting off the media endpoint into its own crate.
---
 kittybox-rs/src/media/mod.rs    | 16 ++++-----
 kittybox-rs/src/micropub/mod.rs | 79 ++---------------------------------------
 2 files changed, 8 insertions(+), 87 deletions(-)

(limited to 'kittybox-rs/src')

diff --git a/kittybox-rs/src/media/mod.rs b/kittybox-rs/src/media/mod.rs
index e9e91ac..4a253d0 100644
--- a/kittybox-rs/src/media/mod.rs
+++ b/kittybox-rs/src/media/mod.rs
@@ -2,20 +2,13 @@ use axum::{
     extract::{Extension, Host, multipart::{Multipart, MultipartError}, Path},
     response::{IntoResponse, Response}, headers::HeaderValue,
 };
-use crate::{micropub::{MicropubError, ErrorType}, tokenauth::User};
+use kittybox_util::error::{MicropubError, ErrorType};
+use crate::tokenauth::User;
 
 pub mod storage;
 use storage::{MediaStore, MediaStoreError, Metadata, ErrorKind};
 pub use storage::file::FileStore;
 
-impl From<MultipartError> for MicropubError {
-    fn from(err: MultipartError) -> Self {
-        Self {
-            error: ErrorType::InvalidRequest,
-            error_description: format!("multipart/form-data error: {}", err)
-        }
-    }
-}
 impl From<MediaStoreError> for MicropubError {
     fn from(err: MediaStoreError) -> Self {
         Self {
@@ -47,7 +40,10 @@ pub async fn upload<S: MediaStore>(
             }.into_response();
         },
         Err(err) => {
-            return MicropubError::from(err).into_response();
+            return MicropubError {
+                error: ErrorType::InternalServerError,
+                error_description: format!("Error while parsing multipart/form-data: {}", err)
+            }.into_response();
         },
     };
     let metadata: Metadata = (&field).into();
diff --git a/kittybox-rs/src/micropub/mod.rs b/kittybox-rs/src/micropub/mod.rs
index 1fa442a..1d81505 100644
--- a/kittybox-rs/src/micropub/mod.rs
+++ b/kittybox-rs/src/micropub/mod.rs
@@ -11,6 +11,8 @@ use serde_json::json;
 use std::fmt::Display;
 use tracing::{debug, error, info, warn};
 
+use kittybox_util::{MicropubError, ErrorType};
+
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 #[serde(rename_all = "kebab-case")]
 enum QueryType {
@@ -26,25 +28,6 @@ pub struct MicropubQuery {
     url: Option<String>,
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
-#[serde(rename_all = "snake_case")]
-pub(crate) enum ErrorType {
-    AlreadyExists,
-    Forbidden,
-    InternalServerError,
-    InvalidRequest,
-    InvalidScope,
-    NotAuthorized,
-    NotFound,
-    UnsupportedMediaType,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub(crate) struct MicropubError {
-    pub(crate) error: ErrorType,
-    pub(crate) error_description: String,
-}
-
 impl From<StorageError> for MicropubError {
     fn from(err: StorageError) -> Self {
         Self {
@@ -57,64 +40,6 @@ impl From<StorageError> for MicropubError {
     }
 }
 
-impl std::error::Error for MicropubError {}
-
-impl Display for MicropubError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("Micropub error: ")?;
-        f.write_str(&self.error_description)
-    }
-}
-
-impl From<&MicropubError> for StatusCode {
-    fn from(err: &MicropubError) -> Self {
-        use ErrorType::*;
-        match err.error {
-            AlreadyExists => StatusCode::CONFLICT,
-            Forbidden => StatusCode::FORBIDDEN,
-            InternalServerError => StatusCode::INTERNAL_SERVER_ERROR,
-            InvalidRequest => StatusCode::BAD_REQUEST,
-            InvalidScope => StatusCode::UNAUTHORIZED,
-            NotAuthorized => StatusCode::UNAUTHORIZED,
-            NotFound => StatusCode::NOT_FOUND,
-            UnsupportedMediaType => StatusCode::UNSUPPORTED_MEDIA_TYPE,
-        }
-    }
-}
-impl From<MicropubError> for StatusCode {
-    fn from(err: MicropubError) -> Self {
-        (&err).into()
-    }
-}
-
-impl axum::response::IntoResponse for MicropubError {
-    fn into_response(self) -> axum::response::Response {
-        axum::response::IntoResponse::into_response((
-            StatusCode::from(&self),
-            axum::response::Json(self),
-        ))
-    }
-}
-
-impl From<serde_json::Error> for MicropubError {
-    fn from(err: serde_json::Error) -> Self {
-        use ErrorType::*;
-        Self {
-            error: InvalidRequest,
-            error_description: err.to_string(),
-        }
-    }
-}
-
-impl MicropubError {
-    fn new(error: ErrorType, error_description: &str) -> Self {
-        Self {
-            error,
-            error_description: error_description.to_owned(),
-        }
-    }
-}
-
 mod util;
 pub(crate) use util::normalize_mf2;
 
-- 
cgit 1.4.1