软件包名可配

.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +1,11 @@
 <component name="InspectionProjectProfileManager">
   <profile version="1.0">
     <option name="myName" value="Project Default" />
+    <inspection_tool class="DuplicatedCode" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <Languages>
+        <language minSize="168" name="Rust" />
+      </Languages>
+    </inspection_tool>
     <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ignoredPackages">
         <value>

Cargo.toml

@@ -16,5 +16,5 @@ crossbeam = "0.8"
 
 
 [package.metadata.windows]
-link-args=["/SUBSYSTEM:WINDOWS"]
-subsystem="windows"
+link-args = ["/SUBSYSTEM:windows", "/ENTRY:mainCRTStartup"]
+subsystem = "windows"

src/download_wrapper.rs

@@ -1,9 +1,9 @@
 use crate::download_wrapper::DownloadError::JlinkNotFindError;
-use anyhow::Error;
+use std::fmt::Display;
 use std::fs;
-use std::path::{Path, PathBuf};
-use std::process::Command;
 use std::io::Write;
+use std::path::PathBuf;
+use std::process::Command;
 
 pub struct DownloadWrapper {
     commander_path: PathBuf,
@@ -20,13 +20,14 @@ pub enum DownloadType {
     Rail,
 }
 
-impl ToString for DownloadType {
-    fn to_string(&self) -> String {
-        match self {
+impl Display for DownloadType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let str = match self {
             DownloadType::Bootloader => "BootLoader".to_string(),
             DownloadType::App => "App".to_string(),
             DownloadType::Rail => "Rail".to_string(),
-        }
+        };
+        write!(f, "{}", str)
     }
 }
 
@@ -43,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"),
-            app_name: String::from("RAWM00-2-0-0_silicon-wisun_APP-V1_D20240927.s37"),
-            rail_name: String::from("rail_soc_railtest_sisdk.s37"),
+            bootloader_name,
+            app_name,
+            rail_name
         }
     }
 }
