Update ruma crates

Cargo.toml

@@ -26,9 +26,9 @@ r2d2-diesel = "1.0"
 regex = "1.0.0"
 reqwest = "0.9"
 router = "0.6"
-ruma-client-api = { git = "https://github.com/exul/ruma-client-api.git" }
-ruma-events = { git = "https://github.com/exul/ruma-events.git" }
-ruma-identifiers = { git = "https://github.com/ruma/ruma-identifiers.git", features = ["diesel"] }
+ruma-client-api = { git= "https://github.com/exul/ruma-client-api.git" }
+ruma-events = { version = "0.11" }
+ruma-identifiers = { version = "0.11", features = ["diesel"] }
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"

src/matrix-rocketchat/handlers/matrix/command_handler.rs

@@ -99,13 +99,13 @@ impl<'a> CommandHandler<'a> {
                 let server = match command.by_ref().next() {
                     Some(token) => {
                         let rocketchat_id = command.by_ref().next().unwrap_or_default();
-                        self.connect_new_rocketchat_server(rocketchat_id, rocketchat_url, token, &event.user_id)?
+                        self.connect_new_rocketchat_server(rocketchat_id, rocketchat_url, token, &event.sender)?
                     }
                     None => self.get_existing_rocketchat_server(rocketchat_url)?,
                 };
 
                 let new_user_on_rocketchat_server = NewUserOnRocketchatServer {
-                    matrix_user_id: event.user_id.clone(),
+                    matrix_user_id: event.sender.clone(),
                     rocketchat_server_id: server.id,
                     rocketchat_user_id: None,
                     rocketchat_auth_token: None,
@@ -118,7 +118,7 @@ impl<'a> CommandHandler<'a> {
                     self.connection,
                     self.admin_room,
                     self.config.as_url.clone(),
-                    &event.user_id,
+                    &event.sender,
                 )?;
                 self.matrix_api.send_text_message(self.admin_room.id.clone(), self.config.matrix_bot_user_id()?, body)?;
 
@@ -183,11 +183,11 @@ impl<'a> CommandHandler<'a> {
 
     fn help(&self, event: &MessageEvent) -> Result<()> {
         let help_message =
-            CommandHandler::build_help_message(self.connection, self.admin_room, self.config.as_url.clone(), &event.user_id)?;
+            CommandHandler::build_help_message(self.connection, self.admin_room, self.config.as_url.clone(), &event.sender)?;
         let bot_user_id = self.config.matrix_bot_user_id()?;
         self.matrix_api.send_text_message(self.admin_room.id.clone(), bot_user_id, help_message)?;
 
-        debug!(self.logger, "Successfully executed help command for user {}", event.user_id);
+        debug!(self.logger, "Successfully executed help command for user {}", event.sender);
         Ok(())
     }
 
@@ -197,7 +197,7 @@ impl<'a> CommandHandler<'a> {
         let password = command.by_ref().fold("".to_string(), |acc, x| acc + x);
 
         let credentials = Credentials {
-            user_id: event.user_id.clone(),
+            user_id: event.sender.clone(),
             rocketchat_username: username.to_string(),
             password: password.to_string(),
             rocketchat_url: server.rocketchat_url.clone(),
@@ -208,23 +208,23 @@ impl<'a> CommandHandler<'a> {
     }
 
     fn list_rocketchat_rooms(&self, event: &MessageEvent, server: &RocketchatServer) -> Result<()> {
-        let user_on_rocketchat_server = UserOnRocketchatServer::find(self.connection, &event.user_id, server.id.clone())?;
+        let user_on_rocketchat_server = UserOnRocketchatServer::find(self.connection, &event.sender, server.id.clone())?;
         let rocketchat_api = RocketchatApi::new(server.rocketchat_url.clone(), self.logger.clone())?.with_credentials(
             user_on_rocketchat_server.rocketchat_user_id.unwrap_or_default(),
             user_on_rocketchat_server.rocketchat_auth_token.unwrap_or_default(),
         );
         let bot_user_id = self.config.matrix_bot_user_id()?;
-        let list = self.build_rocketchat_rooms_list(rocketchat_api.as_ref(), &server.id, &event.user_id)?;
+        let list = self.build_rocketchat_rooms_list(rocketchat_api.as_ref(), &server.id, &event.sender)?;
         let message = t!(["admin_room", "list_rocketchat_rooms"]).with_vars(vec![("list", list)]);
-        self.matrix_api.send_text_message(event.room_id.clone(), bot_user_id, message.l(DEFAULT_LANGUAGE))?;
+        self.matrix_api.send_text_message(self.admin_room.id.clone(), bot_user_id, message.l(DEFAULT_LANGUAGE))?;
 
         info!(self.logger, "Successfully listed rooms for Rocket.Chat server {}", &server.rocketchat_url);
         Ok(())
     }
 
     fn bridge(&self, event: &MessageEvent, server: &RocketchatServer, message: &str) -> Result<()> {
         let bot_user_id = self.config.matrix_bot_user_id()?;
-        let user_on_rocketchat_server = UserOnRocketchatServer::find(self.connection, &event.user_id, server.id.clone())?;
+        let user_on_rocketchat_server = UserOnRocketchatServer::find(self.connection, &event.sender, server.id.clone())?;
         let rocketchat_api = RocketchatApi::new(server.rocketchat_url.clone(), self.logger.clone())?.with_credentials(
             user_on_rocketchat_server.rocketchat_user_id.clone().unwrap_or_default(),
             user_on_rocketchat_server.rocketchat_auth_token.clone().unwrap_or_default(),
@@ -270,7 +270,7 @@ impl<'a> CommandHandler<'a> {
         let room_id = match rocketchat_room.matrix_id()? {
             Some(room_id) => {
                 let room = Room::new(self.config, self.logger, self.matrix_api, room_id.clone());
-                room.bridge_for_user(event.user_id.clone(), rocketchat_room_name.to_string())?;
+                room.bridge_for_user(event.sender.clone(), rocketchat_room_name.to_string())?;
                 room_id
             }
             None => {
@@ -280,14 +280,14 @@ impl<'a> CommandHandler<'a> {
                     &Some(rocketchat_room_name.to_string()),
                     &usernames,
                     &bot_user_id,
-                    &event.user_id,
+                    &event.sender,
                 )?
             }
         };
 
         let message = t!(["admin_room", "room_successfully_bridged"])
             .with_vars(vec![("rocketchat_room_name", rocketchat_room_name.to_string())]);
-        self.matrix_api.send_text_message(event.room_id.clone(), bot_user_id.clone(), message.l(DEFAULT_LANGUAGE))?;
+        self.matrix_api.send_text_message(self.admin_room.id.clone(), bot_user_id.clone(), message.l(DEFAULT_LANGUAGE))?;
 
         info!(self.logger, "Successfully bridged room {} to {}", &rocketchat_room.id, &room_id);
         Ok(())
@@ -297,7 +297,7 @@ impl<'a> CommandHandler<'a> {
         let mut command = message.split_whitespace().collect::<Vec<&str>>().into_iter();
         let name = command.nth(1).unwrap_or_default().to_string();
 
-        let user_on_rocketchat_server = UserOnRocketchatServer::find(self.connection, &event.user_id, server.id.clone())?;
+        let user_on_rocketchat_server = UserOnRocketchatServer::find(self.connection, &event.sender, server.id.clone())?;
         let rocketchat_api = RocketchatApi::new(server.rocketchat_url.clone(), self.logger.clone())?.with_credentials(
             user_on_rocketchat_server.rocketchat_user_id.clone().unwrap_or_default(),
             user_on_rocketchat_server.rocketchat_auth_token.clone().unwrap_or_default(),
@@ -352,7 +352,7 @@ impl<'a> CommandHandler<'a> {
 
         let bot_user_id = self.config.matrix_bot_user_id()?;
         let message = t!(["admin_room", "room_successfully_unbridged"]).with_vars(vec![("rocketchat_room_name", name.clone())]);
-        self.matrix_api.send_text_message(event.room_id.clone(), bot_user_id, message.l(DEFAULT_LANGUAGE))?;
+        self.matrix_api.send_text_message(self.admin_room.id.clone(), bot_user_id, message.l(DEFAULT_LANGUAGE))?;
 
         info!(self.logger, "Successfully unbridged room {}", name.clone());
         Ok(())

src/matrix-rocketchat/handlers/matrix/dispatcher.rs

@@ -36,17 +36,31 @@ impl<'a> Dispatcher<'a> {
         for event in events {
             match *event {
                 Event::RoomMember(member_event) => {
-                    let room = Room::new(self.config, self.logger, self.matrix_api.as_ref(), member_event.room_id.clone());
+                    let room_id = match &member_event.room_id {
+                        Some(room_id) => room_id,
+                        None => {
+                            debug!(self.logger, "Skipping event, no room is specified");
+                            return Ok(());
+                        }
+                    };
+                    let room = Room::new(self.config, self.logger, self.matrix_api.as_ref(), room_id.clone());
                     let handler =
                         MembershipHandler::new(self.config, self.connection, self.logger, self.matrix_api.as_ref(), &room);
                     if let Err(err) = handler.process(&member_event) {
-                        return self.handle_error(&err, &member_event.room_id);
+                        return self.handle_error(&err, room_id);
                     }
                 }
                 Event::RoomMessage(message_event) => {
+                    let room_id = match &message_event.room_id {
+                        Some(room_id) => room_id,
+                        None => {
+                            debug!(self.logger, "Skipping event, no room is specified");
+                            return Ok(());
+                        }
+                    };
                     let handler = MessageHandler::new(self.config, self.connection, self.logger, self.matrix_api.clone());
                     if let Err(err) = handler.process(&message_event) {
-                        return self.handle_error(&err, &message_event.room_id);
+                        return self.handle_error(&err, room_id);
                     }
                 }
                 _ => debug!(self.logger, "Skipping event, because the event type is not known"),

src/matrix-rocketchat/handlers/matrix/forwarder.rs

@@ -25,7 +25,7 @@ impl<'a> Forwarder<'a> {
     /// Forwards messages to Rocket.Chat
     pub fn process(&self, event: &MessageEvent, server: RocketchatServer, channel_id: &str) -> Result<()> {
         let mut user_on_rocketchat_server =
-            match UserOnRocketchatServer::find_by_matrix_user_id(self.connection, &event.user_id, server.id)? {
+            match UserOnRocketchatServer::find_by_matrix_user_id(self.connection, &event.sender, server.id)? {
                 Some(user_on_rocketchat_server) => user_on_rocketchat_server,
                 None => {
                     debug!(self.logger, "Skipping event, because it was sent by a virtual user");
@@ -43,20 +43,20 @@ impl<'a> Forwarder<'a> {
                 rocketchat_api.chat_post_message(&content.body, channel_id)?;
             }
             MessageEventContent::Image(ref content) => {
-                let mimetype = content.clone().info.chain_err(|| ErrorKind::MissingMimeType)?.mimetype;
-                self.forward_file_to_rocketchat(rocketchat_api.as_ref(), &content.url, mimetype, &content.body, channel_id)?;
+                let mt = content.clone().info.chain_err(|| ErrorKind::MissingMimeType)?.mimetype;
+                self.forward_file_to_rocketchat(rocketchat_api.as_ref(), &content.url, Some(mt), &content.body, channel_id)?;
             }
             MessageEventContent::File(ref content) => {
-                let mimetype = content.clone().info.chain_err(|| ErrorKind::MissingMimeType)?.mimetype;
-                self.forward_file_to_rocketchat(rocketchat_api.as_ref(), &content.url, mimetype, &content.body, channel_id)?;
+                let mt = content.clone().info.chain_err(|| ErrorKind::MissingMimeType)?.mimetype;
+                self.forward_file_to_rocketchat(rocketchat_api.as_ref(), &content.url, Some(mt), &content.body, channel_id)?;
             }
             MessageEventContent::Audio(ref content) => {
-                let mimetype = content.clone().info.chain_err(|| ErrorKind::MissingMimeType)?.mimetype;
-                self.forward_file_to_rocketchat(rocketchat_api.as_ref(), &content.url, mimetype, &content.body, channel_id)?;
+                let mt = content.clone().info.chain_err(|| ErrorKind::MissingMimeType)?.mimetype;
+                self.forward_file_to_rocketchat(rocketchat_api.as_ref(), &content.url, mt, &content.body, channel_id)?;
             }
             MessageEventContent::Video(ref content) => {
-                let mimetype = content.clone().info.chain_err(|| ErrorKind::MissingMimeType)?.mimetype;
-                self.forward_file_to_rocketchat(rocketchat_api.as_ref(), &content.url, mimetype, &content.body, channel_id)?;
+                let mt = content.clone().info.chain_err(|| ErrorKind::MissingMimeType)?.mimetype;
+                self.forward_file_to_rocketchat(rocketchat_api.as_ref(), &content.url, mt, &content.body, channel_id)?;
             }
             MessageEventContent::Emote(_) | MessageEventContent::Location(_) | MessageEventContent::Notice(_) => {
                 info!(self.logger, "Not forwarding message, forwarding emote, location or notice messages is not implemented.")

src/matrix-rocketchat/handlers/matrix/membership_handler.rs

@@ -55,12 +55,12 @@ impl<'a> MembershipHandler<'a> {
                 self.handle_bot_join(matrix_bot_user_id)?;
             }
             MembershipState::Join => {
-                debug!(self.logger, "Received join event for user {} and room {}", &state_key, &event.room_id);
+                debug!(self.logger, "Received join event for user {} and room {}", &state_key, self.room.id);
 
                 self.handle_user_join()?;
             }
             MembershipState::Leave if !addressed_to_matrix_bot => {
-                debug!(self.logger, "User {} left room {}", event.user_id, event.room_id);
+                debug!(self.logger, "User {} left room {}", event.sender, self.room.id);
 
                 self.handle_user_leave()?;
             }
@@ -183,7 +183,7 @@ impl<'a> MembershipHandler<'a> {
 
     fn is_private_room(&self) -> Result<bool> {
         let room_members_events = self.matrix_api.get_room_members(self.room.id.clone(), None)?;
-        let mut user_ids: Vec<&UserId> = room_members_events.iter().map(|m| &m.user_id).collect();
+        let mut user_ids: Vec<&UserId> = room_members_events.iter().map(|m| &m.sender).collect();
         user_ids.dedup();
         Ok(user_ids.len() <= 2)
     }

src/matrix-rocketchat/handlers/matrix/message_handler.rs

@@ -29,19 +29,27 @@ impl<'a> MessageHandler<'a> {
 
     /// Handles messages that are sent in a room
     pub fn process(&self, event: &MessageEvent) -> Result<()> {
-        if event.user_id == self.config.matrix_bot_user_id()? {
+        if event.sender == self.config.matrix_bot_user_id()? {
             debug!(self.logger, "Skipping event, because it was sent by the bot user");
             return Ok(());
         }
 
+        let room_id = match &event.room_id {
+            Some(room_id) => room_id,
+            None => {
+                debug!(self.logger, "Skipping event, no room is specified");
+                return Ok(());
+            }
+        };
+
         let matrix_api = self.matrix_api.as_ref();
-        let room = Room::new(self.config, self.logger, self.matrix_api.as_ref(), event.room_id.clone());
+        let room = Room::new(self.config, self.logger, self.matrix_api.as_ref(), room_id.clone());
         if room.is_admin_room()? {
             CommandHandler::new(self.config, self.connection, self.logger, matrix_api, &room).process(event)?;
         } else if let Some((server, channel_id)) = self.get_rocketchat_server_with_room(&room)? {
             Forwarder::new(self.connection, self.logger, matrix_api).process(event, server, &channel_id)?;
         } else {
-            debug!(self.logger, "Skipping event, because the room {} is not bridged", &event.room_id);
+            debug!(self.logger, "Skipping event, because the room {} is not bridged", room_id);
         }
 
         Ok(())

tests/admin_room.rs

@@ -468,6 +468,7 @@ fn unkown_membership_states_are_skipped() {
 
     let unknown_event = MemberEvent {
         content: MemberEventContent {
+            is_direct: None,
             avatar_url: None,
             displayname: None,
             membership: MembershipState::Ban,
@@ -477,10 +478,11 @@ fn unkown_membership_states_are_skipped() {
         event_type: EventType::RoomMember,
         invite_room_state: None,
         prev_content: None,
-        room_id: RoomId::new("localhost").unwrap(),
+        room_id: Some(RoomId::new("localhost").unwrap()),
         state_key: "@spec_user:localhost".to_string(),
         unsigned: None,
-        user_id: UserId::new("localhost").unwrap(),
+        sender: UserId::new("localhost").unwrap(),
+        origin_server_ts: 0,
     };
 
     let events = Events { events: vec![Box::new(Event::RoomMember(unknown_event))] };

tests/matrix-rocketchat-test/Cargo.toml

@@ -20,8 +20,8 @@ rand = "0.4"
 reqwest = "0.9"
 router = "0.6"
 ruma-client-api = { git = "https://github.com/exul/ruma-client-api.git" }
-ruma-events = { git = "https://github.com/exul/ruma-events.git" }
-ruma-identifiers = { git = "https://github.com/ruma/ruma-identifiers.git", features = ["diesel"] }
+ruma-events = { version = "0.11" }
+ruma-identifiers = { version = "0.11", features = ["diesel"] }
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"

tests/matrix-rocketchat-test/handlers.rs

@@ -696,10 +696,11 @@ impl Handler for MatrixState {
                 event_id: EventId::new("localhost").unwrap(),
                 event_type: EventType::RoomAliases,
                 prev_content: None,
-                room_id: room_id.clone(),
+                room_id: Some(room_id.clone()),
                 state_key: "localhost".to_string(),
                 unsigned: None,
-                user_id: user_id.clone(),
+                sender: user_id.clone(),
+                origin_server_ts: 0,
             };
 
             room_states.push(StateEvent::RoomAliases(aliases_event));
@@ -896,6 +897,7 @@ fn build_member_events_from_user_ids(users: &Vec<(UserId, MembershipState)>, roo
     for &(ref user, membership_state) in users.iter() {
         let member_event = MemberEvent {
             content: MemberEventContent {
+                is_direct: None,
                 avatar_url: None,
                 displayname: None,
                 membership: membership_state,
@@ -905,10 +907,11 @@ fn build_member_events_from_user_ids(users: &Vec<(UserId, MembershipState)>, roo
             event_type: EventType::RoomMember,
             invite_room_state: None,
             prev_content: None,
-            room_id: room_id.clone(),
+            room_id: Some(room_id.clone()),
             state_key: user.to_string(),
             unsigned: None,
-            user_id: user.clone(),
+            sender: user.clone(),
+            origin_server_ts: 0,
         };
         member_events.push(member_event);
     }