Add pre-commit config

2025-12-06 14:45:36 +01:00 · 2023-09-24 22:55:14 +02:00
parent 8fa9684b02
commit 72ca7a07fe
13 changed files with 231 additions and 220 deletions
--- a/src/services/mod.rs
+++ b/src/services/mod.rs
@@ -1,8 +1,8 @@
 pub mod book_library;
 pub mod download_utils;
-pub mod telegram_files;
 pub mod downloader;
 pub mod minio;
+pub mod telegram_files;

 use chrono::Duration;
 use serde::Serialize;
@@ -10,16 +10,25 @@ use tracing::log;

 use crate::{prisma::cached_file, views::Database};

-use self::{download_utils::{DownloadResult, response_to_tempfile}, telegram_files::{download_from_telegram_files, UploadData, upload_to_telegram_files}, downloader::{get_filename, FilenameData, download_from_downloader}, book_library::{get_book, types::BaseBook, get_books}, minio::upload_to_minio};
-
+use self::{
+    book_library::{get_book, get_books, types::BaseBook},
+    download_utils::{response_to_tempfile, DownloadResult},
+    downloader::{download_from_downloader, get_filename, FilenameData},
+    minio::upload_to_minio,
+    telegram_files::{download_from_telegram_files, upload_to_telegram_files, UploadData},
+};

 pub async fn get_cached_file_or_cache(
    object_id: i32,
    object_type: String,
-    db: Database
+    db: Database,
 ) -> Option<cached_file::Data> {
-    let cached_file = db.cached_file()
-        .find_unique(cached_file::object_id_object_type(object_id, object_type.clone()))
+    let cached_file = db
+        .cached_file()
+        .find_unique(cached_file::object_id_object_type(
+            object_id,
+            object_type.clone(),
+        ))
        .exec()
        .await
        .unwrap();
@@ -30,80 +39,77 @@ pub async fn get_cached_file_or_cache(
    }
 }

-
 pub async fn cache_file(
    object_id: i32,
    object_type: String,
-    db: Database
+    db: Database,
 ) -> Option<cached_file::Data> {
    let book = match get_book(object_id).await {
        Ok(v) => v,
        Err(err) => {
            log::error!("{:?}", err);
            return None;
-        },
+        }
    };

-    let downloader_result = match download_from_downloader(
-        book.source.id,
-        book.remote_id,
-        object_type.clone()
-    ).await {
+    let downloader_result =
+        match download_from_downloader(book.source.id, book.remote_id, object_type.clone()).await {
+            Ok(v) => v,
+            Err(err) => {
+                log::error!("{:?}", err);
+                return None;
+            }
+        };
+
+    let UploadData {
+        chat_id,
+        message_id,
+    } = match upload_to_telegram_files(downloader_result, book.get_caption()).await {
        Ok(v) => v,
        Err(err) => {
            log::error!("{:?}", err);
            return None;
-        },
-    };
-
-    let UploadData { chat_id, message_id } = match upload_to_telegram_files(
-        downloader_result,
-        book.get_caption()
-    ).await {
-        Ok(v) => v,
-        Err(err) => {
-            log::error!("{:?}", err);
-            return None;
-        },
+        }
    };

    Some(
-        db
-        .cached_file()
-        .create(
-            object_id,
-            object_type,
-            message_id,
-            chat_id,
-            vec![]
-        )
-        .exec()
-        .await
-        .unwrap()
+        db.cached_file()
+            .create(object_id, object_type, message_id, chat_id, vec![])
+            .exec()
+            .await
+            .unwrap(),
    )
 }

-
 pub async fn download_from_cache(
    cached_data: cached_file::Data,
-    db: Database
+    db: Database,
 ) -> Option<DownloadResult> {
-    let response_task = tokio::task::spawn(download_from_telegram_files(cached_data.message_id, cached_data.chat_id));
-    let filename_task = tokio::task::spawn(get_filename(cached_data.object_id, cached_data.object_type.clone()));
+    let response_task = tokio::task::spawn(download_from_telegram_files(
+        cached_data.message_id,
+        cached_data.chat_id,
+    ));
+    let filename_task = tokio::task::spawn(get_filename(
+        cached_data.object_id,
+        cached_data.object_type.clone(),
+    ));
    let book_task = tokio::task::spawn(get_book(cached_data.object_id));

    let response = match response_task.await.unwrap() {
        Ok(v) => v,
        Err(err) => {
            db.cached_file()
-                .delete(cached_file::object_id_object_type(cached_data.object_id, cached_data.object_type.clone()))
+                .delete(cached_file::object_id_object_type(
+                    cached_data.object_id,
+                    cached_data.object_type.clone(),
+                ))
                .exec()
                .await
                .unwrap();

            log::error!("{:?}", err);
            return None;
-        },
+        }
    };

    let filename_data = match filename_task.await.unwrap() {
@@ -122,14 +128,17 @@ pub async fn download_from_cache(
        }
    };

