palpo-core 0.0.2

Core library used by the palpo crates.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

use salvo::prelude::*;
use serde::{Deserialize, Serialize};

use crate::events::{AnyStateEvent, AnyStateEventContent, StateEventType};
use crate::{OwnedEventId, OwnedRoomId, UnixMillis, serde::RawJson};

/// `GET /_matrix/client/*/rooms/{room_id}/state/{eventType}/{stateKey}`
///
/// Get state events associated with a given key.
/// `/v3/` ([spec])
///
/// [spec]: https://spec.matrix.org/latest/client-server-api/#get_matrixclientv3roomsroomidstateeventtypestatekey

// const METADATA: Metadata = metadata! {
//     method: GET,
//     rate_limited: false,
//     authentication: AccessToken,
//     history: {
//         1.0 => "/_matrix/client/r0/rooms/:room_id/state/:event_type/:state_key",
//         1.1 => "/_matrix/client/v3/rooms/:room_id/state/:event_type/:state_key",
//     }
// };

/// Request type for the `get_state_events_for_key` endpoint.
#[derive(ToParameters, Deserialize, Debug)]
pub struct StateEventsForKeyReqArgs {
    /// The room to look up the state for.
    #[salvo(parameter(parameter_in = Path))]
    pub room_id: OwnedRoomId,

    /// The type of state to look up.
    #[salvo(parameter(parameter_in = Path))]
    pub event_type: StateEventType,

    /// The key of the state to look up.
    #[salvo(parameter(parameter_in = Path))]
    pub state_key: String,

    /// Optional parameter to return the event content
    /// or the full state event.
    #[salvo(parameter(parameter_in = Query))]
    pub format: Option<String>,
}
#[derive(ToParameters, Deserialize, Debug)]
pub struct StateEventsForEmptyKeyReqArgs {
    /// The room to look up the state for.
    #[salvo(parameter(parameter_in = Path))]
    pub room_id: OwnedRoomId,

    /// The type of state to look up.
    #[salvo(parameter(parameter_in = Path))]
    pub event_type: StateEventType,

    /// Optional parameter to return the event content
    /// or the full state event.
    #[salvo(parameter(parameter_in = Query))]
    pub format: Option<String>,
}

/// Response type for the `get_state_events_for_key` endpoint.
#[derive(ToSchema, Serialize, Debug)]

pub struct StateEventsForKeyResBody {
    /// The content of the state event.
    ///
    /// This is `serde_json::Value` due to complexity issues with returning only the
    /// actual JSON content without a top level key.
    #[serde(flatten, skip_serializing_if = "Option::is_none")]
    pub content: Option<serde_json::Value>,

    /// The full state event
    ///
    /// This is `serde_json::Value` due to complexity issues with returning only the
    /// actual JSON content without a top level key.
    #[serde(flatten, skip_serializing_if = "Option::is_none")]
    pub event: Option<serde_json::Value>,
}
impl StateEventsForKeyResBody {
    /// Creates a new `Response` with the given content.
    pub fn new(content: serde_json::Value, event: serde_json::Value) -> Self {
        Self {
            content: Some(content),
            event: Some(event),
        }
    }
}

/// `GET /_matrix/client/*/rooms/{room_id}/state`
///
/// Get state events for a room.
/// `/v3/` ([spec])
///
/// [spec]: https://spec.matrix.org/latest/client-server-api/#get_matrixclientv3roomsroomidstate

// const METADATA: Metadata = metadata! {
//     method: GET,
//     rate_limited: false,
//     authentication: AccessToken,
//     history: {
//         1.0 => "/_matrix/client/r0/rooms/:room_id/state",
//         1.1 => "/_matrix/client/v3/rooms/:room_id/state",
//     }
// };

// /// Request type for the `get_state_events` endpoint.

// pub struct StateEventsReqBody {
//     /// The room to look up the state for.
//     #[salvo(parameter(parameter_in = Path))]
//     pub room_id: OwnedRoomId,
// }

/// Response type for the `get_state_events` endpoint.
#[derive(ToSchema, Serialize, Debug)]

pub struct StateEventsResBody(
    /// If the user is a member of the room this will be the current state of the room as a
    /// list of events.
    ///
    /// If the user has left the room then this will be the state of the room when they left as
    /// a list of events.
    #[salvo(schema(value_type = Vec<Object>, additional_properties = true))]
    Vec<RawJson<AnyStateEvent>>,
);
impl StateEventsResBody {
    /// Creates a new `Response` with the given room state.
    pub fn new(room_state: Vec<RawJson<AnyStateEvent>>) -> Self {
        Self(room_state)
    }
}

/// `PUT /_matrix/client/*/rooms/{room_id}/state/{eventType}/{stateKey}`
///
/// Send a state event to a room associated with a given state key.
/// `/v3/` ([spec])
///
/// [spec]: https://spec.matrix.org/latest/client-server-api/#put_matrixclientv3roomsroomidstateeventtypestatekey
// const METADATA: Metadata = metadata! {
//     method: PUT,
//     rate_limited: false,
//     authentication: AccessToken,
//     history: {
//         1.0 => "/_matrix/client/r0/rooms/:room_id/state/:event_type/:state_key",
//         1.1 => "/_matrix/client/v3/rooms/:room_id/state/:event_type/:state_key",
//     }
// };

/// Request type for the `send_state_event` endpoint.
// #[derive(ToSchema, Deserialize, Debug)]
// pub struct SendStateEventReqBody {
//     // /// The room to set the state in.
//     // pub room_id: OwnedRoomId,

//     // /// The type of event to send.
//     // pub event_type: StateEventType,

//     /// The state_key for the state to send.
//     pub state_key: Option<String>,

//     /// The event content to send.
//     #[salvo(schema(value_type = Object, additional_properties = true))]
//     pub body: RawJson<AnyStateEventContent>,

//     /// Timestamp to use for the `origin_server_ts` of the event.
//     ///
//     /// This is called [timestamp massaging] and can only be used by Appservices.
//     ///
//     /// Note that this does not change the position of the event in the timeline.
//     ///
//     /// [timestamp massaging]: https://spec.matrix.org/latest/application-service-api/#timestamp-massaging
//     pub timestamp: Option<UnixMillis>,
// }
#[derive(ToSchema, Deserialize, Debug)]
pub struct SendStateEventReqBody(
    /// The event content to send.
    #[salvo(schema(value_type = Object, additional_properties = true))]
    pub RawJson<AnyStateEventContent>,
);

/// Response type for the `send_state_event` endpoint.
#[derive(ToSchema, Serialize, Debug)]

pub struct SendStateEventResBody {
    /// A unique identifier for the event.
    pub event_id: OwnedEventId,
}
impl SendStateEventResBody {
    /// Creates a new `Response` with the given event id.
    pub fn new(event_id: OwnedEventId) -> Self {
        Self { event_id }
    }
}

/// Data in the request's query string.
#[derive(Serialize, Deserialize, Debug)]
struct RequestQuery {
    /// Timestamp to use for the `origin_server_ts` of the event.
    #[serde(default, rename = "ts", skip_serializing_if = "Option::is_none")]
    timestamp: Option<UnixMillis>,
}