Initial commit

src/db/upload_id.rs

@@ -0,0 +1,94 @@
+use std::{fmt, str::FromStr};
+
+use eyre::OptionExt;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum UploadKind {
+    Thumbnail,
+    Screenshot,
+    File,
+}
+
+impl UploadKind {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Thumbnail => "t",
+            Self::Screenshot => "s",
+            Self::File => "f",
+        }
+    }
+}
+
+impl FromStr for UploadKind {
+    type Err = eyre::Report;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "t" => Self::Thumbnail,
+            "s" => Self::Screenshot,
+            "f" => Self::File,
+            _ => eyre::bail!("wrong upload kind"),
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct UploadId {
+    pub novel: String,
+    pub id: Uuid,
+    pub kind: UploadKind,
+}
+
+impl UploadId {
+    pub fn to_file_name(&self) -> String {
+        format!("{}-{}", self.id, self.kind.as_str())
+    }
+}
+
+impl FromStr for UploadId {
+    type Err = eyre::Report;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let Some((novel, id_and_kind)) = s.rsplit_once('/') else {
+            eyre::bail!("invalid upload id")
+        };
+        if id_and_kind.is_empty() {
+            eyre::bail!("invalid upload id");
+        }
+        let (id, kind) = id_and_kind.split_at(id_and_kind.len().checked_sub(1).ok_or_eyre("loh")?);
+
+        Ok(Self {
+            novel: novel.to_owned(),
+            kind: kind.parse()?,
+            id: id.parse()?,
+        })
+    }
+}
+
+impl fmt::Display for UploadId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}/{}{}", self.novel, self.id, self.kind.as_str())
+    }
+}
+
+impl Serialize for UploadId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl<'de> Deserialize<'de> for UploadId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = <&str>::deserialize(deserializer)?;
+        s.parse().map_err(|e| serde::de::Error::custom(e))
+    }
+}