Rustic cleanups, dedups and making the code less hard to read in general (#251)

* typos :help_me:

* (part 1/?) massive cleanup to make the code more Rust-ic and cut down heap allocations.

* (part 2/?) massive cleanup to make the code more Rust-ic and cut down heap allocations.

* (part 3/?) cut down some pretty major heap allocations here - more Bytes and BytesMuts, less Vec<u8>s

also I don't really understand why you need to `to_vec` when you don't really use it again afterwards

* (part 4/?) deduplicate error handling in backblaze logic

* (part 5/?) fixes, cleanups, refactors, and reformatting

* (part 6/?) cleanups and refactors

* remove loads of `as_str` in types that already are `Display`

* Revert "remove loads of `as_str` in types that already are `Display`"

This reverts commit 4f974310cfb167ceba03001d81388db4f0fbb509.

* reformat and move routes util to the util module

* use streams

* Run prepare + formatting issues

Co-authored-by: Jai A <jaiagr+gpg@pm.me>
Co-authored-by: Geometrically <18202329+Geometrically@users.noreply.github.com>

src/util/routes.rs

@@ -0,0 +1,53 @@
+use crate::routes::project_creation::CreateError;
+use crate::routes::ApiError;
+use actix_multipart::Field;
+use actix_web::web::Payload;
+use actix_web::HttpResponse;
+use bytes::BytesMut;
+use futures::StreamExt;
+use serde::Serialize;
+
+pub async fn read_from_payload(
+    payload: &mut Payload,
+    cap: usize,
+    err_msg: &'static str,
+) -> Result<BytesMut, ApiError> {
+    let mut bytes = BytesMut::new();
+    while let Some(item) = payload.next().await {
+        if bytes.len() >= cap {
+            return Err(ApiError::InvalidInputError(String::from(err_msg)));
+        } else {
+            bytes.extend_from_slice(&item.map_err(|_| {
+                ApiError::InvalidInputError("Unable to parse bytes in payload sent!".to_string())
+            })?);
+        }
+    }
+    Ok(bytes)
+}
+
+pub async fn read_from_field(
+    field: &mut Field,
+    cap: usize,
+    err_msg: &'static str,
+) -> Result<BytesMut, CreateError> {
+    let mut bytes = BytesMut::new();
+    while let Some(chunk) = field.next().await {
+        if bytes.len() >= cap {
+            return Err(CreateError::InvalidInput(String::from(err_msg)));
+        } else {
+            bytes.extend_from_slice(&chunk.map_err(CreateError::MultipartError)?);
+        }
+    }
+    Ok(bytes)
+}
+
+pub(crate) fn ok_or_not_found<T, U>(version_data: Option<T>) -> Result<HttpResponse, ApiError>
+where
+    U: From<T> + Serialize,
+{
+    if let Some(data) = version_data {
+        Ok(HttpResponse::Ok().json(U::from(data)))
+    } else {
+        Ok(HttpResponse::NotFound().body(""))
+    }
+}