conduit/src/client_server/config.rs

use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
use ruma::{
    api::client::{
        error::ErrorKind,
        r0::config::{
            get_global_account_data, get_room_account_data, set_global_account_data,
            set_room_account_data,
        },
    },
    events::{AnyGlobalAccountDataEventContent, AnyRoomAccountDataEventContent},
    serde::Raw,
};
use serde::Deserialize;
use serde_json::{json, value::RawValue as RawJsonValue};

#[cfg(feature = "conduit_bin")]
use rocket::{get, put};

#[cfg_attr(
    feature = "conduit_bin",
    put("/_matrix/client/r0/user/<_>/account_data/<_>", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn set_global_account_data_route(
    db: DatabaseGuard,
    body: Ruma<set_global_account_data::Request<'_>>,
) -> ConduitResult<set_global_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    let data = serde_json::from_str::<serde_json::Value>(body.data.get())
        .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?;

    let event_type = body.event_type.to_string();

    db.account_data.update(
        None,
        sender_user,
        event_type.clone().into(),
        &json!({
            "type": event_type,
            "content": data,
        }),
        &db.globals,
    )?;

    db.flush().await?;

    Ok(set_global_account_data::Response {}.into())
}

#[cfg_attr(
    feature = "conduit_bin",
    put(
        "/_matrix/client/r0/user/<_>/rooms/<_>/account_data/<_>",
        data = "<body>"
    )
)]
#[tracing::instrument(skip(db, body))]
pub async fn set_room_account_data_route(
    db: DatabaseGuard,
    body: Ruma<set_room_account_data::Request<'_>>,
) -> ConduitResult<set_room_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    let data = serde_json::from_str::<serde_json::Value>(body.data.get())
        .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?;

    let event_type = body.event_type.to_string();

    db.account_data.update(
        Some(&body.room_id),
        sender_user,
        event_type.clone().into(),
        &json!({
            "type": event_type,
            "content": data,
        }),
        &db.globals,
    )?;

    db.flush().await?;

    Ok(set_room_account_data::Response {}.into())
}

#[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/client/r0/user/<_>/account_data/<_>", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn get_global_account_data_route(
    db: DatabaseGuard,
    body: Ruma<get_global_account_data::Request<'_>>,
) -> ConduitResult<get_global_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    let event = db
        .account_data
        .get::<Box<RawJsonValue>>(None, sender_user, body.event_type.clone().into())?
        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
    db.flush().await?;

    let account_data = serde_json::from_str::<ExtractGlobalEventContent>(event.get())
        .map_err(|_| Error::bad_database("Invalid account data event in db."))?
        .content;

    Ok(get_global_account_data::Response { account_data }.into())
}

#[cfg_attr(
    feature = "conduit_bin",
    get(
        "/_matrix/client/r0/user/<_>/rooms/<_>/account_data/<_>",
        data = "<body>"
    )
)]
#[tracing::instrument(skip(db, body))]
pub async fn get_room_account_data_route(
    db: DatabaseGuard,
    body: Ruma<get_room_account_data::Request<'_>>,
) -> ConduitResult<get_room_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    let event = db
        .account_data
        .get::<Box<RawJsonValue>>(
            Some(&body.room_id),
            sender_user,
            body.event_type.clone().into(),
        )?
        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
    db.flush().await?;

    let account_data = serde_json::from_str::<ExtractRoomEventContent>(event.get())
        .map_err(|_| Error::bad_database("Invalid account data event in db."))?
        .content;

    Ok(get_room_account_data::Response { account_data }.into())
}

#[derive(Deserialize)]
struct ExtractRoomEventContent {
    content: Raw<AnyRoomAccountDataEventContent>,
}

