jscontact: add {created,updated} fields

epilys · epilys · commit a6c7621ce322 · 2024-10-05T09:31:17.000+03:00
Signed-off-by: Manos Pitsidianakis &lt;manos@pitsidianak.is&gt;
diff --git a/melib/src/contacts/jscontact.rs b/melib/src/contacts/jscontact.rs
@@ -20,8 +20,6 @@
 //
 // SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
 
-use std::hash::Hasher;
-
 use crate::{
     contacts::{Card, CardId},
     error::Result,
@@ -41,7 +39,7 @@ impl JSContactVersion for JSContactVersion1 {}
 
 pub struct CardDeserializer;
 
-#[derive(Debug)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct JSContact<T: JSContactVersion>(
     json_types::JsonCardValue,
     std::marker::PhantomData<*const T>,
@@ -68,25 +66,34 @@ impl<V: JSContactVersion> TryInto<Card> for JSContact<V> {
     type Error = crate::error::Error;
 
     fn try_into(self) -> Result<Card> {
+        let json_types::JsonCardValue {
+            uid, name, email, ..
+        } = self.0;
         let mut card = Card::new();
-        card.set_id(CardId::Hash({
-            let mut hasher = std::collections::hash_map::DefaultHasher::new();
-            hasher.write(self.0.uid.as_bytes());
-            hasher.finish()
-        }));
-        card.set_name(self.0.name.full.clone().unwrap_or_default());
-        if let Some(e) = self.0.email.get_index(0) {
+        card.set_id(CardId::from(uid));
+        if let Some(name) = name.full {
+            card.set_name(name);
+        }
+        if let Some(e) = email.get_index(0) {
             card.set_email(e.1.address.to_string());
         }
 
         Ok(card)
     }
 }
 
+impl From<json_types::JsonCardValue> for JSContact<JSContactVersion1> {
+    fn from(val: json_types::JsonCardValue) -> Self {
+        Self(val, std::marker::PhantomData::<*const JSContactVersion1>)
+    }
+}
+
 pub mod json_types {
     use indexmap::IndexMap;
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+    use crate::utils::datetime::UnixTimestamp;
+
     macro_rules! impl_json_type_struct_serde {
         ($t:tt, $s:literal) => {
             #[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
@@ -155,6 +162,44 @@ pub mod json_types {
         }
     }
 
+    #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+    pub struct UTCDateTime(pub UnixTimestamp);
+
+    impl Serialize for UTCDateTime {
+        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            use crate::utils::datetime::{formats::RFC3339_DATETIME_Z, timestamp_to_string_utc};
+
+            serializer.serialize_str(&timestamp_to_string_utc(
+                self.0,
+                Some(RFC3339_DATETIME_Z),
+                true,
+            ))
+        }
+    }
+
+    impl<'de> Deserialize<'de> for UTCDateTime {
+        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            use crate::utils::datetime::{
+                formats::RFC3339_DATETIME_Z, parse_timestamp_from_string,
+            };
+
+            let s = <&'de str>::deserialize(deserializer)?;
+            let Ok((_, val)) = parse_timestamp_from_string(s, RFC3339_DATETIME_Z) else {
+                return Err(serde::de::Error::custom(format!(
+                    r#"expected UTCDateTime value, found `{}`"#,
+                    s
+                )));
+            };
+            Ok(Self(val))
+        }
+    }
+
     #[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
     #[serde(rename_all = "lowercase")]
     pub enum JsonCardKind {
@@ -181,7 +226,14 @@ pub mod json_types {
         pub version: JsonCardVersion,
         pub uid: String,
         #[serde(default, skip_serializing_if = "Option::is_none")]
-        pub created: Option<String>,
+        pub created: Option<UTCDateTime>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub updated: Option<UTCDateTime>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        /// The language tag, as defined in `RFC5646`, that best describes the
+        /// language used for text in the card, optionally including
+        /// additional information such as the script.
+        pub language: Option<String>,
         #[serde(default, skip_serializing_if = "Option::is_none")]
         pub kind: Option<JsonCardKind>,
         pub name: JsonCardName,
@@ -220,12 +272,17 @@ pub mod json_types {
 
     #[test]
     fn test_addressbook_jscontact() {
+        use super::JSContactVersion1;
+        use crate::contacts::{jscontact::JSContact, Card, CardId};
+
         assert_eq!(
             JsonCardValue {
                 __type: JsonCardType,
                 version: JsonCardVersion::_1_0,
                 uid: "22B2C7DF-9120-4969-8460-05956FE6B065".to_string(),
                 created: None,
+                updated: None,
+                language: None,
                 kind: Some(JsonCardKind::Individual),
                 name: JsonCardName {
                     __type: None,
@@ -264,5 +321,52 @@ pub mod json_types {
             )
             .unwrap(),
         );
+        assert_eq!(
+            Card {
+                last_edited: 1727155810,
+                ..<JSContact<JSContactVersion1> as std::convert::TryInto<Card>>::try_into(
+                    JSContact::<JSContactVersion1>::from(
+                        serde_json::from_str::<JsonCardValue>(
+                            r#"{
+            "@type": "Card",
+            "version": "1.0",
+            "uid": "22B2C7DF-9120-4969-8460-05956FE6B065",
+            "kind": "individual",
+            "email": {
+                "main": {
+                    "address": "user@example.com"
+                }
+            },
+            "name": {
+                "components": [],
+                "full": "full_name",
+                "isOrdered": true
+            }
+        }"#
+                        )
+                        .unwrap()
+                    )
+                )
+                .unwrap()
+            },
+            Card {
+                id: CardId::Uuid(
+                    uuid::Uuid::try_parse("22B2C7DF-9120-4969-8460-05956FE6B065").unwrap()
+                ),
+                title: "".into(),
+                name: "full_name".into(),
+                additionalname: "".into(),
+                name_prefix: "".into(),
+                name_suffix: "".into(),
+                birthday: None,
+                email: "user@example.com".into(),
+                url: "".into(),
+                key: "".into(),
+                color: 0,
+                last_edited: 1727155810,
+                extra_properties: indexmap::indexmap! {},
+                external_resource: false
+            },
+        );
     }
 }
diff --git a/melib/src/contacts/mod.rs b/melib/src/contacts/mod.rs
@@ -67,7 +67,7 @@ impl From<String> for CardId {
     fn from(s: String) -> Self {
         use std::{collections::hash_map::DefaultHasher, str::FromStr};
 
-        if let Ok(u) = Uuid::parse_str(s.as_str()) {
+        if let Ok(u) = Uuid::try_parse(s.as_str()) {
             Self::Uuid(u)
         } else if let Ok(num) = u64::from_str(s.trim()) {
             Self::Hash(num)
diff --git a/melib/src/utils/datetime.rs b/melib/src/utils/datetime.rs
@@ -49,8 +49,12 @@ use crate::error::{ErrorKind, Result, ResultIntoError};
 pub type UnixTimestamp = u64;
 
 pub mod formats {
+    //! Format string constants for use with `strftime`/`strptime`.
+
     /// `<date>`T`<time>`
     pub const RFC3339_DATETIME: &str = "%Y-%m-%dT%H:%M:%S\0";
+    /// `<date>`T`<time>Z`
+    pub const RFC3339_DATETIME_Z: &str = "%Y-%m-%dT%H:%M:%SZ\0";
     /// `<date>`T`<time>`
     pub const RFC3339_DATETIME_AND_SPACE: &str = "%Y-%m-%d %H:%M:%S\0";
 
