finish upgrade ruma

src/api/client_server/push.rs

@@ -9,7 +9,7 @@ use ruma::{
         },
     },
     events::{push_rules::PushRulesEvent, GlobalAccountDataEventType},
-    push::{ConditionalPushRuleInit, PatternedPushRuleInit, SimplePushRuleInit},
+    push::{ConditionalPushRuleInit, NewPushRule, PatternedPushRuleInit, SimplePushRuleInit},
 };
 
 /// # `GET /_matrix/client/r0/pushrules`
@@ -132,66 +132,65 @@ pub async fn set_pushrule_route(
         .map_err(|_| Error::bad_database("Invalid account data event in db."))?;
 
     let global = &mut account_data.content.global;
-    match body.kind {
+    match body.rule {
-        RuleKind::Override => {
+        NewPushRule::Override(rule) => {
             global.override_.replace(
                 ConditionalPushRuleInit {
-                    actions: body.actions,
+                    actions: rule.actions,
                     default: false,
                     enabled: true,
-                    rule_id: body.rule_id,
+                    rule_id: rule.rule_id,
-                    conditions: body.conditions,
+                    conditions: rule.conditions,
                 }
                 .into(),
             );
         }
-        RuleKind::Underride => {
+        NewPushRule::Underride(rule) => {
             global.underride.replace(
                 ConditionalPushRuleInit {
-                    actions: body.actions,
+                    actions: rule.actions,
                     default: false,
                     enabled: true,
-                    rule_id: body.rule_id,
+                    rule_id: rule.rule_id,
-                    conditions: body.conditions,
+                    conditions: rule.conditions,
                 }
                 .into(),
             );
         }
-        RuleKind::Sender => {
+        NewPushRule::Sender(rule) => {
             global.sender.replace(
                 SimplePushRuleInit {
-                    actions: body.actions,
+                    actions: rule.actions,
                     default: false,
                     enabled: true,
-                    rule_id: body.rule_id,
+                    rule_id: rule.rule_id,
                 }
                 .into(),
             );
         }
-        RuleKind::Room => {
+        NewPushRule::Room(rule) => {
             global.room.replace(
                 SimplePushRuleInit {
-                    actions: body.actions,
+                    actions: rule.actions,
                     default: false,
                     enabled: true,
-                    rule_id: body.rule_id,
+                    rule_id: rule.rule_id,
                 }
                 .into(),
             );
         }
-        RuleKind::Content => {
+        NewPushRule::Content(rule) => {
             global.content.replace(
                 PatternedPushRuleInit {
-                    actions: body.actions,
+                    actions: rule.actions,
                     default: false,
                     enabled: true,
-                    rule_id: body.rule_id,
+                    rule_id: rule.rule_id,
-                    pattern: body.pattern.unwrap_or_default(),
+                    pattern: rule.pattern,
                 }
                 .into(),
             );
         }
-        _ => {}
     }
 
     services().account_data.update(
@@ -212,7 +211,7 @@ pub async fn get_pushrule_actions_route(
 ) -> Result<get_pushrule_actions::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    if body.scope != "global" {
+    if body.scope != RuleScope::Global {
         return Err(Error::BadRequest(
             ErrorKind::InvalidParam,
             "Scopes other than 'global' are not supported.",

src/main.rs

@@ -29,7 +29,7 @@ use http::{
 use opentelemetry::trace::{FutureExt, Tracer};
 use ruma::api::{
     client::{
-        error::{Error as RumaError, ErrorKind},
+        error::{Error as RumaError, ErrorBody, ErrorKind},
         uiaa::UiaaResponse,
     },
     IncomingRequest,
@@ -223,8 +223,10 @@ async fn unrecognized_method<B>(
     if inner.status() == axum::http::StatusCode::METHOD_NOT_ALLOWED {
         warn!("Method not allowed: {method} {uri}");
         return Ok(RumaResponse(UiaaResponse::MatrixError(RumaError {
-            kind: ErrorKind::Unrecognized,
+            body: ErrorBody::Standard {
-            message: "M_UNRECOGNIZED: Unrecognized request".to_owned(),
+                kind: ErrorKind::Unrecognized,
+                message: "M_UNRECOGNIZED: Unrecognized request".to_owned(),
+            },
             status_code: StatusCode::METHOD_NOT_ALLOWED,
         }))
         .into_response());

src/service/pusher/mod.rs

@@ -239,12 +239,12 @@ impl Service {
                     device.tweaks = tweaks.clone();
                 }
 
-                let d = &[device];
+                let d = vec![device];
                 let mut notifi = Notification::new(d);
 
                 notifi.prio = NotificationPriority::Low;
-                notifi.event_id = Some(&event.event_id);
+                notifi.event_id = Some((*event.event_id).to_owned());
-                notifi.room_id = Some(&event.room_id);
+                notifi.room_id = Some((*event.room_id).to_owned());
                 // TODO: missed calls
                 notifi.counts = NotificationCounts::new(unread, uint!(0));
 
@@ -260,18 +260,16 @@ impl Service {
                     self.send_request(&http.url, send_event_notification::v1::Request::new(notifi))
                         .await?;
                 } else {
-                    notifi.sender = Some(&event.sender);
+                    notifi.sender = Some(event.sender.clone());
-                    notifi.event_type = Some(&event.kind);
+                    notifi.event_type = Some(event.kind.clone());
-                    let content = serde_json::value::to_raw_value(&event.content).ok();
+                    notifi.content = serde_json::value::to_raw_value(&event.content).ok();
-                    notifi.content = content.as_deref();
 
                     if event.kind == RoomEventType::RoomMember {
                         notifi.user_is_target =
                             event.state_key.as_deref() == Some(event.sender.as_str());
                     }
 
-                    let user_name = services().users.displayname(&event.sender)?;
+                    notifi.sender_display_name = services().users.displayname(&event.sender)?;
-                    notifi.sender_display_name = user_name.as_deref();
 
                     let room_name = if let Some(room_name_pdu) = services()
                         .rooms
@@ -287,7 +285,7 @@ impl Service {
                         None
                     };
 
-                    notifi.room_name = room_name.as_deref();
+                    notifi.room_name = room_name;
 
                     self.send_request(&http.url, send_event_notification::v1::Request::new(notifi))
                         .await?;

src/service/rooms/event_handler/mod.rs

@@ -1113,7 +1113,7 @@ impl Service {
                         .send_federation_request(
                             origin,
                             get_event::v1::Request {
-                                event_id: next_id.into(),
+                                event_id: (*next_id).to_owned(),
                             },
                         )
                         .await

src/service/rooms/state_cache/mod.rs

@@ -164,7 +164,7 @@ impl Service {
                             .content
                             .ignored_users
                             .iter()
-                            .any(|user| user == sender)
+                            .any(|(user, _details)| user == sender)
                     });
 
                 if is_ignored {

src/utils/error.rs

@@ -102,7 +102,10 @@ impl Error {
 
         if let Self::FederationError(origin, error) = self {
             let mut error = error.clone();
-            error.message = format!("Answer from {}: {}", origin, error.message);
+            error.body = ErrorBody::Standard {
+                kind: Unknown,
+                message: format!("Answer from {}: {}", origin, error),
+            };
             return RumaResponse(UiaaResponse::MatrixError(error));
         }