Enum Message 

pub enum Message {
    MessageCreate(MessageCreate),
    ParticipantsLeave(ParticipantsLeave),
    JoinConversation(JoinConversation),
}

Because, for reasons, the Twitter devs decided to create a list of messages that contains one data structure, at the very end, that be not like the others we must leverage a Rust enum

Example

use chrono::{DateTime, NaiveDateTime, Utc};

use twitter_archive::convert::date_time_iso_8601;

use twitter_archive::structs::direct_message_group_headers::Message;

let created_at_string = "2023-08-12T17:10:37.000Z";
let created_at_native_time = NaiveDateTime::parse_from_str(&created_at_string, date_time_iso_8601::FORMAT).unwrap();
let created_at_date_time = DateTime::<Utc>::from_naive_utc_and_offset(created_at_native_time, Utc);

let json = format!(r#"[
  {{
    "messageCreate": {{
      "id": "4444444444444444444",
      "senderId": "222222222",
      "createdAt": "{created_at_string}"
    }}
  }},
  {{
    "messageCreate": {{
      "id": "3333333333333333333",
      "senderId": "111111111",
      "createdAt": "{created_at_string}"
    }}
  }},
  {{
    "participantsLeave": {{
      "userIds": [
        "1234",
        "9876"
      ],
      "createdAt": "{created_at_string}"
    }}
  }},
  {{
    "joinConversation": {{
      "initiatingUserId": "111111111",
      "participantsSnapshot": [
        "222222222",
        "111111111"
      ],
      "createdAt": "{created_at_string}"
    }}
  }}
]"#);

let data: Vec<Message> = serde_json::from_str(&json).unwrap();

// De-serialized properties
assert_eq!(data.len(), 4);

if let Message::MessageCreate(message_create) = &data[0] {
    assert_eq!(message_create.sender_id, "222222222");
    assert_eq!(message_create.id, "4444444444444444444");
    assert_eq!(message_create.created_at, created_at_date_time);
}

if let Message::MessageCreate(message_create) = &data.get(1).unwrap() {
    assert_eq!(message_create.sender_id, "111111111");
    assert_eq!(message_create.id, "3333333333333333333");
    assert_eq!(message_create.created_at, created_at_date_time);
}

if let Message::ParticipantsLeave(message_create) = &data.get(2).unwrap() {
    assert_eq!(message_create.user_ids[0], "1234");
    assert_eq!(message_create.user_ids[1], "9876");
    assert_eq!(message_create.created_at, created_at_date_time);
}

if let Some(Message::JoinConversation(join_conversation)) = &data.last() {
    assert_eq!(join_conversation.initiating_user_id, "111111111");
    assert_eq!(join_conversation.participants_snapshot.len(), 2);
    assert_eq!(join_conversation.participants_snapshot[0], "222222222");
    assert_eq!(join_conversation.participants_snapshot[1], "111111111");
    assert_eq!(join_conversation.created_at, created_at_date_time);
}

// Re-serialize is equivalent to original data without pretty printing
assert_eq!(serde_json::to_string_pretty(&data).unwrap(), json);

Variants

MessageCreate(MessageCreate)

Example JSON data

{
  "id": "1111111111111111111",
  "senderId": "2222",
  "createdAt": "2020-01-20T21:42:09.068Z"
}

ParticipantsLeave(ParticipantsLeave)

Example JSON data

{
  "userIds": [
    "1234",
    "9876"
  ],
  "createdAt": "2020-01-20T21:42:09.068Z"
}

JoinConversation(JoinConversation)

Example JSON data

{
  "initiatingUserId": "1111111111111111111",
  "participantsSnapshot": [
    "2222",
    "3333",
    "4444"
  ],
  "createdAt": "2023-08-12T17:10:37.000Z"
}

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Message

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Message

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Message

fn fmt(&self, _derive_more_display_formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for Message

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.