π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use super::{
AccountSpaceCtx, MESSAGE_KIND_POKE, MESSAGE_KIND_POST_REPLY, MESSAGE_KIND_REGULAR,
retain_content_error, validate_message_payload,
};
use crate::crypto::{
decrypt_secretbox_payload, encrypt_secretbox_payload, generate_key, open_with_keypair,
seal_with_public_key,
};
use crate::error::{Error, Result};
use crate::models::{
ConversationChatSummary, Conversations, Message, MessageActivity, MessageContent, MessagePage,
MessagePayload,
};
use crate::transport::{
ConversationChatSummaryResponse, ConversationsResponse, CreateMessageRequest,
LikeMessageResponse, MessageConversationActivity, MessagePageResponse, MessageResponse,
SpaceActorResponse,
};
use ente_core::b64;
impl AccountSpaceCtx {
pub async fn list_conversations(&self, space_id: &str) -> Result<Conversations> {
let path = format!("/spaces/{space_id}/conversations");
let response: ConversationsResponse = self
.api()
.get(&path)
.send()
.await?
.error_for_status()?
.json()
.await?;
let mut friends = Vec::with_capacity(response.friends.len());
for friend in response.friends {
friends.push(self.open_friend(friend).await?);
}
let mut chat_summaries = std::collections::BTreeMap::new();
for (friend_space_id, summary) in response.chat_summaries {
let mut summary = self.open_conversation_summary(space_id, summary).await?;
if summary.latest_activity.kind == MESSAGE_KIND_POKE {
let mut cursor = None;
let message = loop {
let page = self
.list_message_thread(space_id, &friend_space_id, cursor, Some(100))
.await?;
if let Some(message) = page
.items
.into_iter()
.find(|item| !matches!(item.content, Ok(None)))
{
break Some(message);
}
if page.next_cursor.is_empty() {
break None;
}
cursor = Some(page.next_cursor);
};
let Some(message) = message else {
continue;
};
let outgoing = message.sender_space_id == space_id;
let activity_type = if message.kind == MESSAGE_KIND_POST_REPLY && !outgoing {
"post_reply"
} else {
"message"
};
summary.latest_activity = MessageActivity {
id: format!("{activity_type}:{}", message.message_id),
activity_type: activity_type.into(),
kind: message.kind,
created_at: message.created_at,
outgoing,
message_id: Some(message.message_id),
content: message.content,
reaction: message.reaction,
post_id: message.reply_post_id,
post_space_id: message.reply_post_id.map(|_| message.recipient_space_id),
};
}
chat_summaries.insert(friend_space_id, summary);
}
Ok(Conversations {
friends,
chat_summaries,
latest_post_created_at: response.latest_post_created_at,
})
}
pub async fn list_message_thread(
&self,
viewer_space_id: &str,
space_id: &str,
cursor: Option<String>,
limit: Option<i32>,
) -> Result<MessagePage> {
let mut cursor = cursor;
loop {
let mut query = Vec::new();
if let Some(value) = cursor.filter(|value| !value.trim().is_empty()) {
query.push(("cursor", value));
}
if let Some(value) = limit {
query.push(("limit", value.to_string()));
}
let path = format!("/spaces/{viewer_space_id}/friends/{space_id}/messages");
let page: MessagePageResponse = self
.api()
.get(&path)
.query(&query)
.send()
.await?
.error_for_status()?
.json()
.await?;
let mut items = Vec::with_capacity(page.items.len());
for message in page.items {
let message = self.open_message(viewer_space_id, message).await?;
if message.kind != MESSAGE_KIND_POKE {
items.push(message);
}
}
if !items.is_empty() || page.next_cursor.is_empty() {
return Ok(MessagePage {
items,
next_cursor: page.next_cursor,
});
}
cursor = Some(page.next_cursor);
}
}
async fn open_message(
&self,
viewer_space_id: &str,
message: MessageResponse,
) -> Result<Message> {
let mut kind = message.kind.clone();
let content = if message.is_deleted {
Ok(None)
} else if kind == "friend_added" {
Ok(Some(MessageContent {
text: message.text.clone(),
reply_object_key: None,
}))
} else {
self.decrypt_message(viewer_space_id, &message)
.await
.map(|payload| {
kind = payload.kind;
Some(MessageContent {
text: payload.text,
reply_object_key: payload.reply_object_key,
})
})
};
let content = retain_content_error(content)?;
let reaction = if message.is_deleted {
Ok(None)
} else {
retain_content_error(
self.open_message_reaction(
viewer_space_id,
&message.message_id,
&message.encrypted_reaction,
message.liked,
)
.await,
)?
};
Ok(Message {
reaction,
message_id: message.message_id,
kind,
sender_space_id: message.sender_space_id,
recipient_space_id: message.recipient_space_id,
content,
reply_post_id: message.reply_post_id,
reply_message_id: message.reply_message_id,
liked: message.liked,
viewer_liked: message.viewer_liked,
created_at: message.created_at,
updated_at: message.updated_at,
})
}
async fn open_sent_message(
&self,
space_id: &str,
response: MessageResponse,
) -> Result<Message> {
let message = self.open_message(space_id, response).await?;
let content = message.content?;
if content.is_none() {
return Err(Error::InvalidInput("sent message is deleted".into()));
}
Ok(Message {
content: Ok(content),
..message
})
}
pub(super) async fn open_conversation_summary(
&self,
viewer_space_id: &str,
summary: ConversationChatSummaryResponse,
) -> Result<ConversationChatSummary> {
let mut unread_activities = Vec::with_capacity(summary.unread_activities.len());
for activity in summary.unread_activities {
unread_activities.push(
self.open_message_activity(viewer_space_id, activity)
.await?,
);
}
let latest_activity = self
.open_message_activity(viewer_space_id, summary.latest_activity)
.await?;
for activity in &mut unread_activities {
if activity.id == latest_activity.id && latest_activity.kind == MESSAGE_KIND_POKE {
activity.kind = MESSAGE_KIND_POKE.to_owned();
}
}
unread_activities.retain(|activity| activity.kind != MESSAGE_KIND_POKE);
Ok(ConversationChatSummary {
latest_activity,
unread_activities,
})
}
async fn open_message_activity(
&self,
viewer_space_id: &str,
activity: MessageConversationActivity,
) -> Result<MessageActivity> {
let mut kind = activity.kind.clone();
let content = if activity.message_cipher.trim().is_empty()
|| activity.encrypted_message_key.trim().is_empty()
|| activity.message_id.is_none()
{
Ok(None)
} else {
let server_kind = if kind.trim().is_empty() {
MESSAGE_KIND_REGULAR
} else {
&kind
};
self.decrypt_message_fields(
viewer_space_id,
server_kind,
&activity.encrypted_message_key,
&activity.message_cipher,
)
.await
.map(|payload| {
kind = payload.kind;
Some(MessageContent {
text: payload.text,
reply_object_key: payload.reply_object_key,
})
})
};
let content = retain_content_error(content)?;
let reaction = retain_content_error(
self.open_message_reaction(
viewer_space_id,
activity.message_id.as_deref().unwrap_or_default(),
&activity.encrypted_reaction,
activity.activity_type == "message_like",
)
.await,
)?;
Ok(MessageActivity {
reaction,
id: activity.id,
activity_type: activity.activity_type,
kind,
created_at: activity.created_at,
outgoing: activity.outgoing,
message_id: activity.message_id,
content,
post_id: activity.post_id,
post_space_id: activity.post_space_id,
})
}
pub async fn send_message(
&self,
sender_space_id: &str,
space_id: &str,
text: &str,
) -> Result<Message> {
self.send_direct_message(
sender_space_id,
space_id,
MessagePayload {
version: 1,
kind: MESSAGE_KIND_REGULAR.to_owned(),
text: text.to_owned(),
reply_object_key: None,
},
None,
)
.await
}
async fn send_direct_message(
&self,
sender_space_id: &str,
space_id: &str,
payload: MessagePayload,
notification_kind: Option<&str>,
) -> Result<Message> {
let friend = self
.friend_actor_for_space(sender_space_id, space_id)
.await?;
let request = self
.message_request_for_payload(
sender_space_id,
&friend.public_key,
&payload,
None,
notification_kind.map(str::to_owned),
)
.await?;
let path = format!("/spaces/{sender_space_id}/friends/{space_id}/messages");
let response = self
.api()
.post(&path)
.json(&request)
.send()
.await?
.error_for_status()?
.json()
.await?;
self.open_sent_message(sender_space_id, response).await
}
pub async fn reply_to_message(
&self,
sender_space_id: &str,
space_id: &str,
message_id: &str,
text: &str,
) -> Result<Message> {
let reply_message_id = message_id.trim();
if reply_message_id.is_empty() {
return Err(Error::InvalidInput("message id is required".into()));
}
let friend = self
.friend_actor_for_space(sender_space_id, space_id)
.await?;
let payload = MessagePayload {
version: 1,
kind: MESSAGE_KIND_REGULAR.to_owned(),
text: text.to_owned(),
reply_object_key: None,
};
let request = self
.message_request_for_payload(
sender_space_id,
&friend.public_key,
&payload,
Some(reply_message_id),
None,
)
.await?;
let path = format!("/spaces/{sender_space_id}/friends/{space_id}/messages");
let response = self
.api()
.post(&path)
.json(&request)
.send()
.await?
.error_for_status()?
.json()
.await?;
self.open_sent_message(sender_space_id, response).await
}
pub async fn reply_to_post(
&self,
sender_space_id: &str,
post_space_id: &str,
post_id: i64,
text: &str,
object_key: Option<&str>,
) -> Result<Message> {
let post = self
.get_post_raw(post_space_id, post_id, Some(sender_space_id))
.await?;
if self
.resolve_owned_space_access(&post.space_id)
.await?
.is_some()
{
return Err(Error::InvalidInput("cannot reply to your own post".into()));
}
if post.author.public_key.trim().is_empty() {
return Err(Error::InvalidInput(
"post author public key is missing".into(),
));
}
if let Some(object_key) = object_key
&& !post
.objects
.iter()
.any(|object| object.object_key == object_key)
{
return Err(Error::InvalidInput("photo does not belong to post".into()));
}
let payload = MessagePayload {
version: 1,
kind: MESSAGE_KIND_POST_REPLY.to_owned(),
text: text.to_owned(),
reply_object_key: object_key.map(str::to_owned),
};
let request = self
.message_request_for_payload(
sender_space_id,
&post.author.public_key,
&payload,
None,
None,
)
.await?;
let path = format!("/spaces/{sender_space_id}/posts/{post_id}/reply");
let response = self
.api()
.post(&path)
.json(&request)
.send()
.await?
.error_for_status()?
.json()
.await?;
self.open_sent_message(sender_space_id, response).await
}
async fn decrypt_message(
&self,
space_id: &str,
message: &MessageResponse,
) -> Result<MessagePayload> {
if message.is_deleted {
return Err(Error::InvalidInput("message is deleted".into()));
}
self.decrypt_message_fields(
space_id,
&message.kind,
&message.encrypted_message_key,
&message.message_cipher,
)
.await
}
pub(super) async fn decrypt_message_fields(
&self,
space_id: &str,
kind: &str,
encrypted_message_key: &str,
message_cipher: &str,
) -> Result<MessagePayload> {
let identity = self.space_identity_for(space_id).await?;
let sealed_key = b64::decode(encrypted_message_key)?;
let message_key =
open_with_keypair(&sealed_key, &identity.public_key, &identity.secret_key)?;
let packed_message = b64::decode(message_cipher)?;
let plaintext = decrypt_secretbox_payload(&message_key, &packed_message)?;
let mut payload: MessagePayload = serde_json::from_slice(&plaintext)
.map_err(|err| Error::InvalidInput(format!("invalid message payload: {err}")))?;
if kind != MESSAGE_KIND_REGULAR || payload.kind != MESSAGE_KIND_POKE {
payload.kind = kind.to_owned();
}
Ok(payload)
}
pub async fn like_message(
&self,
space_id: &str,
message_id: &str,
like: bool,
) -> Result<LikeMessageResponse> {
let message_id = message_id.trim();
if message_id.is_empty() {
return Err(Error::InvalidInput("message id is required".into()));
}
let path = format!("/spaces/{space_id}/messages/{message_id}/like");
if like {
Ok(self
.api()
.put(&path)
.json(&serde_json::json!({}))
.send()
.await?
.error_for_status()?
.json()
.await?)
} else {
Ok(self
.api()
.delete(&path)
.send()
.await?
.error_for_status()?
.json()
.await?)
}
}
pub async fn delete_message(&self, space_id: &str, message_id: &str) -> Result<()> {
let message_id = message_id.trim();
if message_id.is_empty() {
return Err(Error::InvalidInput("message id is required".into()));
}
let path = format!("/spaces/{space_id}/messages/{message_id}");
self.api().delete(&path).send().await?.error_for_status()?;
Ok(())
}
pub(crate) async fn friend_actor_for_space(
&self,
sender_space_id: &str,
space_id: &str,
) -> Result<SpaceActorResponse> {
let friends = self.list_space_friends_raw(sender_space_id).await?;
friends
.into_iter()
.map(|value| value.friend)
.find(|friend| friend.space_id == space_id)
.ok_or_else(|| Error::InvalidInput(format!("space {space_id} is not a friend")))
}
async fn message_request_for_payload(
&self,
sender_space_id: &str,
recipient_public_key: &str,
payload: &MessagePayload,
reply_message_id: Option<&str>,
notification_kind: Option<String>,
) -> Result<CreateMessageRequest> {
let identity = self.space_identity_for(sender_space_id).await?;
let recipient_public_key = b64::decode(recipient_public_key)?;
let message_key = generate_key();
let plaintext = serde_json::to_vec(payload)
.map_err(|err| Error::InvalidInput(format!("invalid message payload: {err}")))?;
validate_message_payload(payload, plaintext.len())?;
let sender_key = seal_with_public_key(&message_key, &identity.public_key)?;
let recipient_key = seal_with_public_key(&message_key, &recipient_public_key)?;
Ok(CreateMessageRequest {
message_id: None,
message_cipher: b64::encode(&encrypt_secretbox_payload(&message_key, &plaintext)?),
sender_encrypted_message_key: b64::encode(&sender_key),
recipient_encrypted_message_key: b64::encode(&recipient_key),
reply_message_id: reply_message_id.map(ToOwned::to_owned),
notification_kind,
})
}
}