-    let FilenameData {filename, filename_ascii} = filename_data;
+    let FilenameData {
+        filename,
+        filename_ascii,
+    } = filename_data;
    let caption = book.get_caption();

    Some(DownloadResult {
        response,
        filename,
        filename_ascii,
-        caption
+        caption,
    })
 }

@@ -138,13 +147,13 @@ pub struct FileLinkResult {
    pub link: String,
    pub filename: String,
    pub filename_ascii: String,
-    pub caption: String
+    pub caption: String,
 }

 pub async fn get_download_link(
    object_id: i32,
    object_type: String,
-    db: Database
+    db: Database,
 ) -> Result<Option<FileLinkResult>, Box<dyn std::error::Error + Send + Sync>> {
    let cached_file = match get_cached_file_or_cache(object_id, object_type, db.clone()).await {
        Some(v) => v,
@@ -156,7 +165,12 @@ pub async fn get_download_link(
        None => return Ok(None),
    };

-    let DownloadResult { mut response, filename, filename_ascii, caption } = data;
+    let DownloadResult {
+        mut response,
+        filename,
+        filename_ascii,
+        caption,
+    } = data;

    let tempfile = match response_to_tempfile(&mut response).await {
        Some(v) => v.0,
@@ -172,11 +186,12 @@ pub async fn get_download_link(
        link,
        filename,
        filename_ascii,
-        caption
+        caption,
    }))
 }

-pub async fn get_books_for_update() -> Result<Vec<BaseBook>, Box<dyn std::error::Error + Send + Sync>> {
+pub async fn get_books_for_update(
+) -> Result<Vec<BaseBook>, Box<dyn std::error::Error + Send + Sync>> {
    let mut result: Vec<BaseBook> = vec![];

    let page_size = 50;
@@ -187,12 +202,8 @@ pub async fn get_books_for_update() -> Result<Vec<BaseBook>, Box<dyn std::error:
    let uploaded_gte = subset_3.format("%Y-%m-%d").to_string();
    let uploaded_lte = now.format("%Y-%m-%d").to_string();

-    let first_page = match get_books(
-        1,
-        page_size,
-        uploaded_gte.clone(),
-        uploaded_lte.clone()
-    ).await {
+    let first_page = match get_books(1, page_size, uploaded_gte.clone(), uploaded_lte.clone()).await
+    {
        Ok(v) => v,
        Err(err) => return Err(err),
    };
@@ -203,45 +214,51 @@ pub async fn get_books_for_update() -> Result<Vec<BaseBook>, Box<dyn std::error:
    let page_count = first_page.pages;

    while current_page <= page_count {
-        let page = match get_books(current_page, page_size, uploaded_gte.clone(), uploaded_lte.clone()).await {
+        let page = match get_books(
+            current_page,
+            page_size,
+            uploaded_gte.clone(),
+            uploaded_lte.clone(),
+        )
+        .await
+        {
            Ok(v) => v,
            Err(err) => return Err(err),
        };
        result.extend(page.items);

        current_page += 1;
-    };
+    }

    Ok(result)
 }

-
-pub async fn start_update_cache(
-    db: Database
-) {
+pub async fn start_update_cache(db: Database) {
    let books = match get_books_for_update().await {
        Ok(v) => v,
        Err(err) => {
            log::error!("{:?}", err);
            return;
-        },
+        }
    };

    for book in books {
        'types: for available_type in book.available_types {
            let cached_file = match db
                .cached_file()
-                .find_unique(
-                    cached_file::object_id_object_type(book.id, available_type.clone())
-                )
+                .find_unique(cached_file::object_id_object_type(
+                    book.id,
+                    available_type.clone(),
+                ))
                .exec()
-                .await {
-                    Ok(v) => v,
-                    Err(err) => {
-                        log::error!("{:?}", err);
-                        continue 'types;
-                    }
-                };
+                .await
+            {
+                Ok(v) => v,
+                Err(err) => {
+                    log::error!("{:?}", err);
+                    continue 'types;
+                }
+            };

            if cached_file.is_some() {
                continue 'types;