Fix bug when selecting to_* fields

ps-core/src/model/link.rs

@@ -151,8 +151,20 @@ fn inner_loop<Context: Send + Sync + 'static, Database: DatabaseQuery>(
     output_sender: Sender<Result<Response<Context>>>,
 ) -> Result<()> {
     loop {
-        let (query, context) = input_receiver.recv()?;
-        let result = database.query(&query)?;
+        let (query, context) = match input_receiver.recv() {
+            Ok(n) => n,
+            Err(e) => {
+                tracing::error!("Could not receive: {:?}", &e);
+                continue;
+            }
+        };
+        let result = match database.query(&query) {
+            Ok(n) => n,
+            Err(e) => {
+                tracing::error!("Query Error: {:?}", &e);
+                continue;
+            }
+        };
         let response = process_query(query, result, context);
         output_sender.send(response)?;
     }

ps-database/src/conversion.rs

@@ -65,11 +65,16 @@ pub fn value_from_field<'stmt>(field: &Field, row: &Row<'stmt>) -> Result<ValueF
     use Field::*;
     // Use type safety when unpacking
     match field {
-        Path | SenderDomain | SenderLocalPart | SenderName | ToGroup | ToName | ToAddress
-        | Subject => {
+        // String Fields
+        Path | SenderDomain | SenderLocalPart | SenderName | Subject => {
             let string: String = row.get::<&str, String>(field.as_str())?;
             Ok(ValueField::string(field, &string))
         }
+        // Optional String Fields
+        ToGroup | ToName | ToAddress => {
+            let string: Option<String> = row.get::<&str, Option<String>>(field.as_str())?;
+            Ok(ValueField::string(field, &string.unwrap_or("".to_string())))
+        }
         Year | Month | Day | Timestamp => {
             return Ok(ValueField::usize(
                 field,

ps-database/src/db.rs

@@ -230,8 +230,8 @@ fn insert_mail(statement: &mut Statement, entry: &EmailEntry) -> Result<()> {
     let day = entry.datetime.date().day();
     let timestamp = entry.datetime.timestamp();
     let e = entry;
-    let to_name = e.to_first.as_ref().map(|e| &e.0);
-    let to_address = e.to_first.as_ref().map(|e| &e.1);
+    let to_name = e.to_first.as_ref().map(|e| &e.1);
+    let to_address = e.to_first.as_ref().map(|e| &e.0);
     let meta_tags = e.meta.as_ref().map(|e| e.tags_string());
     let meta_is_seen = e.meta.as_ref().map(|e| e.is_seen);
     let p = params![

ps-importer/src/formats/shared/database.rs

@@ -53,11 +53,12 @@ pub fn into_database<Mail: ParseableEmail + 'static, Database: DatabaseLike + 's
                 Ok(mail) => sender.send(DBMessage::Mail(Box::new(mail))),
                 Err(e) => sender.send(DBMessage::Error(e)),
             } {
-                tracing::error!("Error Inserting into Database: {:?}", &e);
+                tracing::info!("Error Inserting into Database: {:?}", &e);
+                return;
             }
             // Signal the write
             if let Err(e) = tx.send(Message::WriteOne) {
-                tracing::error!("Channel Failure: {:?}", &e);
+                tracing::info!("Channel Failure: {:?}", &e);
             }
         });
 

ps-importer/src/formats/shared/parse.rs

@@ -178,8 +178,15 @@ fn emaildatetime_to_chrono(
     datetime: Option<&mail_parser::DateTime>,
 ) -> Option<chrono::DateTime<Utc>> {
     let dt = datetime?;
-    Some(
-        Utc.ymd(dt.year as i32, dt.month as u32, dt.day as u32)
-            .and_hms(dt.hour as u32, dt.minute as u32, dt.second as u32),
-    )
+    match Utc
+        .ymd_opt(dt.year as i32, dt.month as u32, dt.day as u32)
+        .and_hms_opt(dt.hour as u32, dt.minute as u32, dt.second as u32)
+    {
+        chrono::LocalResult::Ambiguous(n, _) => Some(n),
+        chrono::LocalResult::Single(n) => Some(n),
+        chrono::LocalResult::None => {
+            tracing::error!("Could not convert date {:?}", dt);
+            return None;
+        }
+    }
 }