@@ -133,26 +148,28 @@ impl DownloadWrapper {
             .collect::<Vec<&&str>>()
             .is_empty()
             || result
-            .iter()
-            .filter(|&&str| str.trim().contains("successfully"))
-            .collect::<Vec<&&str>>()
-            .is_empty()
+                .iter()
+                .filter(|&&str| str.trim().contains("successfully"))
+                .collect::<Vec<&&str>>()
+                .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(res) => {
-                    Ok(result_str)
-                }
-                Err(e) => {
-                    Err(DownloadError::DownloadBootloaderError)
-                }
+                Ok(_) => Ok(result_str),
+                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 => {
@@ -184,26 +201,24 @@ impl DownloadWrapper {
             .collect::<Vec<&&str>>()
             .is_empty()
             || result
-            .iter()
-            .filter(|&&str| str.trim().contains("successfully"))
-            .collect::<Vec<&&str>>()
-            .is_empty()
+                .iter()
+                .filter(|&&str| str.trim().contains("successfully"))
+                .collect::<Vec<&&str>>()
+                .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(res) => {
-                    Ok(result_str)
-                }
-                Err(e) => {
-                    Err(DownloadError::DownloadBootloaderError)
-                }
+                Ok(_) => Ok(result_str),
+                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");
         }
@@ -212,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 {
-            use crate::download_wrapper::DownloadType;
-            use crate::download_wrapper::DownloadWrapper;
+mod test {
+    use crate::download_wrapper::DownloadType;
+    use crate::download_wrapper::DownloadWrapper;
 
-            #[test]
-            fn test_download_wrapper() {
-                let dw = DownloadWrapper::new();
-                println!("{:?}", dw.commander_path);
-                println!("{:?}", dw.bin_path);
-                println!("{:?}", dw.bootloader_name);
-                println!("{:?}", dw.app_name);
-                println!("{:?}", dw.rail_name);
-            }
+    #[test]
+    fn test_download_wrapper() {
+        let dw = DownloadWrapper::new();
+        println!("{:?}", dw.commander_path);
+        println!("{:?}", dw.bin_path);
+        println!("{:?}", dw.bootloader_name);
+        println!("{:?}", dw.app_name);
+        println!("{:?}", dw.rail_name);
+    }
 
-            #[test]
-            fn test_check_jlink() {
-                let dw = DownloadWrapper::new();
-                let result = dw.check_jlink();
-                assert_eq!(result.is_ok(), true);
-                println!("ids:{:?}", result.unwrap());
-            }
+    #[test]
+    fn test_check_jlink() {
+        let dw = DownloadWrapper::new();
+        let result = dw.check_jlink();
+        assert_eq!(result.is_ok(), true);
+        println!("ids:{:?}", result.unwrap());
+    }
 
-            #[test]
-            fn test_check_device() {
-                let dw = DownloadWrapper::new();
-                let result = dw.check_device();
-                assert_eq!(result.is_ok(), true);
-            }
+    #[test]
+    fn test_check_device() {
+        let dw = DownloadWrapper::new();
+        let result = dw.check_device();
+        assert_eq!(result.is_ok(), true);
+    }
 
-            #[test]
-            fn test_erase_device() {
-                let dw = DownloadWrapper::new();
-                let result = dw.erase();
-                assert_eq!(result.is_ok(), true);
-            }
+    #[test]
+    fn test_erase_device() {
+        let dw = DownloadWrapper::new();
+        let result = dw.erase(Some("111".to_string()));
+        assert_eq!(result.is_ok(), true);
+    }
 
-            #[test]
-            fn test_download_bootloader() {
-                let dw = DownloadWrapper::new();
-                let result = dw.download(DownloadType::Bootloader);
-                assert_eq!(result.is_ok(), true);
-            }
+    #[test]
+    fn test_download_bootloader() {
+        let dw = DownloadWrapper::new();
+        let result = dw.download(DownloadType::Bootloader, Some("111".to_string()));
+        assert_eq!(result.is_ok(), true);
+    }
 
-            #[test]
-            fn test_download_app() {
-                let dw = DownloadWrapper::new();
-                let result = dw.download(DownloadType::App);
-                assert_eq!(result.is_ok(), true);
-            }
+    #[test]
+    fn test_download_app() {
+        let dw = DownloadWrapper::new();
+        let result = dw.download(DownloadType::App, Some("111".to_string()));
+        assert_eq!(result.is_ok(), true);
+    }
 
-            #[test]
-            fn test_download_rail() {
-                let dw = DownloadWrapper::new();
-                let result = dw.download(DownloadType::Rail);
-                assert_eq!(result.is_ok(), true);
-            }
-        }
+    #[test]
+    fn test_download_rail() {
+        let dw = DownloadWrapper::new();
+        let result = dw.download(DownloadType::Rail, Some("111".to_string()));
+        assert_eq!(result.is_ok(), true);
+    }
+}

src/main.rs

@@ -1,3 +1,5 @@
+#![windows_subsystem = "windows"]
+
 mod download_wrapper;
 mod mes_service;
 
@@ -12,12 +14,13 @@ use iced::widget::text_editor::Edit;
 use iced::widget::{
     button, checkbox, column, container, progress_bar, radio, row, text_editor, text_input,
 };
-use iced::{event, time, window, Background, Border, Color, Element, Event, Length, Subscription, Task};
+use iced::{event, time, window, Border, Color, Element, Event, Length, Subscription, Task};
 use serde_json::Map;
 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)
@@ -206,14 +209,15 @@ impl MainWindow {
                 }else{
                     self.result_background = Color::from_rgb8(255, 0,0);
                 }
+                self.label = "".to_string();
                 Task::none()
             }
             Message::WindowEvent(event) => {
                 //println!("{:?}", event);
-                if let Event::Window(window::Event::Opened { position, size }) = event {
+                if let Event::Window(window::Event::Opened { position: _position, size: _size }) = event {
                     println!("Opened");
                     self.read_config();
-                    return Task::none();
+                    return Task::none()
                 };
                 if let Event::Window(window::Event::CloseRequested) = event {
                     println!("Request Close");
@@ -288,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();
@@ -316,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(),
@@ -336,14 +355,14 @@ impl MainWindow {
                 }
             }
             add_log("正在检查JLink连接".to_string());
-            if let Err(e) = download_wrapper.check_jlink() {
+            if let Err(_) = download_wrapper.check_jlink() {
                 add_log("JLink检查失败, 请检查是否安装驱动或连接是否异常".to_string());
                 sender.send(Message::DownloadEnd((label, false))).unwrap();
                 return;
             }
             add_log("JLink检查成功".to_string());
             add_log("正在检查设备连接".to_string());
-            if let Err(e) = download_wrapper.check_device() {
+            if let Err(_) = download_wrapper.check_device() {
                 add_log("设备检查失败, 请检查设备是否连接".to_string());
                 sender.send(Message::DownloadEnd((label, false))).unwrap();
                 return;
@@ -353,14 +372,14 @@ impl MainWindow {
                 DownloadType::Bootloader => {}
                 DownloadType::App => {
                     add_log("正在擦除Flash".to_string());
-                    if let Err(e) = download_wrapper.erase(Some(label.clone())) {
+                    if let Err(_) = download_wrapper.erase(Some(label.clone())) {
                         add_log("擦除失败".to_string());
                         sender.send(Message::DownloadEnd((label, false))).unwrap();
                         return;
                     }
                     add_log("擦除成功".to_string());
                     add_log("正在下载BootLoader".to_string());
-                    if let Err(e) =
+                    if let Err(_) =
                         download_wrapper.download(DownloadType::Bootloader, Some(label.clone()))
                     {
                         add_log("下载BootLoader失败".to_string());
@@ -369,7 +388,7 @@ impl MainWindow {
                     }
                     add_log("下载BootLoader成功".to_string());
                     add_log("正在下载App".to_string());
-                    if let Err(e) = download_wrapper.download(download_type, Some(label.clone())) {
+                    if let Err(_) = download_wrapper.download(download_type, Some(label.clone())) {
                         add_log("下载App失败".to_string());
                         sender.send(Message::DownloadEnd((label, false))).unwrap();
                         return;
@@ -378,7 +397,7 @@ impl MainWindow {
                 }
                 DownloadType::Rail => {
                     add_log("正在下载Rail".to_string());
-                    if let Err(e) = download_wrapper.download(download_type, Some(label.clone())) {
+                    if let Err(_) = download_wrapper.download(download_type, Some(label.clone())) {
                         add_log("下载Rail失败".to_string());
                         sender.send(Message::DownloadEnd((label, false))).unwrap();
                         return;

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') \
-        ON DUPLICATE KEY UPDATE `Barcode` = VALUES(`Barcode`), `IMEI_1` = VALUES(`IMEI_1`), `Station1` = VALUES(`Station1`)"
+                            "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`), `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}'"),
                     (),
                 )?;
             }
@@ -101,8 +127,8 @@ impl MesService {
 
 #[cfg(test)]
 mod test {
-    use crate::download_wrapper::DownloadType;
     use crate::mes_service::MesService;
+    use mysql::prelude::*;
 
     #[test]
     fn test_mes_service() {
@@ -128,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);
+    }
 }