caffeinatedgaze
/
lavina
forked from lavina/lavina
1
0
Fork 0
Code Pull Requests Activity

Merge remote-tracking branch 'lavina/main' into feature/muc-join-messages

This commit is contained in:
Mikhail 2024-05-24 10:43:03 +02:00
parent d02c394e34 580923814b
commit 6ce8c7a99f
4 changed files with 220 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
crates/projection-xmpp/src/message.rs
View File

@ -20,7 +20,8 @@ impl<'a> XmppConnection<'a> {
}) = m.to
{
if server.0.as_ref() == &*self.hostname_rooms && m.r#type == MessageType::Groupchat {
self.user_handle.send_message(RoomId::try_from(name.0.clone())?, m.body.clone().into()).await?;
let Some(body) = &m.body else { return Ok(()) };
self.user_handle.send_message(RoomId::try_from(name.0.clone())?, body.clone()).await?;
Message::<()> {
to: Some(Jid {
name: Some(self.user.xmpp_name.clone()),
@ -42,7 +43,8 @@ impl<'a> XmppConnection<'a> {
.serialize(output);
Ok(())
} else if server.0.as_ref() == &*self.hostname && m.r#type == MessageType::Chat {
self.user_handle.send_dialog_message(PlayerId::from(name.0.clone())?, m.body.clone()).await?;
let Some(body) = &m.body else { return Ok(()) };
self.user_handle.send_dialog_message(PlayerId::from(name.0.clone())?, body.clone()).await?;
Ok(())
} else {
todo!()

78
crates/projection-xmpp/src/presence.rs
View File

@ -6,8 +6,8 @@ use serde::Serialize;
use lavina_core::room::RoomId;
use proto_xmpp::bind::{Jid, Name, Resource, Server};
use proto_xmpp::client::Presence;
use proto_xmpp::muc::{Delay, XUser, XmppHistoryMessage};
use proto_xmpp::client::{Message, MessageType, Presence, Subject};
use proto_xmpp::muc::{Affiliation, Delay, Role, XUser, XUserItem, XmppHistoryMessage};
use proto_xmpp::xml::{Ignore, ToXml};
use crate::XmppConnection;
@ -24,8 +24,28 @@ impl<'a> XmppConnection<'a> {
// resources in MUCs are members' personas – not implemented (yet?)
resource: Some(_),
}) if server.0 == self.hostname_rooms => {
let muc_presence = self.retrieve_muc_presence(&name).await?;
let mut muc_presence = self.retrieve_muc_presence(&name).await?;
muc_presence.id = p.id;
let subject = Message::<()> {
from: Some(Jid {
name: Some(name.clone()),
server: Server(self.hostname_rooms.clone()),
resource: None,
}),
id: None,
to: Some(Jid {
name: Some(self.user.xmpp_name.clone()),
server: Server(self.hostname.clone()),
resource: Some(self.user.xmpp_resource.clone()),
}),
r#type: MessageType::Groupchat,
lang: None,
subject: Some(Subject(None)),
body: None,
custom: vec![],
};
muc_presence.serialize(output);
subject.serialize(output);
let messages = self.retrieve_message_history(&name).await?;
for message in messages {
@ -62,7 +82,9 @@ impl<'a> XmppConnection<'a> {
};
response.serialize(output);
}
_ => todo!(),
e => {
tracing::error!("TODO: unknown presence type: {e:?}");
}
}
}
@ -80,7 +102,19 @@ impl<'a> XmppConnection<'a> {
server: Server(self.hostname_rooms.clone()),
resource: Some(self.user.xmpp_muc_name.clone()),
}),
custom: vec![XUser],
custom: vec![XUser {
item: XUserItem {
affiliation: Affiliation::Member,
role: Role::Participant,
jid: Jid {
name: Some(self.user.xmpp_name.clone()),
server: Server(self.hostname.clone()),
resource: Some(self.user.xmpp_resource.clone()),
},
},
self_presence: true,
just_created: false, // TODO we don't know this for sure at this point
}],
..Default::default()
};
Ok(response)
@ -142,7 +176,7 @@ mod tests {
use lavina_core::player::PlayerId;
use proto_xmpp::bind::{Jid, Name, Resource, Server};
use proto_xmpp::client::Presence;
use proto_xmpp::muc::XUser;
use proto_xmpp::muc::{Affiliation, Role, XUser, XUserItem};
use crate::testkit::{expect_user_authenticated, TestServer};
use crate::Authenticated;
@ -164,7 +198,7 @@ mod tests {
let mut player_conn = server.core.connect_to_player(&user.player_id).await;
let mut conn = expect_user_authenticated(&server, &user, &mut player_conn).await.unwrap();
let response = conn.retrieve_muc_presence(&user.xmpp_name).await.unwrap();
let muc_presence = conn.retrieve_muc_presence(&user.xmpp_name).await.unwrap();
let expected = Presence {
to: Some(Jid {
name: Some(conn.user.xmpp_name.clone()),
@ -176,10 +210,22 @@ mod tests {
server: Server(conn.hostname_rooms.clone()),
resource: Some(conn.user.xmpp_muc_name.clone()),
}),
custom: vec![XUser],
custom: vec![XUser {
item: XUserItem {
affiliation: Affiliation::Member,
role: Role::Participant,
jid: Jid {
name: Some(conn.user.xmpp_name.clone()),
server: Server(conn.hostname.clone()),
resource: Some(conn.user.xmpp_resource.clone()),
},
},
self_presence: true,
just_created: false,
}],
..Default::default()
};
assert_eq!(expected, response);
assert_eq!(expected, muc_presence);
server.shutdown().await.unwrap();
Ok(())
@ -216,7 +262,19 @@ mod tests {
server: Server(conn.hostname_rooms.clone()),
resource: Some(conn.user.xmpp_muc_name.clone()),
}),
custom: vec![XUser],
custom: vec![XUser {
item: XUserItem {
affiliation: Affiliation::Member,
role: Role::Participant,
jid: Jid {
name: Some(conn.user.xmpp_name.clone()),
server: Server(conn.hostname.clone()),
resource: Some(conn.user.xmpp_resource.clone()),
},
},
self_presence: true,
just_created: false,
}],
..Default::default()
};
assert_eq!(expected, response);

79
crates/proto-xmpp/src/client.rs
View File

@ -20,8 +20,8 @@ pub struct Message<T> {
// default is Normal
pub r#type: MessageType,
pub lang: Option<Str>,
pub subject: Option<Str>,
pub body: Str,
pub subject: Option<Subject>,
pub body: Option<Str>,
pub custom: Vec<T>,
}
@ -38,6 +38,20 @@ impl<T: FromXml> FromXml for Message<T> {
}
}
#[derive(PartialEq, Eq, Debug)]
pub struct Subject(pub Option<Str>);
impl ToXml for Subject {
fn serialize(&self, events: &mut Vec<Event<'static>>) {
if let Some(ref s) = self.0 {
events.push(Event::Start(BytesStart::new("subject")));
events.push(Event::Text(BytesText::new(s).into_owned()));
events.push(Event::End(BytesEnd::new("subject")));
} else {
events.push(Event::Empty(BytesStart::new("subject")));
}
}
}
#[derive(From)]
struct MessageParser<T: FromXml>(MessageParserInner<T>);
@ -57,7 +71,7 @@ struct MessageParserState<T> {
to: Option<Jid>,
r#type: MessageType,
lang: Option<Str>,
subject: Option<Str>,
subject: Option<Subject>,
body: Option<Str>,
custom: Vec<T>,
}
@ -121,22 +135,16 @@ impl<T: FromXml> Parser for MessageParser<T> {
}
}
}
Event::End(_) => {
if let Some(body) = state.body {
Continuation::Final(Ok(Message {
from: state.from,
id: state.id,
to: state.to,
r#type: state.r#type,
lang: state.lang,
subject: state.subject,
body,
custom: state.custom,
}))
} else {
Continuation::Final(Err(ffail!("Body not found")))
}
}
Event::End(_) => Continuation::Final(Ok(Message {
from: state.from,
id: state.id,
to: state.to,
r#type: state.r#type,
lang: state.lang,
subject: state.subject,
body: state.body,
custom: state.custom,
})),
Event::Empty(_) => {
let parser = T::parse();
match parser.consume(namespace, event) {
@ -153,7 +161,7 @@ impl<T: FromXml> Parser for MessageParser<T> {
InSubject(mut state) => match event {
Event::Text(ref bytes) => {
let subject = fail_fast!(std::str::from_utf8(&*bytes));
state.subject = Some(subject.into());
state.subject = Some(Subject(Some(subject.into())));
Continuation::Continue(InSubject(state).into())
}
Event::End(_) => Continuation::Continue(Outer(state).into()),
@ -208,9 +216,14 @@ impl<T: ToXml> ToXml for Message<T> {
value: self.r#type.as_str().as_bytes().into(),
});
events.push(Event::Start(bytes));
events.push(Event::Start(BytesStart::new("body")));
events.push(Event::Text(BytesText::new(&self.body).into_owned()));
events.push(Event::End(BytesEnd::new("body")));
if let Some(subject) = &self.subject {
subject.serialize(events);
}
if let Some(body) = &self.body {
events.push(Event::Start(BytesStart::new("body")));
events.push(Event::Text(BytesText::new(body).into_owned()));
events.push(Event::End(BytesEnd::new("body")));
}
events.push(Event::End(BytesEnd::new("message")));
}
}
@ -487,6 +500,7 @@ impl<T: ToXml> ToXml for Iq<T> {
#[derive(PartialEq, Eq, Debug)]
pub struct Presence<T> {
pub id: Option<String>,
pub to: Option<Jid>,
pub from: Option<Jid>,
pub priority: Option<PresencePriority>,
@ -499,6 +513,7 @@ pub struct Presence<T> {
impl<T> Default for Presence<T> {
fn default() -> Self {
Self {
id: Default::default(),
to: Default::default(),
from: Default::default(),
priority: Default::default(),
@ -573,6 +588,10 @@ impl<T: FromXml> FromXml for Presence<T> {
let s = std::str::from_utf8(&attr.value)?;
p.r#type = Some(s.into());
}
b"id" => {
let s = std::str::from_utf8(&attr.value)?;
p.id = Option::from(s.to_string());
}
_ => {}
}
}
@ -660,6 +679,12 @@ impl<T: ToXml> ToXml for Presence<T> {
value: from.to_string().as_bytes().into(),
}]);
}
if let Some(ref id) = self.id {
start.extend_attributes([Attribute {
key: QName(b"id"),
value: id.to_string().as_bytes().into(),
}]);
}
events.push(Event::Start(start));
if let Some(ref priority) = self.priority {
let s = priority.0.to_string();
@ -698,8 +723,8 @@ mod tests {
}),
r#type: MessageType::Chat,
lang: None,
subject: Some("daa".into()),
body: "bbb".into(),
subject: Some(Subject(Some("daa".into()))),
body: Some("bbb".into()),
custom: vec![Ignore],
}
)
@ -721,8 +746,8 @@ mod tests {
}),
r#type: MessageType::Chat,
lang: None,
subject: Some("daa".into()),
body: "bbb".into(),
subject: Some(Subject(Some("daa".into()))),
body: Some("bbb".into()),
custom: vec![Ignore],
}
)

