Fix mail header

.github/workflows/rust.yml

@@ -5,7 +5,7 @@ on:
   workflow_dispatch:
 
 jobs:
-  package:
+  build:
     strategy:
       matrix:
           platform:
@@ -25,8 +25,6 @@ jobs:
     - uses: dtolnay/rust-toolchain@stable
       with:
         targets: ${{ matrix.platform.target }}
-    - name: Install deb
-      run: cargo install cargo-deb
     - name: Install cross
       if: matrix.platform.use_cross
       run: cargo install cross
@@ -36,6 +34,8 @@ jobs:
     - name: Build Native
       if: ${{ !matrix.platform.use_cross }}
       run: cargo build --release --target ${{ matrix.platform.target }}
+    - name: Install deb
+      run: cargo install cargo-deb
     - name: Create Cross Debian Package
       if: ${{ matrix.platform.use_cross }}
       run: cross deb --no-build --target ${{ matrix.platform.target }} --no-strip
@@ -47,3 +47,16 @@ jobs:
       with:
         name: deb-package-${{ matrix.platform.target }}
         path: target/${{ matrix.platform.target }}/debian/*.deb
+    - name: Create tag
+      run: |
+        TAG=v1.0.${{ github.run_number }}
+        echo "TAG=$TAG" >> $GITHUB_ENV
+        git tag $TAG
+        git push origin $TAG
+    - name: Upload release asset
+      uses: softprops/action-gh-release@v1
+      with:
+        files:  target/${{ matrix.platform.target }}/debian/*.deb
+        tag_name: ${{ env.TAG }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

src/config/mod.rs

@@ -49,20 +49,17 @@ impl Default for Config {
 }
 fn create_gateway() -> Box<dyn Gateway + Send> {
     let sender = Mailbox::new(match env::var("SENDER_NAME") { Ok(x)=> Some(x), _ => None }, env::var("EMAIL").unwrap().parse().unwrap());
+    let default_receiver = match env::var("RECIPIENT")  {
+     Ok(receiver) => Mailbox::new(match env::var("SENDER_NAME") { Ok(x)=> Some(x), _ => None }, receiver.parse().unwrap()),
+     Err(_) => panic!("RECIPIENT environment variable must be set!"),
+    };
     match env::var("ROUTER").unwrap().as_str() {
         "default" => {
-            if let Ok(receiver) = env::var("RECIPIENT") {
-                let receiver = Mailbox::new(match env::var("SENDER_NAME") { Ok(x)=> Some(x), _ => None }, receiver.parse().unwrap());
-                Box::new(DefaultRouter::new(sender, receiver))
-
-            } else {
-                panic!("RECIPIENT environment variable must be set!");
-            }
-
+                Box::new(DefaultRouter::new(sender, default_receiver))
         }
         "sql" => {
             if let Ok(backend) = env::var("SQL_BACKEND") {
-                Box::new(SQLRouter::new(sender, &backend).unwrap())
+                Box::new(SQLRouter::new(sender, default_receiver, &backend).unwrap())
             } else {
                 panic!("SQL_BACKEND environment variable must be set!");
             }

src/modem/mod.rs

@@ -1,6 +1,6 @@
 mod dummy_serial;
 
-use std::io;
+use std::{env, io};
 use std::io::{Read, Write};
 use std::thread::sleep;
 use std::time::Duration;
@@ -26,6 +26,11 @@ pub struct UnparsableATResponse;
 pub struct UnableToSetConfig;
 
 
+enum  Strategy {
+    PULL,
+    WAIT,
+}
+
 pub struct SMS {
     pub received_number: String,
     pub send_number: String,
@@ -288,45 +293,75 @@ impl Drop for Modem {
     }
 }
 
-pub async fn modem_loop(serial_port: SerialPortConfig, sender: Sender<SMS>) -> Result<()> {
-    loop {
-        let mut modem = Modem::new(serial_port.serial_port.as_str(), serial_port.baud_rate)?;
-        modem.load_config(ModemConfig { sms_mode: 1, sms_charset: String::new() }).await?;
+async fn pulling(modem: &mut Modem, sender: &Sender<SMS>) -> Result<()> {
+    modem.load_config(ModemConfig { sms_mode: 1, sms_charset: String::new() }).await?;
 
-        for i in 1..=23 {
-            let sms_res = modem.read_sms(i).await;
-            if let Ok(sms) = sms_res {
-                info!("SMS ready to beam from: {}  {} on {}", sms.send_number, sms.data, sms.time);
+    for i in 1..=23 {
+        let sms_res = modem.read_sms(i).await;
+        if let Ok(sms) = sms_res {
+            info!("SMS ready to beam from: {}  {} on {}", sms.send_number, sms.data, sms.time);
 
-                sender.send(sms).await?;
-                modem.delete_sms(i).await?;
-            }
+            sender.send(sms).await?;
+            modem.delete_sms(i).await?;
         }
-        drop(modem);
-        tokio::time::sleep(Duration::from_millis(300000)).await;
     }
-    /*
 
-        match modem.read() {
-            Ok(ModemStatus::NONE) => info!("Modem continue!"),
-            Ok(ModemStatus::SMS(status)) => {
-                info!("Received SMS in slot: {:?}", status);
-                //modem.load_config(ModemConfig{sms_mode: 1,  sms_charset: String::new()}).await?;
+    Ok(())
+}
+
+async fn waiting(modem: &mut Modem, sender: &Sender<SMS>) -> Result<()> {
+    match modem.read() {
+        Ok(ModemStatus::NONE) => info!("Modem continue!"),
+        Ok(ModemStatus::SMS(status)) => {
+            info!("Received SMS in slot: {:?}", status);
+            //modem.load_config(ModemConfig{sms_mode: 1,  sms_charset: String::new()}).await?;
 
-                let sms = modem.read_sms(status).await?;
-                info!("SMS ready to beam from: {}  {} on {}", sms.send_number, sms.data, sms.time);
+            let sms = modem.read_sms(status).await?;
+            info!("SMS ready to beam from: {}  {} on {}", sms.send_number, sms.data, sms.time);
 
-                sender.send(sms).await?;
-                modem.delete_sms(status).await?;
+            sender.send(sms).await?;
+            modem.delete_sms(status).await?;
+        }
+        Err(e) => {
+            error!("Unknown modem response {}",e);
+            let sms = SMS{received_number: "Error".parse()?, send_number: "Error".parse()?, time: "Now".parse()?, data: format!("There was a error while writing: {}", e), message_type: "Error".parse()? };
+            sender.send(sms).await?;
+            bail!(UnparsableATResponse);
+        },
+        _ => info!("Modem continue!"),
+    }
+    modem.check_power().await?;
+    Ok(())
+}
+
+pub async fn modem_loop(serial_port: SerialPortConfig, sender: Sender<SMS>) -> Result<()> {
+    let pull_time = match env::var("PULL_TIME") {
+        Ok(t) => { info!("To pase {}", t); t.parse::<u64>().unwrap_or(300000) },
+        Err(_) => {
+            info!("Set PULL_TIME to 30000ms");
+            300000
+        },
+    };
+
+    let strategy = match env::var("MODEM_STRAT") {
+        Ok(ref v) if v == "WAIT" => Strategy::WAIT,
+        _ => Strategy::PULL,
+    };
+
+    let mut modem = Modem::new(serial_port.serial_port.as_str(), serial_port.baud_rate)?;
+    modem.load_config(ModemConfig { sms_mode: 1, sms_charset: String::new() }).await?;
+    pulling(&mut modem, &sender).await?;
+
+    loop {
+
+        match strategy {
+            Strategy::WAIT => {
+                waiting(&mut modem, &sender).await?;
+            }
+            Strategy::PULL => {
+                pulling(&mut modem, &sender).await?;
             }
-            Err(e) => {
-                error!("Unknown modem response {}",e);
-                let sms = SMS{received_number: "Error".parse()?, send_number: "Error".parse()?, time: "Now".parse()?, data: format!("There was a error while writing: {}", e), message_type: "Error".parse()? };
-                sender.send(sms).await?;
-                bail!(UnparsableATResponse);
-            },
-            _ => info!("Modem continue!"),
         }
-        modem.check_power().await?;*/
-   // }
+        tokio::time::sleep(Duration::from_millis(pull_time)).await;
+   }
 }

