507 lines
18 KiB
Rust
507 lines
18 KiB
Rust
use crate::{
|
|
constants::IMAGE_SERVICE,
|
|
get_client,
|
|
states::chat::room::Room,
|
|
utils::{ago, compare, nip96_upload},
|
|
};
|
|
use async_utility::task::spawn;
|
|
use gpui::{
|
|
div, img, list, px, white, AnyElement, AppContext, Context, EventEmitter, Flatten, FocusHandle,
|
|
FocusableView, InteractiveElement, IntoElement, ListAlignment, ListState, Model, ObjectFit,
|
|
ParentElement, PathPromptOptions, Pixels, Render, SharedString, StatefulInteractiveElement,
|
|
Styled, StyledImage, View, ViewContext, VisualContext, WeakModel, WeakView, WindowContext,
|
|
};
|
|
use itertools::Itertools;
|
|
use message::Message;
|
|
use nostr_sdk::prelude::*;
|
|
use smol::fs;
|
|
use tokio::sync::oneshot;
|
|
use ui::{
|
|
button::{Button, ButtonVariants},
|
|
dock_area::{
|
|
panel::{Panel, PanelEvent},
|
|
state::PanelState,
|
|
},
|
|
input::{InputEvent, TextInput},
|
|
popup_menu::PopupMenu,
|
|
prelude::FluentBuilder,
|
|
theme::{scale::ColorScaleStep, ActiveTheme},
|
|
v_flex, Icon, IconName,
|
|
};
|
|
|
|
mod message;
|
|
|
|
#[derive(Clone)]
|
|
pub struct State {
|
|
count: usize,
|
|
items: Vec<Message>,
|
|
}
|
|
|
|
pub struct ChatPanel {
|
|
// Panel
|
|
closeable: bool,
|
|
zoomable: bool,
|
|
focus_handle: FocusHandle,
|
|
// Chat Room
|
|
id: SharedString,
|
|
name: SharedString,
|
|
room: Model<Room>,
|
|
state: Model<State>,
|
|
list: ListState,
|
|
// New Message
|
|
input: View<TextInput>,
|
|
// Media
|
|
attaches: Model<Option<Vec<Url>>>,
|
|
is_uploading: bool,
|
|
}
|
|
|
|
impl ChatPanel {
|
|
pub fn new(model: Model<Room>, cx: &mut WindowContext) -> View<Self> {
|
|
let room = model.read(cx);
|
|
let id = room.id.to_string().into();
|
|
let name = room.title.clone().unwrap_or("Untitled".into());
|
|
|
|
cx.observe_new_views::<Self>(|this, cx| {
|
|
this.load_messages(cx);
|
|
})
|
|
.detach();
|
|
|
|
cx.new_view(|cx| {
|
|
// Form
|
|
let input = cx.new_view(|cx| {
|
|
TextInput::new(cx)
|
|
.appearance(false)
|
|
.text_size(ui::Size::Small)
|
|
.placeholder("Message...")
|
|
.cleanable()
|
|
});
|
|
|
|
// List
|
|
let state = cx.new_model(|_| State {
|
|
count: 0,
|
|
items: vec![],
|
|
});
|
|
|
|
// Send message when user presses enter
|
|
cx.subscribe(
|
|
&input,
|
|
move |this: &mut ChatPanel, view, input_event, cx| {
|
|
if let InputEvent::PressEnter = input_event {
|
|
this.send_message(view.downgrade(), cx);
|
|
}
|
|
},
|
|
)
|
|
.detach();
|
|
|
|
// Update list on every state changes
|
|
cx.observe(&state, |this, model, cx| {
|
|
let items = model.read(cx).items.clone();
|
|
|
|
this.list = ListState::new(
|
|
items.len(),
|
|
ListAlignment::Bottom,
|
|
Pixels(256.),
|
|
move |idx, _cx| {
|
|
let item = items.get(idx).unwrap().clone();
|
|
div().child(item).into_any_element()
|
|
},
|
|
);
|
|
|
|
cx.notify();
|
|
})
|
|
.detach();
|
|
|
|
cx.observe(&model, |this, model, cx| {
|
|
this.load_new_messages(model.downgrade(), cx);
|
|
})
|
|
.detach();
|
|
|
|
let attaches = cx.new_model(|_| None);
|
|
|
|
Self {
|
|
closeable: true,
|
|
zoomable: true,
|
|
focus_handle: cx.focus_handle(),
|
|
room: model,
|
|
list: ListState::new(0, ListAlignment::Bottom, Pixels(256.), move |_, _| {
|
|
div().into_any_element()
|
|
}),
|
|
is_uploading: false,
|
|
id,
|
|
name,
|
|
input,
|
|
state,
|
|
attaches,
|
|
}
|
|
})
|
|
}
|
|
|
|
fn load_messages(&self, cx: &mut ViewContext<Self>) {
|
|
let room = self.room.read(cx);
|
|
let members = room.members.clone();
|
|
let owner = room.owner.clone();
|
|
// Get all public keys
|
|
let all_keys = room.get_all_keys();
|
|
|
|
// Async
|
|
let async_state = self.state.clone();
|
|
let mut async_cx = cx.to_async();
|
|
|
|
cx.foreground_executor()
|
|
.spawn(async move {
|
|
let events: anyhow::Result<Events, anyhow::Error> = async_cx
|
|
.background_executor()
|
|
.spawn({
|
|
let client = get_client();
|
|
let pubkeys = members.iter().map(|m| m.public_key()).collect::<Vec<_>>();
|
|
|
|
async move {
|
|
let signer = client.signer().await?;
|
|
let author = signer.get_public_key().await?;
|
|
|
|
let recv = Filter::new()
|
|
.kind(Kind::PrivateDirectMessage)
|
|
.author(author)
|
|
.pubkeys(pubkeys.clone());
|
|
|
|
let send = Filter::new()
|
|
.kind(Kind::PrivateDirectMessage)
|
|
.authors(pubkeys)
|
|
.pubkey(author);
|
|
|
|
// Get all DM events in database
|
|
let query = client.database().query(vec![recv, send]).await?;
|
|
|
|
Ok(query)
|
|
}
|
|
})
|
|
.await;
|
|
|
|
if let Ok(events) = events {
|
|
let items: Vec<Message> = events
|
|
.into_iter()
|
|
.sorted_by_key(|ev| ev.created_at)
|
|
.filter_map(|ev| {
|
|
let mut pubkeys: Vec<_> = ev.tags.public_keys().copied().collect();
|
|
pubkeys.push(ev.pubkey);
|
|
|
|
if compare(&pubkeys, &all_keys) {
|
|
let member = if let Some(member) =
|
|
members.iter().find(|&m| m.public_key() == ev.pubkey)
|
|
{
|
|
member.to_owned()
|
|
} else {
|
|
owner.clone()
|
|
};
|
|
|
|
Some(Message::new(
|
|
member,
|
|
ev.content.into(),
|
|
ago(ev.created_at).into(),
|
|
))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
let total = items.len();
|
|
|
|
_ = async_cx.update_model(&async_state, |a, b| {
|
|
a.items = items;
|
|
a.count = total;
|
|
b.notify();
|
|
});
|
|
}
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
fn load_new_messages(&self, model: WeakModel<Room>, cx: &mut ViewContext<Self>) {
|
|
if let Some(model) = model.upgrade() {
|
|
let room = model.read(cx);
|
|
let items: Vec<Message> = room
|
|
.new_messages
|
|
.iter()
|
|
.filter_map(|event| {
|
|
room.member(&event.pubkey).map(|member| {
|
|
Message::new(
|
|
member,
|
|
event.content.clone().into(),
|
|
ago(event.created_at).into(),
|
|
)
|
|
})
|
|
})
|
|
.collect();
|
|
|
|
cx.update_model(&self.state, |model, cx| {
|
|
model.items.extend(items);
|
|
model.count = model.items.len();
|
|
cx.notify();
|
|
});
|
|
}
|
|
}
|
|
|
|
fn send_message(&mut self, view: WeakView<TextInput>, cx: &mut ViewContext<Self>) {
|
|
let room = self.room.read(cx);
|
|
let owner = room.owner.clone();
|
|
let members = room.members.to_vec();
|
|
|
|
// Get message
|
|
let mut content = self.input.read(cx).text().to_string();
|
|
// Get all attaches and merge with message
|
|
if let Some(attaches) = self.attaches.read(cx).as_ref() {
|
|
let merged = attaches
|
|
.iter()
|
|
.map(|url| url.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join("\n");
|
|
|
|
content = format!("{}\n{}", content, merged)
|
|
}
|
|
|
|
// Async
|
|
let async_state = self.state.clone();
|
|
let mut async_cx = cx.to_async();
|
|
|
|
cx.foreground_executor()
|
|
.spawn(async move {
|
|
// Send message to all members
|
|
async_cx
|
|
.background_executor()
|
|
.spawn({
|
|
let client = get_client();
|
|
let content = content.clone().to_string();
|
|
let tags: Vec<Tag> = members
|
|
.iter()
|
|
.filter_map(|m| {
|
|
if m.public_key() != owner.public_key() {
|
|
Some(Tag::public_key(m.public_key()))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
async move {
|
|
// Send message to all members
|
|
for member in members.iter() {
|
|
_ = client
|
|
.send_private_msg(member.public_key(), &content, tags.clone())
|
|
.await
|
|
}
|
|
}
|
|
})
|
|
.detach();
|
|
|
|
_ = async_cx.update_model(&async_state, |model, cx| {
|
|
let message = Message::new(
|
|
owner,
|
|
content.to_string().into(),
|
|
ago(Timestamp::now()).into(),
|
|
);
|
|
|
|
model.items.extend(vec![message]);
|
|
model.count = model.items.len();
|
|
cx.notify();
|
|
});
|
|
|
|
if let Some(input) = view.upgrade() {
|
|
_ = async_cx.update_view(&input, |input, cx| {
|
|
input.set_text("", cx);
|
|
});
|
|
}
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
fn upload(&mut self, cx: &mut ViewContext<Self>) {
|
|
let attaches = self.attaches.clone();
|
|
let paths = cx.prompt_for_paths(PathPromptOptions {
|
|
files: true,
|
|
directories: false,
|
|
multiple: false,
|
|
});
|
|
|
|
// Show loading spinner
|
|
self.is_uploading = true;
|
|
cx.notify();
|
|
|
|
// TODO: support multiple upload
|
|
cx.spawn(move |this, mut async_cx| async move {
|
|
match Flatten::flatten(paths.await.map_err(|e| e.into())) {
|
|
Ok(Some(mut paths)) => {
|
|
let path = paths.pop().unwrap();
|
|
|
|
if let Ok(file_data) = fs::read(path).await {
|
|
let (tx, rx) = oneshot::channel::<Url>();
|
|
|
|
spawn(async move {
|
|
if let Ok(url) = nip96_upload(file_data).await {
|
|
_ = tx.send(url);
|
|
}
|
|
});
|
|
|
|
if let Ok(url) = rx.await {
|
|
// Stop loading spinner
|
|
if let Some(view) = this.upgrade() {
|
|
_ = async_cx.update_view(&view, |this, cx| {
|
|
this.is_uploading = false;
|
|
cx.notify();
|
|
});
|
|
}
|
|
|
|
// Update attaches model
|
|
_ = async_cx.update_model(&attaches, |model, cx| {
|
|
if let Some(model) = model.as_mut() {
|
|
model.push(url);
|
|
} else {
|
|
*model = Some(vec![url]);
|
|
}
|
|
cx.notify();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
Ok(None) => {}
|
|
Err(_) => {}
|
|
}
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
fn remove(&mut self, url: &Url, cx: &mut ViewContext<Self>) {
|
|
self.attaches.update(cx, |model, cx| {
|
|
if let Some(urls) = model.as_mut() {
|
|
let ix = urls.iter().position(|x| x == url).unwrap();
|
|
urls.remove(ix);
|
|
cx.notify();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
impl Panel for ChatPanel {
|
|
fn panel_id(&self) -> SharedString {
|
|
self.id.clone()
|
|
}
|
|
|
|
fn panel_metadata(&self) -> Option<Metadata> {
|
|
None
|
|
}
|
|
|
|
fn title(&self, _cx: &WindowContext) -> AnyElement {
|
|
self.name.clone().into_any_element()
|
|
}
|
|
|
|
fn closeable(&self, _cx: &WindowContext) -> bool {
|
|
self.closeable
|
|
}
|
|
|
|
fn zoomable(&self, _cx: &WindowContext) -> bool {
|
|
self.zoomable
|
|
}
|
|
|
|
fn popup_menu(&self, menu: PopupMenu, _cx: &WindowContext) -> PopupMenu {
|
|
menu.track_focus(&self.focus_handle)
|
|
}
|
|
|
|
fn toolbar_buttons(&self, _cx: &WindowContext) -> Vec<Button> {
|
|
vec![]
|
|
}
|
|
|
|
fn dump(&self, _cx: &AppContext) -> PanelState {
|
|
PanelState::new(self)
|
|
}
|
|
}
|
|
|
|
impl EventEmitter<PanelEvent> for ChatPanel {}
|
|
|
|
impl FocusableView for ChatPanel {
|
|
fn focus_handle(&self, _: &AppContext) -> FocusHandle {
|
|
self.focus_handle.clone()
|
|
}
|
|
}
|
|
|
|
impl Render for ChatPanel {
|
|
fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
|
|
v_flex()
|
|
.size_full()
|
|
.child(list(self.list.clone()).flex_1())
|
|
.child(
|
|
div().flex_shrink_0().p_2().child(
|
|
div()
|
|
.flex()
|
|
.flex_col()
|
|
.when_some(self.attaches.read(cx).as_ref(), |this, attaches| {
|
|
this.gap_1p5().children(attaches.iter().map(|url| {
|
|
let url = url.clone();
|
|
let path: SharedString = url.to_string().into();
|
|
|
|
div()
|
|
.id(path.clone())
|
|
.relative()
|
|
.w_16()
|
|
.child(
|
|
img(format!(
|
|
"{}/?url={}&w=128&h=128&fit=cover&n=-1",
|
|
IMAGE_SERVICE, path
|
|
))
|
|
.size_16()
|
|
.shadow_lg()
|
|
.rounded(px(cx.theme().radius))
|
|
.object_fit(ObjectFit::ScaleDown),
|
|
)
|
|
.child(
|
|
div()
|
|
.absolute()
|
|
.top_neg_2()
|
|
.right_neg_2()
|
|
.size_4()
|
|
.flex()
|
|
.items_center()
|
|
.justify_center()
|
|
.rounded_full()
|
|
.bg(cx.theme().danger)
|
|
.child(
|
|
Icon::new(IconName::Close)
|
|
.size_2()
|
|
.text_color(white()),
|
|
),
|
|
)
|
|
.on_click(cx.listener(move |this, _, cx| {
|
|
this.remove(&url, cx);
|
|
}))
|
|
}))
|
|
})
|
|
.child(
|
|
div()
|
|
.w_full()
|
|
.h_9()
|
|
.flex()
|
|
.items_center()
|
|
.gap_2()
|
|
.child(
|
|
Button::new("upload")
|
|
.icon(Icon::new(IconName::Upload))
|
|
.ghost()
|
|
.on_click(cx.listener(move |this, _, cx| {
|
|
this.upload(cx);
|
|
}))
|
|
.loading(self.is_uploading),
|
|
)
|
|
.child(
|
|
div()
|
|
.flex_1()
|
|
.flex()
|
|
.bg(cx.theme().base.step(cx, ColorScaleStep::FOUR))
|
|
.rounded(px(cx.theme().radius))
|
|
.px_2()
|
|
.child(self.input.clone()),
|
|
),
|
|
),
|
|
),
|
|
)
|
|
}
|
|
}
|