98
crates/proto-xmpp/src/muc/mod.rs
View File

@ -146,14 +146,108 @@ impl FromXml for X {
}
}
/// Information about an MUC member. May contain [MUC status codes](https://xmpp.org/registrar/mucstatus.html).
#[derive(Debug, PartialEq, Eq)]
pub struct XUser;
pub struct XUser {
pub item: XUserItem,
/// Code 110. The receiver is the user referred to in the presence stanza.
pub self_presence: bool,
/// Code 201. The room from which the presence stanza was sent was just created.
pub just_created: bool,
}
impl ToXml for XUser {
fn serialize(&self, output: &mut Vec<Event<'static>>) {
let mut tag = BytesStart::new("x");
tag.push_attribute(("xmlns", XMLNS_USER));
output.push(Event::Empty(tag));
output.push(Event::Start(tag));
self.item.serialize(output);
if self.self_presence {
let mut meg = BytesStart::new("status");
meg.push_attribute(("code", "110"));
output.push(Event::Empty(meg));
}
if self.just_created {
let mut meg = BytesStart::new("status");
meg.push_attribute(("code", "201"));
output.push(Event::Empty(meg));
}
output.push(Event::End(BytesEnd::new("x")));
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct XUserItem {
pub affiliation: Affiliation,
pub jid: Jid,
pub role: Role,
}
impl ToXml for XUserItem {
fn serialize(&self, output: &mut Vec<Event<'static>>) {
let mut meg = BytesStart::new("item");
meg.push_attribute(("affiliation", self.affiliation.to_str()));
meg.push_attribute(("role", self.role.to_str()));
meg.push_attribute(("jid", self.jid.to_string().as_str()));
output.push(Event::Empty(meg));
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Affiliation {
Owner,
Admin,
Member,
Outcast,
None,
}
impl Affiliation {
pub fn from_str(s: &str) -> Option<Self> {
match s {
"owner" => Some(Self::Owner),
"admin" => Some(Self::Admin),
"member" => Some(Self::Member),
"outcast" => Some(Self::Outcast),
"none" => Some(Self::None),
_ => None,
}
}
pub fn to_str(&self) -> &str {
match self {
Self::Owner => "owner",
Self::Admin => "admin",
Self::Member => "member",
Self::Outcast => "outcast",
Self::None => "none",
}
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Role {
Moderator,
Participant,
Visitor,
None,
}
impl Role {
pub fn from_str(s: &str) -> Option<Self> {
match s {
"moderator" => Some(Self::Moderator),
"participant" => Some(Self::Participant),
"visitor" => Some(Self::Visitor),
"none" => Some(Self::None),
_ => None,
}
}
pub fn to_str(&self) -> &str {
match self {
Self::Moderator => "moderator",
Self::Participant => "participant",
Self::Visitor => "visitor",
Self::None => "none",
}
}
}