feat: implement redirecting users to original

Signed-off-by: rooot <[e-mail]>

src/bsky.rs

···
 use crate::meow::{
-    EmbedAuthor, EmbedMedia, EmbedSource, EmbedThingy, GenericError, MissingElementError,
+    BotCheck, EmbedAuthor, EmbedMedia, EmbedResponse, EmbedSource, EmbedThingy, GenericError,
+    MissingElementError,
 };
 use crate::ManagedBskyAgent;
 use bsky_sdk::api::app::bsky::embed::images::ImageData;
···
 
 #[get("/profile/<name>/post/<post>")]
 pub(crate) async fn profile_post(
+    check: BotCheck,
     agent: &State<ManagedBskyAgent>,
     name: &str,
     post: &str,
-) -> Result<EmbedThingy, GenericError> {
+) -> Result<EmbedResponse, GenericError> {
+    let source = EmbedSource::Bsky(name.into(), post.into());
+
+    if let Some(redirect) = check.redirect(&source) {
+        return Ok(redirect);
+    }
+
     let atproto_uri = format!("at://{}/app.bsky.feed.post/{}", name, post);
     let post_thread = agent
         .agent
···
                             }
                         }
 
-                        return Ok(EmbedThingy {
+                        return Ok(EmbedResponse::Embed(EmbedThingy {
                             author: Some(author),
                             text,
                             embeds: embed_embeds,
-                            source: EmbedSource::Bsky(format!("https://bsky.social/profile/{}/post/{}", name, post)),
-                        });
+                            source,
+                        }));
                     }
                 }
             }

src/meow.rs

···
+use std::fmt::{Display, Formatter};
+
 use rocket::http::{ContentType, Status};
-use rocket::response::Responder;
+use rocket::request::{FromRequest, Outcome};
+use rocket::response::{Redirect, Responder};
 use rocket::{response, Request, Response};
 use serde::ser::SerializeMap;
 use serde::Serialize;
···
 // this contains the original source/url of the embed
 #[derive(Debug)]
 pub enum EmbedSource {
-    Bsky(String),
+    Bsky(String, String),
+}
+
+impl Display for EmbedSource {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            EmbedSource::Bsky(name, post) => {
+                write!(f, "https://bsky.app/profile/{}/post/{}", name, post)
+            }
+        }
+    }
 }
 
 #[derive(Debug)]
···
 
         // maybe in the future this will be useful IF i add support for other sites
 
-        let source_url;
-        match self.source {
-            EmbedSource::Bsky(url) => {
-                source_url = url;
-                html.push_str("<meta property=\"theme-color\" content=\"#0085ff\">\n");
-            }
-        }
+        let source_url = self.source.to_string();
+        let color = match self.source {
+            EmbedSource::Bsky(_, _) => "#0085ff",
+        };
+
+        html.push_str(&format!(
+            "<meta property=\"theme-color\" content=\"{}\">\n",
+            color
+        ));
 
         // add canonical urls
         html.push_str(&format!(r#"<link rel="canonical" href="{}">"#, source_url));
···
             .finalize())
     }
 }
+
+pub enum EmbedResponse {
+    Embed(EmbedThingy),
+    Redirect(String),
+}
+
+impl<'r, 'o: 'r> Responder<'r, 'o> for EmbedResponse {
+    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'o> {
+        match self {
+            EmbedResponse::Embed(embed) => embed.respond_to(req),
+            EmbedResponse::Redirect(url) => Redirect::temporary(url).respond_to(req),
+        }
+    }
+}
+
+pub struct BotCheck(bool);
+
+impl BotCheck {
+    pub fn redirect(&self, src: &EmbedSource) -> Option<EmbedResponse> {
+        if self.0 {
+            Some(EmbedResponse::Redirect(src.to_string()))
+        } else {
+            None
+        }
+    }
+}
+
+fn is_bot(user_agent: &str) -> bool {
+    // if you know a bot not listed here that embeds content, pls open an issue!!
+    let agents = [
+        "Discordbot",
+        "https://discordapp.com",
+        "Bluesky Cardyb",
+        "https://opengraph.io",
+        "Twitterbot",
+        "TwitterBot",
+        "FacebookBot",
+        // not a bot but used for debugging :3c
+        "curl/",
+    ];
+
+    agents.iter().any(|agent| user_agent.contains(*agent))
+}
+
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for BotCheck {
+    type Error = ();
+
+    async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
+        if let Some(user_agent) = req.headers().get_one("user-agent") {
+            if !is_bot(user_agent) {
+                return Outcome::Success(Self(true));
+            }
+        }
+        Outcome::Success(Self(false))
+    }
+}