671 lines
21 KiB
Rust
671 lines
21 KiB
Rust
use std::cmp::Ordering;
|
|
|
|
use anyhow::{anyhow, Error};
|
|
use chrono::{Local, TimeZone};
|
|
use common::display::DisplayProfile;
|
|
use common::event::EventUtils;
|
|
use global::nostr_client;
|
|
use gpui::{App, AppContext, Context, EventEmitter, SharedString, Task, Window};
|
|
use itertools::Itertools;
|
|
use nostr_sdk::prelude::*;
|
|
use smallvec::SmallVec;
|
|
|
|
use crate::message::Message;
|
|
use crate::Registry;
|
|
|
|
pub(crate) const NOW: &str = "now";
|
|
pub(crate) const SECONDS_IN_MINUTE: i64 = 60;
|
|
pub(crate) const MINUTES_IN_HOUR: i64 = 60;
|
|
pub(crate) const HOURS_IN_DAY: i64 = 24;
|
|
pub(crate) const DAYS_IN_MONTH: i64 = 30;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum RoomSignal {
|
|
NewMessage(Message),
|
|
Refresh,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct SendError {
|
|
pub profile: Profile,
|
|
pub message: SharedString,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
|
|
pub enum RoomKind {
|
|
Ongoing,
|
|
#[default]
|
|
Request,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Room {
|
|
pub id: u64,
|
|
pub created_at: Timestamp,
|
|
/// Subject of the room
|
|
pub subject: Option<SharedString>,
|
|
/// Picture of the room
|
|
pub picture: Option<SharedString>,
|
|
/// All members of the room
|
|
pub members: SmallVec<[PublicKey; 2]>,
|
|
/// Kind
|
|
pub kind: RoomKind,
|
|
}
|
|
|
|
impl Ord for Room {
|
|
fn cmp(&self, other: &Self) -> Ordering {
|
|
self.created_at.cmp(&other.created_at)
|
|
}
|
|
}
|
|
|
|
impl PartialOrd for Room {
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
Some(self.cmp(other))
|
|
}
|
|
}
|
|
|
|
impl PartialEq for Room {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.id == other.id
|
|
}
|
|
}
|
|
|
|
impl Eq for Room {}
|
|
|
|
impl EventEmitter<RoomSignal> for Room {}
|
|
|
|
impl Room {
|
|
pub fn new(event: &Event) -> Self {
|
|
let id = event.uniq_id();
|
|
let created_at = event.created_at;
|
|
let public_keys = event.all_pubkeys();
|
|
|
|
// Convert pubkeys into members
|
|
let members = public_keys.into_iter().unique().sorted().collect();
|
|
|
|
// Get the subject from the event's tags
|
|
let subject = if let Some(tag) = event.tags.find(TagKind::Subject) {
|
|
tag.content().map(|s| s.to_owned().into())
|
|
} else {
|
|
None
|
|
};
|
|
|
|
// Get the picture from the event's tags
|
|
let picture = if let Some(tag) = event.tags.find(TagKind::custom("picture")) {
|
|
tag.content().map(|s| s.to_owned().into())
|
|
} else {
|
|
None
|
|
};
|
|
|
|
Self {
|
|
id,
|
|
created_at,
|
|
subject,
|
|
picture,
|
|
members,
|
|
kind: RoomKind::default(),
|
|
}
|
|
}
|
|
|
|
/// Sets the kind of the room and returns the modified room
|
|
///
|
|
/// This is a builder-style method that allows chaining room modifications.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `kind` - The RoomKind to set for this room
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// The modified Room instance with the new kind
|
|
pub fn kind(mut self, kind: RoomKind) -> Self {
|
|
self.kind = kind;
|
|
self
|
|
}
|
|
|
|
/// Sets the rearrange_by field of the room and returns the modified room
|
|
///
|
|
/// This is a builder-style method that allows chaining room modifications.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `rearrange_by` - The PublicKey to set for rearranging the member list
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// The modified Room instance with the new member list after rearrangement
|
|
pub fn rearrange_by(mut self, rearrange_by: PublicKey) -> Self {
|
|
let (not_match, matches): (Vec<PublicKey>, Vec<PublicKey>) = self
|
|
.members
|
|
.into_iter()
|
|
.partition(|key| key != &rearrange_by);
|
|
self.members = not_match.into();
|
|
self.members.extend(matches);
|
|
self
|
|
}
|
|
|
|
/// Set the room kind to ongoing
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `cx` - The context to notify about the update
|
|
pub fn set_ongoing(&mut self, cx: &mut Context<Self>) {
|
|
if self.kind != RoomKind::Ongoing {
|
|
self.kind = RoomKind::Ongoing;
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
/// Checks if the room is a group chat
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// true if the room has more than 2 members, false otherwise
|
|
pub fn is_group(&self) -> bool {
|
|
self.members.len() > 2
|
|
}
|
|
|
|
/// Updates the creation timestamp of the room
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `created_at` - The new Timestamp to set
|
|
/// * `cx` - The context to notify about the update
|
|
pub fn created_at(&mut self, created_at: impl Into<Timestamp>, cx: &mut Context<Self>) {
|
|
self.created_at = created_at.into();
|
|
cx.notify();
|
|
}
|
|
|
|
/// Updates the subject of the room
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `subject` - The new subject to set
|
|
/// * `cx` - The context to notify about the update
|
|
pub fn subject(&mut self, subject: impl Into<SharedString>, cx: &mut Context<Self>) {
|
|
self.subject = Some(subject.into());
|
|
cx.notify();
|
|
}
|
|
|
|
/// Updates the picture of the room
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `picture` - The new subject to set
|
|
/// * `cx` - The context to notify about the update
|
|
pub fn picture(&mut self, picture: impl Into<SharedString>, cx: &mut Context<Self>) {
|
|
self.picture = Some(picture.into());
|
|
cx.notify();
|
|
}
|
|
|
|
/// Returns a human-readable string representing how long ago the room was created
|
|
///
|
|
/// The string will be formatted differently based on the time elapsed:
|
|
/// - Less than a minute: "now"
|
|
/// - Less than an hour: "Xm" (minutes)
|
|
/// - Less than a day: "Xh" (hours)
|
|
/// - Less than a month: "Xd" (days)
|
|
/// - More than a month: "MMM DD" (month abbreviation and day)
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// A SharedString containing the formatted time representation
|
|
pub fn ago(&self) -> SharedString {
|
|
let input_time = match Local.timestamp_opt(self.created_at.as_u64() as i64, 0) {
|
|
chrono::LocalResult::Single(time) => time,
|
|
_ => return "1m".into(),
|
|
};
|
|
|
|
let now = Local::now();
|
|
let duration = now.signed_duration_since(input_time);
|
|
|
|
match duration {
|
|
d if d.num_seconds() < SECONDS_IN_MINUTE => NOW.into(),
|
|
d if d.num_minutes() < MINUTES_IN_HOUR => format!("{}m", d.num_minutes()),
|
|
d if d.num_hours() < HOURS_IN_DAY => format!("{}h", d.num_hours()),
|
|
d if d.num_days() < DAYS_IN_MONTH => format!("{}d", d.num_days()),
|
|
_ => input_time.format("%b %d").to_string(),
|
|
}
|
|
.into()
|
|
}
|
|
|
|
/// Gets the display name for the room
|
|
///
|
|
/// If the room has a subject set, that will be used as the display name.
|
|
/// Otherwise, it will generate a name based on the room members.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `cx` - The application context
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// A SharedString containing the display name
|
|
pub fn display_name(&self, cx: &App) -> SharedString {
|
|
if let Some(subject) = self.subject.clone() {
|
|
subject
|
|
} else {
|
|
self.merge_name(cx)
|
|
}
|
|
}
|
|
|
|
/// Gets the display image for the room
|
|
///
|
|
/// The image is determined by:
|
|
/// - The room's picture if set
|
|
/// - The first member's avatar for 1:1 chats
|
|
/// - A default group image for group chats
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `proxy` - Whether to use the proxy for the avatar URL
|
|
/// * `cx` - The application context
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// A SharedString containing the image path or URL
|
|
pub fn display_image(&self, proxy: bool, cx: &App) -> SharedString {
|
|
if let Some(picture) = self.picture.as_ref() {
|
|
picture.clone()
|
|
} else if !self.is_group() {
|
|
self.first_member(cx).avatar_url(proxy)
|
|
} else {
|
|
"brand/group.png".into()
|
|
}
|
|
}
|
|
|
|
/// Get the first member of the room.
|
|
///
|
|
/// First member is always different from the current user.
|
|
pub(crate) fn first_member(&self, cx: &App) -> Profile {
|
|
let registry = Registry::read_global(cx);
|
|
registry.get_person(&self.members[0], cx)
|
|
}
|
|
|
|
/// Merge the names of the first two members of the room.
|
|
pub(crate) fn merge_name(&self, cx: &App) -> SharedString {
|
|
let registry = Registry::read_global(cx);
|
|
|
|
if self.is_group() {
|
|
let profiles = self
|
|
.members
|
|
.iter()
|
|
.map(|pk| registry.get_person(pk, cx))
|
|
.collect::<Vec<_>>();
|
|
|
|
let mut name = profiles
|
|
.iter()
|
|
.take(2)
|
|
.map(|p| p.display_name())
|
|
.collect::<Vec<_>>()
|
|
.join(", ");
|
|
|
|
if profiles.len() > 2 {
|
|
name = format!("{}, +{}", name, profiles.len() - 2);
|
|
}
|
|
|
|
name.into()
|
|
} else {
|
|
self.first_member(cx).display_name()
|
|
}
|
|
}
|
|
|
|
/// Loads all profiles for this room members from the database
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `cx` - The App context
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// A Task that resolves to Result<Vec<Profile>, Error> containing all profiles for this room
|
|
pub fn load_metadata(&self, cx: &mut Context<Self>) -> Task<Result<Vec<Profile>, Error>> {
|
|
let public_keys = self.members.clone();
|
|
|
|
cx.background_spawn(async move {
|
|
let database = nostr_client().database();
|
|
let mut profiles = vec![];
|
|
|
|
for public_key in public_keys.into_iter() {
|
|
let metadata = database.metadata(public_key).await?.unwrap_or_default();
|
|
profiles.push(Profile::new(public_key, metadata));
|
|
}
|
|
|
|
Ok(profiles)
|
|
})
|
|
}
|
|
|
|
/// Loads all messages for this room from the database
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `cx` - The App context
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// A Task that resolves to Result<Vec<RoomMessage>, Error> containing all messages for this room
|
|
pub fn load_messages(&self, cx: &App) -> Task<Result<Vec<Message>, Error>> {
|
|
let pubkeys = self.members.clone();
|
|
|
|
let filter = Filter::new()
|
|
.kind(Kind::PrivateDirectMessage)
|
|
.authors(self.members.clone())
|
|
.pubkeys(self.members.clone());
|
|
|
|
cx.background_spawn(async move {
|
|
let mut messages = vec![];
|
|
let parser = NostrParser::new();
|
|
let database = nostr_client().database();
|
|
|
|
// Get all events from database
|
|
let events = database
|
|
.query(filter)
|
|
.await?
|
|
.into_iter()
|
|
.sorted_by_key(|ev| ev.created_at)
|
|
.filter(|ev| ev.compare_pubkeys(&pubkeys))
|
|
.collect::<Vec<_>>();
|
|
|
|
for event in events.into_iter() {
|
|
let content = event.content.clone();
|
|
let tokens = parser.parse(&content);
|
|
let mut replies_to = vec![];
|
|
|
|
for tag in event.tags.filter(TagKind::e()) {
|
|
if let Some(content) = tag.content() {
|
|
if let Ok(id) = EventId::from_hex(content) {
|
|
replies_to.push(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
for tag in event.tags.filter(TagKind::q()) {
|
|
if let Some(content) = tag.content() {
|
|
if let Ok(id) = EventId::from_hex(content) {
|
|
replies_to.push(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
let mentions = tokens
|
|
.filter_map(|token| match token {
|
|
Token::Nostr(nip21) => match nip21 {
|
|
Nip21::Pubkey(pubkey) => Some(pubkey),
|
|
Nip21::Profile(profile) => Some(profile.public_key),
|
|
_ => None,
|
|
},
|
|
_ => None,
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
if let Ok(message) = Message::builder(event.id, event.pubkey)
|
|
.content(content)
|
|
.created_at(event.created_at)
|
|
.replies_to(replies_to)
|
|
.mentions(mentions)
|
|
.build()
|
|
{
|
|
messages.push(message);
|
|
}
|
|
}
|
|
|
|
Ok(messages)
|
|
})
|
|
}
|
|
|
|
/// Emits a message event to the GPUI
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `event` - The Nostr event to emit
|
|
/// * `window` - The Window to emit the event to
|
|
/// * `cx` - The context for the room
|
|
///
|
|
/// # Effects
|
|
///
|
|
/// Processes the event and emits an Incoming to the UI when complete
|
|
pub fn emit_message(&self, event: Event, _window: &mut Window, cx: &mut Context<Self>) {
|
|
// Extract all mentions from content
|
|
let mentions = extract_mentions(&event.content);
|
|
|
|
// Extract reply_to if present
|
|
let mut replies_to = vec![];
|
|
|
|
for tag in event.tags.filter(TagKind::e()) {
|
|
if let Some(content) = tag.content() {
|
|
if let Ok(id) = EventId::from_hex(content) {
|
|
replies_to.push(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
for tag in event.tags.filter(TagKind::q()) {
|
|
if let Some(content) = tag.content() {
|
|
if let Ok(id) = EventId::from_hex(content) {
|
|
replies_to.push(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Ok(message) = Message::builder(event.id, event.pubkey)
|
|
.content(event.content)
|
|
.created_at(event.created_at)
|
|
.replies_to(replies_to)
|
|
.mentions(mentions)
|
|
.build()
|
|
{
|
|
cx.emit(RoomSignal::NewMessage(message));
|
|
}
|
|
}
|
|
|
|
/// Emits a signal to refresh the current room's messages.
|
|
pub fn emit_refresh(&mut self, cx: &mut Context<Self>) {
|
|
cx.emit(RoomSignal::Refresh);
|
|
log::info!("refresh room: {}", self.id);
|
|
}
|
|
|
|
/// Creates a temporary message for optimistic updates
|
|
///
|
|
/// This constructs an unsigned message with the current user as the author,
|
|
/// extracts any mentions from the content, and packages it as a Message struct.
|
|
/// The message will have a generated ID but hasn't been published to relays.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `content` - The message content text
|
|
/// * `cx` - The application context containing user profile information
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// Returns `Some(Message)` containing the temporary message if the current user's profile is available,
|
|
/// or `None` if no account is found.
|
|
pub fn create_temp_message(
|
|
&self,
|
|
public_key: PublicKey,
|
|
content: &str,
|
|
replies: Option<&Vec<Message>>,
|
|
) -> Option<Message> {
|
|
let builder = EventBuilder::private_msg_rumor(public_key, content);
|
|
|
|
// Add event reference if it's present (replying to another event)
|
|
let mut refs = vec![];
|
|
|
|
if let Some(replies) = replies {
|
|
if replies.len() == 1 {
|
|
refs.push(Tag::event(replies[0].id))
|
|
} else {
|
|
for message in replies.iter() {
|
|
refs.push(Tag::custom(TagKind::q(), vec![message.id]))
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut event = if !refs.is_empty() {
|
|
builder.tags(refs).build(public_key)
|
|
} else {
|
|
builder.build(public_key)
|
|
};
|
|
|
|
// Create a unsigned event to convert to Coop Message
|
|
event.ensure_id();
|
|
|
|
// Extract all mentions from content
|
|
let mentions = extract_mentions(&event.content);
|
|
|
|
// Extract reply_to if present
|
|
let mut replies_to = vec![];
|
|
|
|
for tag in event.tags.filter(TagKind::e()) {
|
|
if let Some(content) = tag.content() {
|
|
if let Ok(id) = EventId::from_hex(content) {
|
|
replies_to.push(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
for tag in event.tags.filter(TagKind::q()) {
|
|
if let Some(content) = tag.content() {
|
|
if let Ok(id) = EventId::from_hex(content) {
|
|
replies_to.push(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
Message::builder(event.id.unwrap(), public_key)
|
|
.content(event.content)
|
|
.created_at(event.created_at)
|
|
.replies_to(replies_to)
|
|
.mentions(mentions)
|
|
.build()
|
|
.ok()
|
|
}
|
|
|
|
/// Sends a message to all members in the background task
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `content` - The content of the message to send
|
|
/// * `cx` - The App context
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// A Task that resolves to Result<Vec<String>, Error> where the
|
|
/// strings contain error messages for any failed sends
|
|
pub fn send_in_background(
|
|
&self,
|
|
content: &str,
|
|
replies: Option<&Vec<Message>>,
|
|
backup: bool,
|
|
cx: &App,
|
|
) -> Task<Result<Vec<SendError>, Error>> {
|
|
let content = content.to_owned();
|
|
let replies = replies.cloned();
|
|
let subject = self.subject.clone();
|
|
let picture = self.picture.clone();
|
|
let public_keys = self.members.clone();
|
|
|
|
cx.background_spawn(async move {
|
|
let client = nostr_client();
|
|
let signer = client.signer().await?;
|
|
let public_key = signer.get_public_key().await?;
|
|
|
|
let mut reports = vec![];
|
|
let mut tags: Vec<Tag> = public_keys
|
|
.iter()
|
|
.filter_map(|pubkey| {
|
|
if pubkey != &public_key {
|
|
Some(Tag::public_key(*pubkey))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
// Add event reference if it's present (replying to another event)
|
|
if let Some(replies) = replies {
|
|
if replies.len() == 1 {
|
|
tags.push(Tag::event(replies[0].id))
|
|
} else {
|
|
for message in replies.iter() {
|
|
tags.push(Tag::custom(TagKind::q(), vec![message.id]))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add subject tag if it's present
|
|
if let Some(subject) = subject {
|
|
tags.push(Tag::from_standardized(TagStandard::Subject(
|
|
subject.to_string(),
|
|
)));
|
|
}
|
|
|
|
// Add picture tag if it's present
|
|
if let Some(picture) = picture {
|
|
tags.push(Tag::custom(TagKind::custom("picture"), vec![picture]));
|
|
}
|
|
|
|
let Some((current_user, receivers)) = public_keys.split_last() else {
|
|
return Err(anyhow!("Something is wrong. Cannot get receivers list."));
|
|
};
|
|
|
|
for receiver in receivers.iter() {
|
|
if let Err(e) = client
|
|
.send_private_msg(*receiver, &content, tags.clone())
|
|
.await
|
|
{
|
|
let metadata = client
|
|
.database()
|
|
.metadata(*receiver)
|
|
.await?
|
|
.unwrap_or_default();
|
|
let profile = Profile::new(*receiver, metadata);
|
|
let report = SendError {
|
|
profile,
|
|
message: e.to_string().into(),
|
|
};
|
|
|
|
reports.push(report);
|
|
}
|
|
}
|
|
|
|
// Only send a backup message to current user if there are no issues when sending to others
|
|
if backup && reports.is_empty() {
|
|
if let Err(e) = client
|
|
.send_private_msg(*current_user, &content, tags.clone())
|
|
.await
|
|
{
|
|
let metadata = client
|
|
.database()
|
|
.metadata(*current_user)
|
|
.await?
|
|
.unwrap_or_default();
|
|
let profile = Profile::new(*current_user, metadata);
|
|
let report = SendError {
|
|
profile,
|
|
message: e.to_string().into(),
|
|
};
|
|
reports.push(report);
|
|
}
|
|
}
|
|
|
|
Ok(reports)
|
|
})
|
|
}
|
|
}
|
|
|
|
pub(crate) fn extract_mentions(content: &str) -> Vec<PublicKey> {
|
|
let parser = NostrParser::new();
|
|
let tokens = parser.parse(content);
|
|
|
|
tokens
|
|
.filter_map(|token| match token {
|
|
Token::Nostr(nip21) => match nip21 {
|
|
Nip21::Pubkey(pubkey) => Some(pubkey),
|
|
Nip21::Profile(profile) => Some(profile.public_key),
|
|
_ => None,
|
|
},
|
|
_ => None,
|
|
})
|
|
.collect::<Vec<_>>()
|
|
}
|