cleanup upload_video arguments

Author: oscartbeaumont

apps/desktop/src-tauri/src/lib.rs

@@ -1111,9 +1111,9 @@ async fn upload_exported_video(
         &app,
         upload_id.clone(),
         output_path,
-        Some(s3_config),
-        Some(meta.project_path.join("screenshots/display.jpg")),
-        Some(metadata),
+        meta.project_path.join("screenshots/display.jpg"),
+        s3_config,
+        metadata,
         Some(channel.clone()),
     )
     .await

apps/desktop/src-tauri/src/recording.rs

@@ -803,26 +803,29 @@ async fn handle_recording_finish(
                                 }
                             }
                         } else {
-                            let meta = build_video_meta(&output_path).ok();
-                            // The upload_video function handles screenshot upload, so we can pass it along
-                            match upload_video(
-                                &app,
-                                video_upload_info.id.clone(),
-                                output_path,
-                                Some(video_upload_info.config.clone()),
-                                Some(display_screenshot.clone()),
-                                meta,
-                                None,
-                            )
-                            .await
+                            if let Ok(meta) = build_video_meta(&output_path)
+                                .map_err(|err| error!("Error getting video metdata: {}", err))
                             {
-                                Ok(_) => {
-                                    info!(
-                                        "Final video upload with screenshot completed successfully"
-                                    )
-                                }
-                                Err(e) => {
-                                    error!("Error in final upload with screenshot: {}", e)
+                                // The upload_video function handles screenshot upload, so we can pass it along
+                                match upload_video(
+                                    &app,
+                                    video_upload_info.id.clone(),
+                                    output_path,
+                                    display_screenshot.clone(),
+                                    video_upload_info.config.clone(),
+                                    meta,
+                                    None,
+                                )
+                                .await
+                                {
+                                    Ok(_) => {
+                                        info!(
+                                            "Final video upload with screenshot completed successfully"
+                                        )
+                                    }
+                                    Err(e) => {
+                                        error!("Error in final upload with screenshot: {}", e)
+                                    }
                                 }
                             }
                         }

apps/desktop/src-tauri/src/upload.rs

@@ -34,53 +34,10 @@ pub struct CreateErrorResponse {
     error: String,
 }
 
-// fn deserialize_empty_object_as_string<'de, D>(deserializer: D) -> Result<String, D::Error>
-// where
-//     D: Deserializer<'de>,
-// {
-//     struct StringOrObject;
-
-//     impl<'de> de::Visitor<'de> for StringOrObject {
-//         type Value = String;
-
-//         fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-//             formatter.write_str("string or empty object")
-//         }
-
-//         fn visit_str<E>(self, value: &str) -> Result<String, E>
-//         where
-//             E: de::Error,
-//         {
-//             Ok(value.to_string())
-//         }
-
-//         fn visit_string<E>(self, value: String) -> Result<String, E>
-//         where
-//             E: de::Error,
-//         {
-//             Ok(value)
-//         }
-
-//         fn visit_map<M>(self, _map: M) -> Result<String, M::Error>
-//         where
-//             M: de::MapAccess<'de>,
-//         {
-//             // Return empty string for empty objects
-//             Ok(String::new())
-//         }
-//     }
-
-//     deserializer.deserialize_any(StringOrObject)
-// }
-
 impl S3UploadMeta {
     pub fn id(&self) -> &str {
         &self.id
     }
-
-    // pub fn new(id: String) -> Self {
-    //     Self { id }
-    // }
 }
 
 #[derive(Serialize, Debug, Clone)]
@@ -106,12 +63,6 @@ pub struct UploadedImage {
     pub id: String,
 }
 
-// pub struct UploadedAudio {
-//     pub link: String,
-//     pub id: String,
-//     pub config: S3UploadMeta,
-// }
-
 pub struct UploadProgressUpdater {
     video_state: Option<VideoProgressState>,
     app: AppHandle,
@@ -212,26 +163,22 @@ pub async fn upload_video(
     app: &AppHandle,
     video_id: String,
     file_path: PathBuf,
-    existing_config: Option<S3UploadMeta>,
-    screenshot_path: Option<PathBuf>,
-    meta: Option<S3VideoMeta>,
+    screenshot_path: PathBuf,
+    s3_config: S3UploadMeta,
+    meta: S3VideoMeta,
     channel: Option<Channel<UploadProgress>>,
 ) -> Result<UploadedVideo, String> {
-    println!("Uploading video {video_id}...");
+    info!("Uploading video {video_id}...");
 
     let client = reqwest::Client::new();
-    let s3_config = match existing_config {
-        Some(config) => config,
-        None => create_or_get_video(app, false, Some(video_id.clone()), None, meta).await?,
-    };
 
     let presigned_put = presigned_s3_put(
         app,
         PresignedS3PutRequest {
             video_id: video_id.clone(),
             subpath: "result.mp4".to_string(),
             method: PresignedS3PutRequestMethod::Put,
-            meta: Some(build_video_meta(&file_path)?),
+            meta: Some(meta),
         },
     )
     .await?;
@@ -270,12 +217,7 @@ pub async fn upload_video(
         }
     });
 
-    let screenshot_upload = match screenshot_path {
-        Some(screenshot_path) if screenshot_path.exists() => {
-            Some(prepare_screenshot_upload(app, &s3_config, screenshot_path))
-        }
-        _ => None,
-    };
+    let screenshot_upload = prepare_screenshot_upload(app, &s3_config, screenshot_path);
 
     let video_upload = client
         .put(presigned_put)
@@ -284,21 +226,15 @@ pub async fn upload_video(
 
     let (video_upload, screenshot_result): (
         Result<reqwest::Response, reqwest::Error>,
-        Option<Result<reqwest::Response, String>>,
-    ) = tokio::join!(video_upload.send(), async {
-        if let Some(screenshot_req) = screenshot_upload {
-            Some(screenshot_req.await)
-        } else {
-            None
-        }
-    });
+        Result<reqwest::Response, String>,
+    ) = tokio::join!(video_upload.send(), screenshot_upload);
 
     let response = video_upload.map_err(|e| format!("Failed to send upload file request: {e}"))?;
 
     if response.status().is_success() {
         println!("Video uploaded successfully");
 
-        if let Some(Ok(screenshot_response)) = screenshot_result {
+        if let Ok(screenshot_response) = screenshot_result {
             if screenshot_response.status().is_success() {
                 println!("Screenshot uploaded successfully");
             } else {