resonite 0.4.0

Resonite's API in rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use serde::{Deserialize, Serialize};
use time::{OffsetDateTime, serde::rfc3339};

#[cfg_attr(
	feature = "borsh",
	derive(borsh::BorshSerialize, borsh::BorshDeserialize)
)]
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
/// A message between two accounts
pub struct Message {
	/// The contents of the message
	#[serde(flatten)]
	pub content: MessageContents,
	/// An UUID prefixed with `MSG-`
	pub id: String,
	#[serde(default)]
	/// If the message was from a migration
	///
	/// Defaults to false if missing
	pub is_migrated: bool,
	#[cfg_attr(
		feature = "borsh",
		borsh(
			serialize_with = "crate::util::borsh::time::ser",
			deserialize_with = "crate::util::borsh::time::de"
		)
	)]
	#[serde(with = "rfc3339")]
	/// When the message was sent
	pub last_update_time: OffsetDateTime,
	/// The owner, so most likely the logged in user
	pub owner_id: crate::id::User,
	#[cfg_attr(
		feature = "borsh",
		borsh(
			serialize_with = "crate::util::borsh::time::optional_ser",
			deserialize_with = "crate::util::borsh::time::optional_de"
		)
	)]
	#[serde(default)]
	#[serde(with = "crate::util::opt_rfc3339")]
	#[serde(skip_serializing_if = "Option::is_none")]
	/// When the message was sent
	pub read_time: Option<OffsetDateTime>,
	/// If the user is focused on this session
	pub recipient_id: crate::id::User,
	#[cfg_attr(
		feature = "borsh",
		borsh(
			serialize_with = "crate::util::borsh::time::ser",
			deserialize_with = "crate::util::borsh::time::de"
		)
	)]
	#[serde(with = "rfc3339")]
	/// When the message was sent
	pub send_time: OffsetDateTime,
	/// The sender of the message
	pub sender_id: crate::id::User,
	#[serde(skip_serializing_if = "Option::is_none")]
	/// The user session ID of the sender of the message
	pub sender_user_session_id: Option<crate::id::UserSession>,
}

impl Message {
	#[must_use]
	/// Gets the ID recipient's if the owners ID doesn't match it, otherwise the
	/// sender's id is returned
	pub fn non_owner_id(&self) -> &crate::id::User {
		if self.owner_id == self.recipient_id {
			&self.sender_id
		} else {
			&self.recipient_id
		}
	}

	#[cfg(feature = "rand_util")]
	#[must_use]
	/// Creates a new message with a random id and time set to now
	pub fn new(
		content: MessageContents, owner_and_sender: crate::id::User,
		sender_user_session_id: Option<crate::id::UserSession>,
		recipient: crate::id::User,
	) -> Self {
		let now = OffsetDateTime::now_utc();

		Self {
			owner_id: owner_and_sender.clone(),
			sender_id: owner_and_sender,
			recipient_id: recipient,
			content,
			id: Self::new_id(),
			sender_user_session_id,
			send_time: now,
			last_update_time: now,
			read_time: None,
			is_migrated: false,
		}
	}

	#[cfg(feature = "rand_util")]
	#[must_use]
	/// Generates a new pseudorandom ID for a message
	pub fn new_id() -> String {
		"MSG-".to_owned() + &crate::util::random_ascii_string(24)
	}
}

#[repr(u8)]
#[cfg_attr(
	feature = "borsh",
	derive(borsh::BorshSerialize, borsh::BorshDeserialize)
)]
#[cfg_attr(feature = "borsh", borsh(use_discriminant = true))]
#[serde_with::serde_as]
#[allow(clippy::module_name_repetitions)]
#[derive(
	Debug, Clone, PartialEq, Serialize, Deserialize, strum::VariantNames,
)]
#[serde(tag = "messageType", content = "content")]
/// The contents of a message combined with the `MessageType`
pub enum MessageContents {
	/// A generic object Record message
	Object(
		#[serde_as(as = "serde_with::json::JsonString")] Box<crate::model::Record>,
	) = 3,
	/// Invite to a session
	SessionInvite(
		#[serde_as(as = "serde_with::json::JsonString")]
		Box<crate::model::SessionInfo>,
	) = 2,
	/// Voice recording
	Sound(
		#[serde_as(as = "serde_with::json::JsonString")] Box<crate::model::Record>,
	) = 1,
	/// A normal message
	Text(String) = 0,
}