Switch to using New Renderer

README.md

@@ -1,2 +1,4 @@
 # Cache Mii
 Mii Render Caching Server that saves a .png and .tga render of a user's mii for use across SPFN's services
+
+Renderer Used: https://mii-server.cubexmine.dev/

src/main.rs

@@ -1,19 +1,13 @@
 use dotenvy::dotenv;
-use rocket::http::Status;
 use rocket::fs::NamedFile;
 use rocket::State;
 use reqwest::Client;
 use bytes::Bytes;
 
-static MII_RENDERER_URL: &str = "https://mii-renderer.spfn.net";
+static MII_RENDERER_URL: &str = "https://mii-server.cubexmine.dev";
 
-static ALLOWED_FORMATS: [&str; 2] = [
+async fn request_mii_render(client: &State<Client>, pid: i32, path: &str) -> Option<Bytes> {
-    "png",
+    let req_str = format!("{MII_RENDERER_URL}/{pid}/{path}");
-    "tga",
-];
-
-async fn request_mii_render(client: &State<Client>, mii_data: &str, ext: &str) -> Option<Bytes> {
-    let req_str = format!("{}/miis/image.{}?data={}", MII_RENDERER_URL, ext, mii_data);
 
     let response = client.get(req_str)
         .send()
@@ -21,7 +15,16 @@ async fn request_mii_render(client: &State<Client>, mii_data: &str, ext: &str) -
 
     match response {
         Ok(res) => {
-            Some(res.bytes().await.expect("Failed to parse Mii Render to Bytes"))
+            let bytes = res.bytes().await;
+            match bytes {
+                Ok(bytes) => {
+                    Some(bytes)
+                },
+                Err(_) => {
+                    println!("Error Getting Response Bytes");
+                    None
+                }
+            }
         }
         Err(err) => {
             let status = match err.status() {
@@ -36,22 +39,26 @@ async fn request_mii_render(client: &State<Client>, mii_data: &str, ext: &str) -
     }
 }
 
-#[rocket::get("/<pid_str>/<path>")]
+#[rocket::get("/<pid>/<path>")]
-pub async fn mii_render(pid_str: &str, path: &str, client: &State<Client>) -> Option<NamedFile> {
+pub async fn mii_render(pid: i32, path: &str, client: &State<Client>) -> Option<NamedFile> {
-    let ext = path.splitn(2, ".").nth(1)?;
-    let pid: i32 = pid_str.parse().expect("PID is not an i32");
-
-    if !ALLOWED_FORMATS.contains(&ext) {return None}
-
     let mii_data = {
-        let route = format!("https://account.spfn.net/api/v2/users/{}/mii", pid);
+        let route = format!("https://account.spfn.net/api/v2/users/{pid}/mii");
         let response = client.get(route)
             .send()
-            .await
+            .await;
-            .ok()
-            .expect("Error Retrieving Mii Data");
         
-        let data: String = response.json().await.expect("Failed to parse Mii Data Response");
+        let response = match response {
+            Ok(res) => res,
+            Err(e) => {
+                println!("Error Fetching Mii Data: {e}");
+                return None;
+            }
+        };
+
+        let data: String = match response.json().await {
+            Ok(data) => data,
+            Err(_) => return None,
+        };
 
         data
     };
@@ -69,41 +76,41 @@ pub async fn mii_render(pid_str: &str, path: &str, client: &State<Client>) -> Op
                 Ok(hash) => {
                     if hash == mii_data { // Cached images are correct
                         if !img_path.exists() || !img_path.is_file() { // File type was not found - Request data
-                            let img_data = request_mii_render(client, &mii_data, ext).await?;
+                            let img_data = request_mii_render(client, pid, path).await?;
                             let _ = std::fs::write(&img_path, &img_data);
                         }
                     } else { // Cached images are outdated - Update data
-                        let img_data = request_mii_render(client, &mii_data, ext).await?;
+                        let img_data = request_mii_render(client, pid, path).await?;
                         let _ = std::fs::write(&img_path, &img_data);
                     };
                 }
 
                 Err(_) => { // Data cannot be read - Request data
-                    println!("Data is not valid");
                     let _ = std::fs::write(data_path, &mii_data);
 
-                    let img_data = request_mii_render(client, &mii_data, ext).await?;
+                    let img_data = request_mii_render(client, pid, path).await?;
                     let _ = std::fs::write(&img_path, &img_data);
                 }
             }
         } else { // Data isn't saved - Request data
-            println!("Data is not recorded");
             let _ = std::fs::write(data_path, &mii_data);
 
-            let img_file = request_mii_render(client, &mii_data, ext).await?;
+            let img_file = request_mii_render(client, pid, path).await?;
             let _ = std::fs::write(&img_path, &img_file);
         }
     } else { // Mii data was never cached - Request data
-        println!("Mii Data was Never Cached");
         let _ = std::fs::create_dir(format!("miis/{}", pid.to_string()));
 
         let _ = std::fs::write(data_path, &mii_data);
 
-        let img_data = request_mii_render(client, &mii_data, ext).await?;
+        let img_data = request_mii_render(client, pid, path).await?;
         let _ = std::fs::write(&img_path, &img_data);
     };
 
-    let img = NamedFile::open(img_path).await.map_err(|_| Status::InternalServerError).expect("Error opening Image");
+    let img = match NamedFile::open(img_path).await {
+        Ok(img) => img,
+        Err(_) => return None
+    };
 
     Some(img)
 }