initial commit

src/main.rs

@@ -0,0 +1,184 @@
+use std::{env, error::Error};
+
+use poem::{Route, Server, listener::TcpListener};
+use poem_openapi::{
+    ApiResponse, Object, OpenApi, OpenApiService, SecurityScheme, auth::Bearer, payload::Json,
+    payload::PlainText,
+};
+use tokio::task::spawn_blocking;
+
+struct Bookmark {
+    id: i32,
+    title: String,
+    url: String,
+    description: String,
+}
+
+#[derive(SecurityScheme)]
+#[oai(ty = "bearer", key_name = "X-Minibookfluxmark-Auth", key_in = "header")]
+struct BearerAuth(Bearer);
+
+impl BearerAuth {
+    fn check(&self) -> bool {
+        self.0.token == std::env::var("MINIBOOKFLUXMARK_ACCESS_TOKEN").unwrap()
+    }
+}
+
+#[derive(Object, Clone)]
+struct BookmarkRequest {
+    title: String,
+    url: String,
+    description: String,
+}
+
+#[derive(ApiResponse)]
+enum AddBookmarkResponse {
+    #[oai(status = 200)]
+    Ok,
+    #[oai(status = 403)]
+    NotAuthorized,
+    #[oai(status = 500)]
+    ServerError,
+}
+
+#[derive(ApiResponse)]
+enum FeedResponse {
+    #[oai(status = 200)]
+    Ok(PlainText<String>),
+    #[oai(status = 403)]
+    NotAuthorized,
+    #[oai(status = 500)]
+    ServerError,
+}
+
+struct Api;
+
+#[OpenApi]
+impl Api {
+    #[oai(path = "/add", method = "post")]
+    async fn post_bookmark(
+        &self,
+        body: Json<BookmarkRequest>,
+        auth: BearerAuth,
+    ) -> AddBookmarkResponse {
+        if !auth.check() {
+            return AddBookmarkResponse::NotAuthorized;
+        }
+
+        if let Err(e) = spawn_blocking(move || {
+            let db_conn = match rusqlite::Connection::open(
+                env::var("MINIBOOKFLUXMARK_DB_PATH").unwrap_or(String::from("db.sqlite")),
+            ) {
+                Ok(c) => c,
+                Err(e) => {
+                    println!("Failde to open db: {e}");
+                    return Err(e);
+                }
+            };
+            db_conn.execute(
+                "insert into bookmarks (title, url, description) values (?1, ?2, ?3)",
+                (&body.title, &body.url, &body.description),
+            )?;
+
+            Ok(())
+        })
+        .await
+        {
+            println!("Failed to spawn database save: {e}");
+            return AddBookmarkResponse::ServerError;
+        }
+
+        AddBookmarkResponse::Ok
+    }
+
+    #[oai(path = "/feed", method = "get")]
+    async fn get_feed(&self, auth: BearerAuth) -> FeedResponse {
+        if !auth.check() {
+            return FeedResponse::NotAuthorized;
+        }
+
+        let mut resp = String::new();
+        resp.push_str(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<rss version=\"2.0\">\n<channel>",
+        );
+
+        match spawn_blocking(move || {
+            let db_conn = match rusqlite::Connection::open(
+                env::var("MINIBOOKFLUXMARK_DB_PATH").unwrap_or(String::from("db.sqlite")),
+            ) {
+                Ok(c) => c,
+                Err(e) => {
+                    println!("Failde to open db: {e}");
+                    return Err(e);
+                }
+            };
+            let mut query = db_conn.prepare("select id, title, url, description from bookmarks")?;
+            let bookmark_iter = query.query_map([], |row| {
+                Ok(Bookmark {
+                    id: row.get(0)?,
+                    title: row.get(1)?,
+                    url: row.get(2)?,
+                    description: row.get(3)?,
+                })
+            })?;
+            let bookmarks = Vec::from_iter(bookmark_iter.flatten());
+            Ok(bookmarks)
+        })
+        .await
+        {
+            Ok(Ok(bookmarks)) => {
+                for b in bookmarks {
+                    resp.push_str(&format!("<item>\n<title>{}</title>\n<link>{}</link>\n<description>{}</description>\n</item>", b.title, b.url, b.description));
+                }
+            }
+            Ok(Err(e)) => {
+                println!("Failed to read database: {e}");
+                return FeedResponse::ServerError;
+            }
+            Err(e) => {
+                println!("Failed to spawn database read: {e}");
+                return FeedResponse::ServerError;
+            }
+        }
+
+        resp.push_str("</channel>\n</rss>");
+
+        FeedResponse::Ok(PlainText(resp))
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    match spawn_blocking(move || {
+            let db_conn = match rusqlite::Connection::open(
+                env::var("MINIBOOKFLUXMARK_DB_PATH").unwrap_or(String::from("db.sqlite")),
+            ) {
+                Ok(c) => c,
+                Err(e) => {
+                    println!("Failde to open db: {e}");
+                    return;
+                }
+            };
+            db_conn
+                .execute(
+                    "create table if not exists bookmarks (id integer primary key, title text not null, url text not null, description text not null)", ()
+                )
+                .unwrap();
+        })
+        .await
+        {
+            Ok(_) => (),
+            Err(e) => println!("Failed to spawn database save: {e}"),
+        }
+    let api_service = OpenApiService::new(Api, "minibookfluxmark", "0.1").server("/api/v1");
+    let ui = api_service.swagger_ui();
+    let app = Route::new()
+        .nest("/api/v1/", api_service)
+        .nest("/ui/v1/", ui);
+
+    Server::new(TcpListener::bind("0.0.0.0:3000"))
+        .run(app)
+        .await?;
+
+    Ok(())
+}