#[derive(Deserialize)]
struct ExtractGlobalEventContent {
    content: Raw<AnyGlobalAccountDataEventContent>,
}
Sqlite 2021-07-14 07:07:08 +00:00			`use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`use ruma::{`
			`api::client::{`
			`error::ErrorKind,`
chore: get rid of warnings 2021-03-24 10:52:10 +00:00			`r0::config::{`
			`get_global_account_data, get_room_account_data, set_global_account_data,`
			`set_room_account_data,`
			`},`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`},`
improvement: federation get_keys and optimize signingkey storage - get encryption keys over federation - optimize signing key storage - rate limit parsing of bad events - rate limit signature fetching - dependency bumps 2021-05-20 21:46:52 +00:00			`events::{AnyGlobalAccountDataEventContent, AnyRoomAccountDataEventContent},`
Update ruma to latest, renamed server keys and removed PduStub 2020-12-04 23:16:17 +00:00			`serde::Raw,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`};`
Return only event content in account_data endpoints, not the entire event 2021-04-29 19:06:15 +00:00			`use serde::Deserialize;`
improvement: federation get_keys and optimize signingkey storage - get encryption keys over federation - optimize signing key storage - rate limit parsing of bad events - rate limit signature fetching - dependency bumps 2021-05-20 21:46:52 +00:00			`use serde_json::{json, value::RawValue as RawJsonValue};`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
			`#[cfg(feature = "conduit_bin")]`
			`use rocket::{get, put};`

			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`put("/_matrix/client/r0/user/<_>/account_data/<_>", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 11:41:03 +00:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`pub async fn set_global_account_data_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 15:32:03 +00:00			`body: Ruma<set_global_account_data::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`) -> ConduitResult<set_global_account_data::Response> {`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 18:33:12 +00:00			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
improvement: federation get_keys and optimize signingkey storage - get encryption keys over federation - optimize signing key storage - rate limit parsing of bad events - rate limit signature fetching - dependency bumps 2021-05-20 21:46:52 +00:00			`let data = serde_json::from_str::<serde_json::Value>(body.data.get())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`.map_err(\|_\| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?;`

			`let event_type = body.event_type.to_string();`

			`db.account_data.update(`
			`None,`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 18:33:12 +00:00			`sender_user,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`event_type.clone().into(),`
improvement: federation get_keys and optimize signingkey storage - get encryption keys over federation - optimize signing key storage - rate limit parsing of bad events - rate limit signature fetching - dependency bumps 2021-05-20 21:46:52 +00:00			`&json!({`
			`"type": event_type,`
			`"content": data,`
			`}),`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`&db.globals,`
			`)?;`

improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`db.flush().await?;`

improvement: upgrade ruma and implement blurhashes 2021-07-15 21:17:58 +00:00			`Ok(set_global_account_data::Response {}.into())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`

feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`#[cfg_attr(`
			`feature = "conduit_bin",`
