Update

Author: liulifox233

.github/workflows/rust.yml

@@ -20,7 +20,10 @@ jobs:
       run: cargo build --release --verbose
     - uses: actions/upload-artifact@v4
       with:
-        path: |
-          target/release/check-cmt
-          target/release/check-pr
+        name: check-cmt
+        path: target/release/check-cmt
+    - uses: actions/upload-artifact@v4
+      with:
+        name: check-pr
+        path: target/release/check-pr
 

README.md

@@ -5,7 +5,13 @@
 
 ## Usage
 
+First, compile the binaries of PDFium and place them in the `./lib` directory with the appropriate filename, such as `libpdfium.xxx`.
+
+Then
+```sh
+cargo run --bin check-pr -d "./path_you_want_to_check" ...
+```
+Or
 ```sh
-cargo install --path .
-byrdocs-check -d "./path_you_want_to_check"
+cargo run --bin check-cmt -d "./path_you_want_to_check" ...
 ```

check-cmt/src/main.rs

@@ -219,21 +219,20 @@ async fn get_files_need_update(s3_obj: &Vec<Object>) -> anyhow::Result<HashSet<S
             webp_files.insert(key[..32].to_string());
         }
     }
-    println!("Jpg files: {:?}", jpg_files);
-    println!("Webp files: {:?}", webp_files);
+
     let mut raw_files = HashSet::new();
     for item in s3_obj {
         let key = item.key.clone().unwrap_or_default();
         if key.ends_with(".pdf") || key.ends_with(".zip") {
             raw_files.insert(key[..32].to_string());
         }
     }
-    println!("Raw files: {:?}", raw_files);
+
     let jpg_diff = raw_files.difference(&jpg_files).cloned().collect::<HashSet<_>>();
     let webp_diff = raw_files.difference(&webp_files).cloned().collect::<HashSet<_>>();
     let files_need_update = jpg_diff.union(&webp_diff).cloned().collect::<HashSet<_>>();
     //Get files need to update
-    println!("Files need to update: {:?}", files_need_update);
+    println!("Files need to update: {:#?}", files_need_update);
     Ok(files_need_update)
 }
 
@@ -268,6 +267,7 @@ async fn generate_jpg_files() -> anyhow::Result<()> {
         Pdfium::bind_to_library(Pdfium::pdfium_platform_library_name_at_path("./lib"))
             .or_else(|_| Pdfium::bind_to_system_library())?,
     );
+    let mut error_count = 0;
     for file in dir.read_dir()? {
         let file = file?;
         let path = file.path();
@@ -288,15 +288,22 @@ async fn generate_jpg_files() -> anyhow::Result<()> {
                 )?;
             }else{
                 println!("Failed to load pdf: {:?}", path.to_string_lossy().as_ref());
+                error_count += 1;
             };
         }
     }//Generate jpg files
+
+    if error_count > 0 {
+        return Err(anyhow::anyhow!("Failed to load {} pdf files", error_count));
+    }
+
     println!("jpg Files generated");
     Ok(())
 }
 
 async fn generate_webp_files() -> anyhow::Result<()> {
     let dir = Path::new("./tmp2");
+    let mut count = 0;
     for file in dir.read_dir()? {
         let file = file?;
         let path = file.path();
@@ -316,11 +323,11 @@ async fn generate_webp_files() -> anyhow::Result<()> {
 
             let file_path = Path::new("./tmp3").join(format!("{}.webp", path.file_stem().unwrap().to_str().unwrap()));
             let mut file = File::create(file_path.clone()).await?;
-            println!("file: {:#?}", file_path.to_string_lossy());
             file.write_all(&webp_data).await?;
+            count += 1;
         }
     }//Generate jpg files
-    println!("webp Files generated");
+    println!("webp Files generated: {}", count);
     Ok(())
 }
 

check-pr/src/main.rs

@@ -1,12 +1,15 @@
-use std::path::Path;
+use anyhow;
+use regex;
 use rusoto_core::HttpClient;
 use rusoto_s3::S3;
-use tokio::{self, io::{AsyncReadExt, BufReader}};
-use regex;
-use serde_yaml;
 use serde;
-use anyhow;
+use serde_yaml;
+use std::path::Path;
 use structopt::StructOpt;
+use tokio::{
+    self,
+    io::{AsyncReadExt, BufReader},
+};
 
 #[derive(StructOpt)]
 struct Input {
@@ -18,15 +21,25 @@ struct Input {
     backend_url: String,
     #[structopt(short = "t", long = "token", help = "Token", required = true)]
     backend_token: String,
-    #[structopt(short = "a", long = "ACCESS_KEY_ID", help = "ACCESS_KEY_ID", required = true)]
+    #[structopt(
+        short = "a",
+        long = "ACCESS_KEY_ID",
+        help = "ACCESS_KEY_ID",
+        required = true
+    )]
     assess_key_id: String,
-    #[structopt(short = "s", long = "SECRET_ACCESS_KEY", help = "SECRET_ACCESS_KEY", required = true)]
+    #[structopt(
+        short = "s",
+        long = "SECRET_ACCESS_KEY",
+        help = "SECRET_ACCESS_KEY",
+        required = true
+    )]
     secret_access_key: String,
     #[structopt(short = "c", long = "bucket", help = "bucket name", required = true)]
     bucket: String,
 }
 
