re-write db functions to use query macro instead

src/db.rs

@@ -18,8 +18,8 @@ pub async fn add_file(
 ) -> Result<SqliteQueryResult, sqlx::Error> {
     // We need to send the filetype, but only sometimes.
     if filetype.is_none() {
-        // Filetype is none, so don't send the filetype in the sql query!
-        let result = sqlx::query(
+        // Filetype is none, so don't send the filetype in the sql query
+        let result = sqlx::query!(
             "INSERT INTO files (
                 file,
                 expiry, 
@@ -29,24 +29,24 @@ pub async fn add_file(
                 ip, 
                 domain)
                 VALUES ( ?,?,?,?,?,?,? )",
+            file,
+            expiry,
+            adminkey,
+            accessed,
+            filesize,
+            ip,
+            domain
         )
-        .bind(file)
-        .bind(expiry)
-        .bind(adminkey)
-        .bind(accessed)
-        .bind(filesize)
-        .bind(ip)
-        .bind(domain)
         .execute(sqlconn)
         .await;
         tracing::debug!("add_file.filetype.is_none(Added file to the database.)");
         result
     } else {
-        // Filetype is NOT none, so send the filetype in the sql query!
-        let result = sqlx::query(
+        // Filetype is NOT none, so send the filetype in the sql query
+        let result = sqlx::query!(
             "INSERT INTO files (
                 file,
-                filetype, 
+                filetype,
                 expiry, 
                 adminkey, 
                 accessed,
@@ -54,15 +54,15 @@ pub async fn add_file(
                 ip, 
                 domain)
                 VALUES ( ?,?,?,?,?,?,?,? )",
+            file,
+            filetype,
+            expiry,
+            adminkey,
+            accessed,
+            filesize,
+            ip,
+            domain
         )
-        .bind(file)
-        .bind(filetype)
-        .bind(expiry)
-        .bind(adminkey)
-        .bind(accessed)
-        .bind(filesize)
-        .bind(ip)
-        .bind(domain)
         .execute(sqlconn)
         .await;
         tracing::debug!("add_file.filetype.not_none(Added file to the database.)");
@@ -76,14 +76,20 @@ pub async fn add_file(
 // This function checks if the filename actually exists in the DB, returning true if it does, false otherwise.
 // This /can/ return true if there are multiple files with the same name, as we're not really interested in checking for errors here.
 pub async fn check_filename(sqlconn: &Pool<Sqlite>, filename: String) -> bool {
-    let result = sqlx::query("SELECT COUNT(*) FROM files WHERE file = ? and isDeleted = 0")
-        .bind(&filename)
-        .fetch_one(sqlconn)
-        .await
-        .unwrap();
-    let filecount: i32 = result.get("COUNT(*)");
-    tracing::debug!("check_file(filecount: {:?})", filecount);
-    match filecount {
+    let result = sqlx::query!(
+        "SELECT COUNT(*) as count 
+            FROM files 
+            WHERE file = ? and isDeleted = 0",
+        filename
+    )
+    .fetch_one(sqlconn)
+    .await
+    .unwrap();
+
+    tracing::debug!("check_file(filecount: {:?})", result.count);
+
+    // Check if there are multiple files with the same name
+    match result.count {
         0 => false, // File doesn't exist :(
         1 => true,  // File exists!
         _ => {
@@ -91,25 +97,26 @@ pub async fn check_filename(sqlconn: &Pool<Sqlite>, filename: String) -> bool {
             tracing::info!(
                 "Multiple files exist for file: {}, filecount: {}",
                 filename,
-                filecount
+                result.count
             );
             true
         }
     }
 }
 
-// Check if the adminkey corresponds to a file, and return Some(file), or None.
+// This function receives an adminkey, (and sqlpool) and returns a Some(String) with the filename corresponding to the adminkey.
+// It returns files that haven't already been deleted, so this is a 'single-use' operation per file.
 pub async fn check_adminkey(sqlconn: &Pool<Sqlite>, adminkey: String) -> Option<String> {
-    // Make sure isDeleted = 0, so we don't try to delete files that are already deleted.
-    // Making this function into a 'single use' per file.
-    let result = sqlx::query("SELECT file FROM files WHERE adminkey = ? AND isDeleted = 0")
-        .bind(&adminkey)
-        .fetch_one(sqlconn)
-        .await;
+    let result = sqlx::query!(
+        "SELECT file FROM files WHERE adminkey = ? AND isDeleted = 0",
+        adminkey
+    )
+    .fetch_one(sqlconn)
+    .await;
     if result.is_err() {
         return None;
     } else {
-        let filename: String = result.unwrap().get("file");
+        let filename: String = result.unwrap().file;
         tracing::debug!("check_adminkey(filename: {:?})", filename);
         if filename.is_empty() {
             None
@@ -119,55 +126,67 @@ pub async fn check_adminkey(sqlconn: &Pool<Sqlite>, adminkey: String) -> Option<
     }
 }
 
-// Marking a file as deleted
-pub async fn delete_file(sqlconn: &Pool<Sqlite>, filename: String) -> SqliteQueryResult {
+// Marking a file as deleted in the DB (Doesn't delete the file on disk)
+// This function returns a Some(u64), with the number of rows modified.
+pub async fn delete_file(sqlconn: &Pool<Sqlite>, filename: String) -> Option<u64> {
     tracing::debug!("delete_file(adminkey: {})", filename);
-    let result = sqlx::query("UPDATE files SET isDeleted = 1 WHERE file = ?")
-        .bind(&filename)
+    let result = sqlx::query!("UPDATE files SET isDeleted = 1 WHERE file = ?", filename)
         .execute(sqlconn)
         .await;
-    result.unwrap()
 
-    // TODO: Check for row affected, and give a Result
+    if result.is_err() {
+        // If error, return none
+        return None;
+    } else {
+        return Some(result.unwrap().rows_affected());
+    }
 }
 
-// Updating a files viewcount
-pub async fn update_fileview(
-    sqlconn: &Pool<Sqlite>,
-    filename: String,
-    accessed: i32,
-) -> SqliteQueryResult {
-    sqlx::query("UPDATE files SET accessed = ?, views = views + 1 WHERE file = ?")
-        .bind(accessed)
-        .bind(filename)
-        .execute(sqlconn)
-        .await
-        .unwrap()
+// Updating a files viewcount and accesstime.
+// This receives the a String with the filename, i32 unix timestamp (and sqlpool)
+// This returns a Some(u64), with the number of rows affected.
+pub async fn update_fileview(sqlconn: &Pool<Sqlite>, filename: String, accessed: i32) -> Option<u64> {
+    let result = sqlx::query!(
+        "UPDATE files SET accessed = ?, views = views + 1 WHERE file = ?",
+        accessed,
+        filename
+    )
+    .execute(sqlconn)
+    .await;
 
-    // TODO: Check for row affected, and give a Result
+    if result.is_err() {
+        // If error, return none
+        return None;
+    } else {
+        return Some(result.unwrap().rows_affected());
+    }
 }
 
 // Returns the unix timestamp of the last access - 0 if unviewed.
+// This doesn't do the basic error handling like the above functions, this re-write it completely.
 pub async fn get_accesss_time(sqlconn: &Pool<Sqlite>, filename: String) -> i32 {
-    let result = sqlx::query("SELECT accessed FROM files WHERE file = ?")
-        .bind(&filename)
+    let result = sqlx::query!("SELECT accessed FROM files WHERE file = ?", filename)
         .fetch_one(sqlconn)
         .await;
-    // TODO: We should probably handle /all/ the errors, but idk how.
+
     if result.is_err() {
         // If result is an error, very likely this is the first upload of the file, so lets return the current time!
+        // If it isn't, we're in trouble.
         return SystemTime::now()
             .duration_since(SystemTime::UNIX_EPOCH)
             .unwrap()
             .as_secs() as i32;
+    } else {
+        // This will only panic if the i64 doesn't fit into the i32
+        // I guess I'll have to patch this in 2038 anyway.
+        let accesstime: i32 = result.unwrap().accessed.try_into().unwrap();
+        tracing::debug!(
+            "get_accesss_time(filename: {}: {:?})",
+            filename,
+            accesstime.clone()
+        );
+        accesstime as i32
     }
-    let accesstime: i32 = result.unwrap().get("accessed");
-    tracing::debug!(
-        "get_accesss_time(filename: {}: {:?})",
-        filename,
-        accesstime.clone()
-    );
-    accesstime as i32
 }
 
 // Generating a list of files that should be deleted

src/main.rs

@@ -88,7 +88,7 @@ async fn serve_file(req: &mut Request, res: &mut Response) {
         return;
     }
 
-        // override the mimetype if it's part of unsafe extensions
+    // override the mimetype if it's part of unsafe extensions
     let r#unsafe = CONFIG
         .get_array("operations.unsafe_extensions")
         .expect("Couldn't find 'unsafe_extensions' in config. :(");
@@ -147,7 +147,9 @@ async fn serve_file(req: &mut Request, res: &mut Response) {
 
     // TODO: Add actual file serving from the disk HERE, since salvo's built-in way breaks content-type header.
     // Check if nginx sendfile is enabled, because we can skip this if it is.
-    let nginxsendfile = CONFIG.get_bool("server.nginx_sendfile").expect("Couldn't find 'nginx_sendfile' in config. :(");
+    let nginxsendfile = CONFIG
+        .get_bool("server.nginx_sendfile")
+        .expect("Couldn't find 'nginx_sendfile' in config. :(");
 
     if nginxsendfile {
         // Add the header, and we're done.
@@ -156,7 +158,7 @@ async fn serve_file(req: &mut Request, res: &mut Response) {
         res.add_header("X-Accel-Redirect", xsend, true).unwrap();
 
         // We don't really need to update the content-type header, since nginx handles that (TODO: Test this lol)
-        return
+        return;
     } else {
         // If nginx sendfile is disabled, we need to render the file directly
         let filepath = "files/".to_string() + &filename.to_string();
@@ -164,7 +166,10 @@ async fn serve_file(req: &mut Request, res: &mut Response) {
 
         // If the content-type header is already set, we don't need to update this
         if res.headers().contains_key("content-type") {
-            tracing::debug!("content-type exists: content-type: {:?}", res.headers().get("content-type").unwrap());
+            tracing::debug!(
+                "content-type exists: content-type: {:?}",
+                res.headers().get("content-type").unwrap()
+            );
             file.send(headers, res).await;
             // This complains about us writing into ResBody::Stream, but it means it renders as plaintext, so who cares.
             res.render("");