chore: get rid of warnings 2021-03-24 10:52:10 +00:00			`put(`
			`"/_matrix/client/r0/user/<_>/rooms/<_>/account_data/<_>",`
			`data = "<body>"`
			`)`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`)]`
			`#[tracing::instrument(skip(db, body))]`
			`pub async fn set_room_account_data_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`body: Ruma<set_room_account_data::Request<'_>>,`
			`) -> ConduitResult<set_room_account_data::Response> {`
			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`

fix: putting global account data works now 2021-05-29 08:49:13 +00:00			`let data = serde_json::from_str::<serde_json::Value>(body.data.get())`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`.map_err(\|_\| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?;`

			`let event_type = body.event_type.to_string();`

			`db.account_data.update(`
			`Some(&body.room_id),`
			`sender_user,`
			`event_type.clone().into(),`
improvement: federation get_keys and optimize signingkey storage - get encryption keys over federation - optimize signing key storage - rate limit parsing of bad events - rate limit signature fetching - dependency bumps 2021-05-20 21:46:52 +00:00			`&json!({`
			`"type": event_type,`
			`"content": data,`
			`}),`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`&db.globals,`
			`)?;`

			`db.flush().await?;`

improvement: upgrade ruma and implement blurhashes 2021-07-15 21:17:58 +00:00			`Ok(set_room_account_data::Response {}.into())`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`}`

refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`get("/_matrix/client/r0/user/<_>/account_data/<_>", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 11:41:03 +00:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`pub async fn get_global_account_data_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 15:32:03 +00:00			`body: Ruma<get_global_account_data::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`) -> ConduitResult<get_global_account_data::Response> {`
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device 2020-10-18 18:33:12 +00:00			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
Return only event content in account_data endpoints, not the entire event 2021-04-29 19:06:15 +00:00			`let event = db`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`.account_data`
Return only event content in account_data endpoints, not the entire event 2021-04-29 19:06:15 +00:00			`.get::<Box<RawJsonValue>>(None, sender_user, body.event_type.clone().into())?`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`.ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;`
improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`db.flush().await?;`

improvement: federation get_keys and optimize signingkey storage - get encryption keys over federation - optimize signing key storage - rate limit parsing of bad events - rate limit signature fetching - dependency bumps 2021-05-20 21:46:52 +00:00			`let account_data = serde_json::from_str::<ExtractGlobalEventContent>(event.get())`
Return only event content in account_data endpoints, not the entire event 2021-04-29 19:06:15 +00:00			`.map_err(\|_\| Error::bad_database("Invalid account data event in db."))?`
			`.content;`

Bump ruma 2021-04-29 18:56:45 +00:00			`Ok(get_global_account_data::Response { account_data }.into())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00
			`#[cfg_attr(`
			`feature = "conduit_bin",`
chore: get rid of warnings 2021-03-24 10:52:10 +00:00			`get(`
			`"/_matrix/client/r0/user/<_>/rooms/<_>/account_data/<_>",`
			`data = "<body>"`
			`)`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`)]`
			`#[tracing::instrument(skip(db, body))]`
			`pub async fn get_room_account_data_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`body: Ruma<get_room_account_data::Request<'_>>,`
			`) -> ConduitResult<get_room_account_data::Response> {`
			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`

Return only event content in account_data endpoints, not the entire event 2021-04-29 19:06:15 +00:00			`let event = db`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`.account_data`
Return only event content in account_data endpoints, not the entire event 2021-04-29 19:06:15 +00:00			`.get::<Box<RawJsonValue>>(`
chore: get rid of warnings 2021-03-24 10:52:10 +00:00			`Some(&body.room_id),`
			`sender_user,`
			`body.event_type.clone().into(),`
			`)?`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`.ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;`
			`db.flush().await?;`

improvement: federation get_keys and optimize signingkey storage - get encryption keys over federation - optimize signing key storage - rate limit parsing of bad events - rate limit signature fetching - dependency bumps 2021-05-20 21:46:52 +00:00			`let account_data = serde_json::from_str::<ExtractRoomEventContent>(event.get())`
Return only event content in account_data endpoints, not the entire event 2021-04-29 19:06:15 +00:00			`.map_err(\|_\| Error::bad_database("Invalid account data event in db."))?`
			`.content;`

Bump ruma 2021-04-29 18:56:45 +00:00			`Ok(get_room_account_data::Response { account_data }.into())`
feat: room_account_data endpoints 2021-03-24 07:48:28 +00:00			`}`
Return only event content in account_data endpoints, not the entire event 2021-04-29 19:06:15 +00:00
			`#[derive(Deserialize)]`
improvement: federation get_keys and optimize signingkey storage - get encryption keys over federation - optimize signing key storage - rate limit parsing of bad events - rate limit signature fetching - dependency bumps 2021-05-20 21:46:52 +00:00			`struct ExtractRoomEventContent {`
			`content: Raw<AnyRoomAccountDataEventContent>,`
			`}`

			`#[derive(Deserialize)]`
			`struct ExtractGlobalEventContent {`
			`content: Raw<AnyGlobalAccountDataEventContent>,`
Return only event content in account_data endpoints, not the entire event 2021-04-29 19:06:15 +00:00			`}`