-#[derive(serde::Deserialize)]
+#[derive(serde::Deserialize, Debug)]
 enum Type {
     #[serde(rename = "test")]
     Test,
@@ -36,26 +49,25 @@ enum Type {
     Doc,
 }
 
-#[derive(serde::Deserialize)]
+#[derive(serde::Deserialize, Debug)]
 #[serde(untagged)]
 enum Data {
     Test(Test),
     Book(Book),
     Doc(Doc),
-    
 }
 
-#[derive(serde::Deserialize)]
+#[derive(serde::Deserialize, Debug)]
 #[allow(dead_code)]
 struct MetaData {
     id: String,
     url: String,
     #[serde(rename = "type")]
     type_: Type,
-    data: Data
+    data: Data,
 }
 
-#[derive(serde::Deserialize)]
+#[derive(serde::Deserialize, Debug)]
 #[allow(dead_code)]
 struct Test {
     title: String,
@@ -66,15 +78,15 @@ struct Test {
     content: Vec<String>,
 }
 
-#[derive(serde::Deserialize)]
+#[derive(serde::Deserialize, Debug)]
 #[allow(dead_code)]
 struct Course {
     #[serde(rename = "type")]
     type_: Option<String>,
     name: Option<String>,
 }
 
-#[derive(serde::Deserialize)]
+#[derive(serde::Deserialize, Debug)]
 #[allow(dead_code)]
 struct Book {
     title: String,
@@ -86,7 +98,7 @@ struct Book {
     filetype: String,
 }
 
-#[derive(serde::Deserialize)]
+#[derive(serde::Deserialize, Debug)]
 #[allow(dead_code)]
 struct Doc {
     title: String,
@@ -95,7 +107,7 @@ struct Doc {
     content: Vec<DocContent>,
 }
 
-#[derive(serde::Deserialize)]
+#[derive(serde::Deserialize, Debug)]
 #[serde(rename_all = "PascalCase")]
 enum DocContent {
     思维导图,
@@ -146,7 +158,10 @@ async fn main() -> anyhow::Result<()> {
 
     let end_point = input.s3_url;
     let http_client = HttpClient::new()?;
-    let credentials = rusoto_core::credential::StaticProvider::new_minimal(input.assess_key_id, input.secret_access_key);
+    let credentials = rusoto_core::credential::StaticProvider::new_minimal(
+        input.assess_key_id,
+        input.secret_access_key,
+    );
     let region = rusoto_core::Region::Custom {
         name: "byr".to_owned(),
         endpoint: end_point,
@@ -157,25 +172,41 @@ async fn main() -> anyhow::Result<()> {
         ..Default::default()
     };
     let result = s3_client.list_objects_v2(request).await?;
-    let s3_file_list = result.contents.unwrap().iter().map(|item| item.key.clone().unwrap()).collect::<Vec<_>>();
+    let s3_file_list = result
+        .contents
+        .unwrap()
+        .iter()
+        .map(|item| item.key.clone().unwrap())
+        .collect::<Vec<_>>();
 
     let backend_client = reqwest::Client::new();
-    let temp_files = backend_client.get(format!("{}/api/file/notPublished", input.backend_url))
+    let temp_files = backend_client
+        .get(format!("{}/api/file/notPublished", input.backend_url))
         .bearer_auth(input.backend_token)
         .send()
         .await?
         .json::<ApiResult>()
         .await?;
 
+    let mut success_book = 0;
+    let mut success_test = 0;
+    let mut success_doc = 0;
+    let mut total = 0;
     let dir_path = Path::new(&input.dir);
+    
     for entry in dir_path.read_dir()? {
+        total += 1;
         let entry = entry?;
+        if !entry.file_name().to_str().unwrap().ends_with(".yml") {
+            continue;
+        }
         let path = entry.path();
         if path.is_file() {
-
             let file = std::fs::File::open(&path)?;
             let metadata: MetaData = serde_yaml::from_reader(file)?;
-            let url_regex = regex::Regex::new(r"^https://byrdocs\.org/files/[a-fA-F0-9]{32}\.(pdf|zip)$").unwrap();
+            let url_regex =
+                regex::Regex::new(r"^https://byrdocs\.org/files/[a-fA-F0-9]{32}\.(pdf|zip)$")
+                    .unwrap();
             if !url_regex.is_match(&metadata.url) | !metadata.url.contains(metadata.id.as_str()) {
                 println!("Invalid URL or id: {}", path.display());
                 continue;
@@ -190,7 +221,9 @@ async fn main() -> anyhow::Result<()> {
             }
 
             for temp_file in &temp_files.files {
-                if temp_file.file_name.as_str() == format!("{}.pdf", metadata.id) || temp_file.file_name.as_str() == format!("{}.zip", metadata.id) {
+                if temp_file.file_name.as_str() == format!("{}.pdf", metadata.id)
+                    || temp_file.file_name.as_str() == format!("{}.zip", metadata.id)
+                {
                     match temp_file.status {
                         Status::Published => {
                             println!("Published: {}", path.display());
@@ -215,19 +248,28 @@ async fn main() -> anyhow::Result<()> {
                 }
             }
             match metadata.data {
-                Data::Test(test) => {
-                    println!("Test: {}", test.title);
+                Data::Test(_test) => {
+                    success_test += 1;
                 }
-                Data::Book(book) => {
-                    println!("Book: {}", book.title);
+                Data::Book(_book) => {
+                    success_book += 1;
                 }
-                Data::Doc(doc) => {
-                    println!("Doc: {}", doc.title);
+                Data::Doc(_doc) => {
+                    success_doc += 1;
                 }
             }
         }
     }
-
-
+    println!(
+        "Total: {}, Success: {}, Book: {}, Test: {}, Doc: {}",
+        total,
+        success_book + success_test + success_doc,
+        success_book,
+        success_test,
+        success_doc
+    );
+    if total != success_book + success_test + success_doc {
+        return Err(anyhow::anyhow!("Some files are invalid"));
+    }
     Ok(())
-}
+}