src/router/mod.rs

@@ -29,6 +29,9 @@ pub trait Gateway: Send {
         let msg = msg_build.body(body)?;
         anyhow::Ok(msg)
     }
+    fn gen_header(&self, sms: &SMS, content: &str) -> String {
+        content.replace("%DATE", sms.time.as_str()).replace("%FROM", sms.send_number.as_str())
+    }
 }
 
 
@@ -45,16 +48,11 @@ impl DefaultRouter {
         }
         DefaultRouter {mailbox_sender, mailbox_receiver, content: String::from("Neue SMS von %FROM empfangen um %DATE")}
     }
-
-    fn gen_header(&self, sms: &SMS) -> String {
-        let header = self.content.clone();
-        header.replace("%DATE", sms.time.as_str()).replace("%FROM", sms.send_number.as_str())
-    }
 }
 
 impl Gateway for DefaultRouter {
     fn generate_sms(&self, sms: SMS) -> Option<Message> {
-        match DefaultRouter::generate_email(self.mailbox_sender.clone(), vec![self.mailbox_receiver.clone()], self.gen_header(&sms), sms.data.to_string()) {
+        match DefaultRouter::generate_email(self.mailbox_sender.clone(), vec![self.mailbox_receiver.clone()], self.gen_header(&sms, &self.content), sms.data.to_string()) {
             Ok(mail) => return Some(mail),
             Err(error) => error!("Unable to create mail: {}", error)
         };
@@ -65,20 +63,21 @@ impl Gateway for DefaultRouter {
 pub struct SQLRouter {
     conn: Connection,
     mailbox_sender: Mailbox,
-    header: String
+    header: String,
+    default_mailbox_receiver: Mailbox
 }
 
 impl SQLRouter {
-    pub fn new(mailbox_sender: Mailbox, path_to_database: &str) -> Result<SQLRouter> {
+    pub fn new(mailbox_sender: Mailbox, default_mailbox_receiver: Mailbox, path_to_database: &str) -> Result<SQLRouter> {
         let conn = Connection::open(path_to_database)?;
 
         let stmt: rusqlite::Result<String> = conn.query_one("SELECT content FROM settings WHERE key = 'header'", [], |row| row.get(0));
 
 
         if let Ok(header) = stmt { 
-            anyhow::Ok(SQLRouter {mailbox_sender, conn, header})
+            anyhow::Ok(SQLRouter {mailbox_sender, default_mailbox_receiver, conn, header})
         } else {
-            anyhow::Ok(SQLRouter {mailbox_sender, conn, header:String::from("Neue SMS von %FROM empfangen um %DATE")})
+            anyhow::Ok(SQLRouter {mailbox_sender, default_mailbox_receiver, conn, header: String::from("Neue SMS von %FROM empfangen um %DATE")})
         }
     }
 
@@ -106,9 +105,9 @@ impl SQLRouter {
 impl Gateway for SQLRouter {
     fn generate_sms(&self, sms: SMS) -> Option<Message> {
 
-        let receivers = self.get_receiver(&sms.send_number).unwrap_or(vec![]);
+        let receivers = self.get_receiver(&sms.send_number).unwrap_or(vec![self.default_mailbox_receiver.clone()]);
 
-        match DefaultRouter::generate_email(self.mailbox_sender.clone(), receivers, self.header.clone(), sms.data.to_string()) {
+        match DefaultRouter::generate_email(self.mailbox_sender.clone(), receivers, self.gen_header(&sms, &self.header), sms.data.to_string()) {
             Ok(mail) => return Some(mail),
             Err(error) => error!("Unable to create mail: {}", error)
         };
@@ -117,19 +116,18 @@ impl Gateway for SQLRouter {
 }
 
 
-pub async fn bifroest(scotty: Box<dyn Gateway>, reader: Receiver<SMS>, sender: Sender<Message>)
+pub async fn bifroest(heimdall: Box<dyn Gateway>, reader: Receiver<SMS>, sender: Sender<Message>)
 {
-   // let  = create_gateway();
     info!("Enterprise on command!");
     loop {
         let sms = match reader.recv().await {
             Ok(sms) => sms,
             Err(e) => {error!("unable to receive Data from modem! {}", e); panic!("Unable to receive");}
         };
 
-        if let Some(email) = scotty.generate_sms(sms) {
+        if let Some(email) = heimdall.generate_sms(sms) {
             match sender.send(email).await {
-                Ok(()) => info!("Energize, Scotty"),
+                Ok(()) => info!("Sending Mail"),
                 Err(e) => error!("Unable to send to mail thread: {}", e)
             };
         };