软件包名可配

src/download_wrapper.rs

@@ -1,9 +1,9 @@
-use std::fmt::Display;
 use crate::download_wrapper::DownloadError::JlinkNotFindError;
+use std::fmt::Display;
 use std::fs;
+use std::io::Write;
 use std::path::PathBuf;
 use std::process::Command;
-use std::io::Write;
 
 pub struct DownloadWrapper {
     commander_path: PathBuf,
@@ -44,13 +44,27 @@ pub enum DownloadError {
 
 impl Default for DownloadWrapper {
     fn default() -> Self {
+        let config_str = fs::read_to_string("config.json").unwrap();
+        let config: serde_json::Value = serde_json::from_str(&config_str).unwrap();
+        let bootloader_name = config["bootloader_name"]
+            .as_str()
+            .unwrap_or("RAWM00-2-0-0_silicon-wisun_bootloader_D20241008.s37")
+            .to_string();
+        let app_name = config["app_name"]
+            .as_str()
+            .unwrap_or("RAWM00-2-0-0_silicon-combine-V1-D20241230-BZ.hex")
+            .to_string();
+        let rail_name = config["rail_name"]
+            .as_str()
+            .unwrap_or("rail_soc_railtest_sisdk(silabs).hex")
+            .to_string();
         Self {
             commander_path: PathBuf::from(std::env::current_dir().unwrap())
                 .join("commander/Simplicity Commander/commander.exe"),
             bin_path: PathBuf::from(std::env::current_dir().unwrap()).join("bin/"),
-            bootloader_name: String::from("RAWM00-2-0-0_silicon-wisun_bootloader_D20241008.s37"),
+            bootloader_name,
-            app_name: String::from("RAWM00-2-0-0_silicon-wisun_APP-V1_D20240927.s37"),
+            app_name,
-            rail_name: String::from("rail_soc_railtest_sisdk.s37"),
+            rail_name
         }
     }
 }
@@ -134,26 +148,28 @@ impl DownloadWrapper {
             .collect::<Vec<&&str>>()
             .is_empty()
             || result
-            .iter()
+                .iter()
-            .filter(|&&str| str.trim().contains("successfully"))
+                .filter(|&&str| str.trim().contains("successfully"))
-            .collect::<Vec<&&str>>()
+                .collect::<Vec<&&str>>()
-            .is_empty()
+                .is_empty()
         {
             Err(DownloadError::EraseError)
         } else {
-            let Some(label) = label else { return Err(DownloadError::NoLabel) };
+            let Some(label) = label else {
+                return Err(DownloadError::NoLabel);
+            };
             match self.save_log(label, result_str.clone()) {
-                Ok(_) => {
+                Ok(_) => Ok(result_str),
-                    Ok(result_str)
+                Err(_) => Err(DownloadError::DownloadBootloaderError),
-                }
-                Err(_) => {
-                    Err(DownloadError::DownloadBootloaderError)
-                }
             }
         }
     }
 
-    pub fn download(&self, download_type: DownloadType, label: Option<String>) -> Result<String, DownloadError> {
+    pub fn download(
+        &self,
+        download_type: DownloadType,
+        label: Option<String>,
+    ) -> Result<String, DownloadError> {
         let mut binding: PathBuf;
         match download_type {
             DownloadType::Bootloader => {
@@ -185,26 +201,24 @@ impl DownloadWrapper {
             .collect::<Vec<&&str>>()
             .is_empty()
             || result
-            .iter()
+                .iter()
-            .filter(|&&str| str.trim().contains("successfully"))
+                .filter(|&&str| str.trim().contains("successfully"))
-            .collect::<Vec<&&str>>()
+                .collect::<Vec<&&str>>()
-            .is_empty()
+                .is_empty()
         {
             Err(DownloadError::DownloadBootloaderError)
         } else {
-            let Some(label) = label else { return Err(DownloadError::NoLabel) };
+            let Some(label) = label else {
+                return Err(DownloadError::NoLabel);
+            };
             match self.save_log(label, result_str.clone()) {
-                Ok(_) => {
+                Ok(_) => Ok(result_str),
-                    Ok(result_str)
+                Err(_) => Err(DownloadError::DownloadBootloaderError),
-                }
-                Err(_) => {
-                    Err(DownloadError::DownloadBootloaderError)
-                }
             }
         }
     }
 
-    fn save_log(& self, label: String, log: String) -> Result<bool, DownloadError> {
+    fn save_log(&self, label: String, log: String) -> Result<bool, DownloadError> {
         if !fs::exists("./log").unwrap() {
             fs::create_dir("./log").expect("Cant Create Log Folder");
         }
@@ -213,66 +227,66 @@ impl DownloadWrapper {
             .append(true)
             .open(format!("./log/{label}.txt"))
             .expect("file not found");
-        writeln!(file, "{}",log).expect("write failed");
+        writeln!(file, "{}", log).expect("write failed");
         Ok(true)
     }
 }
 
 #[cfg(test)]
-        mod test {
+mod test {
-            use crate::download_wrapper::DownloadType;
+    use crate::download_wrapper::DownloadType;
-            use crate::download_wrapper::DownloadWrapper;
+    use crate::download_wrapper::DownloadWrapper;
 
-            #[test]
+    #[test]
-            fn test_download_wrapper() {
+    fn test_download_wrapper() {
-                let dw = DownloadWrapper::new();
+        let dw = DownloadWrapper::new();
-                println!("{:?}", dw.commander_path);
+        println!("{:?}", dw.commander_path);
-                println!("{:?}", dw.bin_path);
+        println!("{:?}", dw.bin_path);
-                println!("{:?}", dw.bootloader_name);
+        println!("{:?}", dw.bootloader_name);
-                println!("{:?}", dw.app_name);
+        println!("{:?}", dw.app_name);
-                println!("{:?}", dw.rail_name);
+        println!("{:?}", dw.rail_name);
-            }
+    }
 
-            #[test]
+    #[test]
-            fn test_check_jlink() {
+    fn test_check_jlink() {
-                let dw = DownloadWrapper::new();
+        let dw = DownloadWrapper::new();
-                let result = dw.check_jlink();
+        let result = dw.check_jlink();
-                assert_eq!(result.is_ok(), true);
+        assert_eq!(result.is_ok(), true);
-                println!("ids:{:?}", result.unwrap());
+        println!("ids:{:?}", result.unwrap());
-            }
+    }
 
-            #[test]
+    #[test]
-            fn test_check_device() {
+    fn test_check_device() {
-                let dw = DownloadWrapper::new();
+        let dw = DownloadWrapper::new();
-                let result = dw.check_device();
+        let result = dw.check_device();
-                assert_eq!(result.is_ok(), true);
+        assert_eq!(result.is_ok(), true);
-            }
+    }
 
-            #[test]
+    #[test]
-            fn test_erase_device() {
+    fn test_erase_device() {
-                let dw = DownloadWrapper::new();
+        let dw = DownloadWrapper::new();
-                let result = dw.erase(Some("111".to_string()));
+        let result = dw.erase(Some("111".to_string()));
-                assert_eq!(result.is_ok(), true);
+        assert_eq!(result.is_ok(), true);
-            }
+    }
 
-            #[test]
+    #[test]
-            fn test_download_bootloader() {
+    fn test_download_bootloader() {
-                let dw = DownloadWrapper::new();
+        let dw = DownloadWrapper::new();
-                let result = dw.download(DownloadType::Bootloader, Some("111".to_string()));
+        let result = dw.download(DownloadType::Bootloader, Some("111".to_string()));
-                assert_eq!(result.is_ok(), true);
+        assert_eq!(result.is_ok(), true);
-            }
+    }
 
-            #[test]
+    #[test]
-            fn test_download_app() {
+    fn test_download_app() {
-                let dw = DownloadWrapper::new();
+        let dw = DownloadWrapper::new();
-                let result = dw.download(DownloadType::App, Some("111".to_string()));
+        let result = dw.download(DownloadType::App, Some("111".to_string()));
-                assert_eq!(result.is_ok(), true);
+        assert_eq!(result.is_ok(), true);
-            }
+    }
 
-            #[test]
+    #[test]
-            fn test_download_rail() {
+    fn test_download_rail() {
-                let dw = DownloadWrapper::new();
+        let dw = DownloadWrapper::new();
-                let result = dw.download(DownloadType::Rail, Some("111".to_string()));
+        let result = dw.download(DownloadType::Rail, Some("111".to_string()));
-                assert_eq!(result.is_ok(), true);
+        assert_eq!(result.is_ok(), true);
-            }
+    }
-        }
+}

src/main.rs

@@ -20,6 +20,7 @@ use std::any::Any;
 use std::fs;
 use std::io::Write;
 use std::sync::{Arc, LazyLock, Mutex};
+use std::thread::sleep;
 
 pub fn main() -> iced::Result {
     iced::application("WisunDownload V0.1", MainWindow::update, MainWindow::view)
@@ -208,6 +209,7 @@ impl MainWindow {
                 }else{
                     self.result_background = Color::from_rgb8(255, 0,0);
                 }
+                self.label = "".to_string();
                 Task::none()
             }
             Message::WindowEvent(event) => {
@@ -290,14 +292,18 @@ impl MainWindow {
 
     fn start(&mut self, sender: Sender<Message>) -> () {
         let mes_config = self.mysql_config.clone();
-        let label = self.label.clone();
+        let mut label = self.label.clone();
         let download_type: DownloadType = self.selection.unwrap();
         let online = self.is_online.clone();
         if label == "" {
             add_log("请输入Label".to_string());
             return;
         }
+        label = label.replace(":", "");
+        label = label.to_uppercase();
+        add_log("Label: ".to_string() + label.as_str());
         std::thread::spawn(move || {
+            sleep(std::time::Duration::from_secs(5));
             let mut download_wrapper = download_wrapper::DownloadWrapper::new();
             let mut mes_service: MesService;
             sender.send(Message::ClearLog).unwrap();
@@ -318,6 +324,17 @@ impl MainWindow {
                     }
                 }
                 add_log("连接成功".to_string());
+                // match mes_service.get_order_number(mes_config.work_order.clone()){
+                //     Ok(batch) => {
+                //         label = batch + &label[label.len() - 6..];
+                //         add_log("获取订单号成功".to_string());
+                //     },
+                //     Err(e) =>{
+                //         add_log(e.to_string());
+                //         sender.send(Message::DownloadEnd((label, false))).unwrap();
+                //         return;
+                //     }
+                // }
                 add_log("正在过站检测".to_string());
                 let check_result = mes_service.check_station(
                     mes_config.work_order.clone(),

src/mes_service.rs

@@ -36,18 +36,40 @@ impl MesService {
         download_type: DownloadType,
     ) -> Result<bool, Error> {
         match download_type {
-            DownloadType::App => Ok(true),
             DownloadType::Rail => {
                 let mut conn = self.pool.get_conn()?;
                 let check_result: Vec<String> = conn.query(format!(
-                    "SELECT `Station1` FROM {work_order} WHERE `Barcode` = {label}"
+                    "SELECT `Station2` FROM `{work_order}` WHERE `Barcode` = '{label}'"
                 ))?;
                 if check_result.is_empty() {
                     return Ok(false);
                 }
                 Ok(check_result[0] == "1")
             }
-            DownloadType::Bootloader => Err(Error::msg("Not implemented yet")),
+            DownloadType::App => {
+                let mut conn = self.pool.get_conn()?;
+                let check_result: Vec<String> = conn.query(format!(
+                    "SELECT `IMEI_1` FROM `{work_order}` WHERE `Barcode` = '{label}';"
+                ))?;
+                if check_result.is_empty() {
+                    Ok(true)
+                } else {
+                    Ok(false)
+                }
+            }
+            DownloadType::Bootloader => Ok(true),
+        }
+    }
+
+    pub fn get_order_number(&self, work_order: String)->Result<String, Error>{
+        let mut conn = self.pool.get_conn()?;
+        let order_number: Vec<String> = conn.query(format!(
+            "SELECT `Batch` FROM wisun_ordertables WHERE `OrderId` = '{work_order}'"
+        ))?;
+        if order_number.is_empty() {
+            Err(Error::msg("No order number found"))
+        }else{
+            Ok(order_number[0].clone())
         }
     }
 
@@ -57,6 +79,7 @@ impl MesService {
         label: String,
         download_type: DownloadType,
     ) -> Result<(), Error> {
+        let time_now = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
         match download_type {
             DownloadType::Bootloader => {}
             DownloadType::App => {
@@ -67,8 +90,11 @@ impl MesService {
                 if let Some(work_order_id) = work_order_id.first() {
                     let _: Vec<String> = conn.exec(
                         format!(
-                            "INSERT INTO {work_order} (`ID`, `Barcode`, `IMEI_1`, `Station1`) VALUES ({work_order_id}, {label}, {label}, '1') \
+                            "INSERT INTO `{work_order}` (`ID`, `Barcode`, `IMEI_1`, `Station1`, `Station1Time`) VALUES ( {work_order_id}, '{label}', '{label}', '1', '{time_now}') \
-        ON DUPLICATE KEY UPDATE `Barcode` = VALUES(`Barcode`), `IMEI_1` = VALUES(`IMEI_1`), `Station1` = VALUES(`Station1`)"
+        ON DUPLICATE KEY UPDATE `Barcode` = VALUES(`Barcode`), `IMEI_1` = VALUES(`IMEI_1`), `Station1` = VALUES(`Station1`), `Station1Time`= VALUES(`Station1Time`)",
+                            work_order_id = work_order_id,
+                            label = label,
+                            time_now = time_now
                         ),
                         ()
                     )?;
@@ -79,7 +105,7 @@ impl MesService {
             DownloadType::Rail => {
                 let mut conn = self.pool.get_conn()?;
                 let _: Vec<String> = conn.exec(
-                    format!("UPDATE {work_order} SET `Station2` = 1 WHERE `Barcode` = {label}"),
+                    format!("UPDATE `{work_order}` SET Station3 = 1, Station3Time='{time_now}' WHERE Barcode = '{label}'"),
                     (),
                 )?;
             }
@@ -102,6 +128,7 @@ impl MesService {
 #[cfg(test)]
 mod test {
     use crate::mes_service::MesService;
+    use mysql::prelude::*;
 
     #[test]
     fn test_mes_service() {
@@ -127,4 +154,24 @@ mod test {
         assert_ne!(work_orders.len(), 0);
         println!("{:?}", work_orders);
     }
+
+    #[test]
+    fn test_check_station() {
+        let mes = MesService::new(
+            "192.168.1.17".to_string(),
+            "3306".to_string(),
+            "root".to_string(),
+            "".to_string(),
+            "MOBILETEK_WISUN".to_string(),
+        );
+        let mut conn = mes.unwrap().pool.get_conn().unwrap();
+        let work_order = "3333";
+        let label = "202400154Y000016";
+        let check_result: Vec<String> = conn
+            .query(format!(
+                "SELECT `COUNT` FROM `{work_order}` WHERE `Barcode` = '{label}';"
+            ))
+            .unwrap();
+        println!("{:?}", check_result);
+    }
 }