conduit/src/client_server/context.rs

use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
use ruma::api::client::{error::ErrorKind, r0::context::get_context};
use std::convert::TryFrom;

#[cfg(feature = "conduit_bin")]
use rocket::get;

/// # `GET /_matrix/client/r0/rooms/{roomId}/context`
///
/// Allows loading room history around an event.
///
/// - Only works if the user is joined (TODO: always allow, but only show events if the user was
/// joined, depending on history_visibility)
#[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/client/r0/rooms/<_>/context/<_>", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn get_context_route(
    db: DatabaseGuard,
    body: Ruma<get_context::Request<'_>>,
) -> ConduitResult<get_context::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    if !db.rooms.is_joined(sender_user, &body.room_id)? {
        return Err(Error::BadRequest(
            ErrorKind::Forbidden,
            "You don't have permission to view this room.",
        ));
    }

    let base_pdu_id = db
        .rooms
        .get_pdu_id(&body.event_id)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "Base event id not found.",
        ))?;

    let base_token = db.rooms.pdu_count(&base_pdu_id)?;

    let base_event = db
        .rooms
        .get_pdu_from_id(&base_pdu_id)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "Base event not found.",
        ))?
        .to_room_event();

    let events_before: Vec<_> = db
        .rooms
        .pdus_until(sender_user, &body.room_id, base_token)?
        .take(
            u32::try_from(body.limit).map_err(|_| {
                Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.")
            })? as usize
                / 2,
        )
        .filter_map(|r| r.ok()) // Remove buggy events
        .collect();

    let start_token = events_before
        .last()
        .and_then(|(pdu_id, _)| db.rooms.pdu_count(pdu_id).ok())
        .map(|count| count.to_string());

    let events_before: Vec<_> = events_before
        .into_iter()
        .map(|(_, pdu)| pdu.to_room_event())
        .collect();

    let events_after: Vec<_> = db
        .rooms
        .pdus_after(sender_user, &body.room_id, base_token)?
        .take(
            u32::try_from(body.limit).map_err(|_| {
                Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.")
            })? as usize
                / 2,
        )
        .filter_map(|r| r.ok()) // Remove buggy events
        .collect();

    let end_token = events_after
        .last()
        .and_then(|(pdu_id, _)| db.rooms.pdu_count(pdu_id).ok())
        .map(|count| count.to_string());

    let events_after: Vec<_> = events_after
        .into_iter()
        .map(|(_, pdu)| pdu.to_room_event())
        .collect();

    let resp = get_context::Response {
        start: start_token,
        end: end_token,
        events_before,
        event: Some(base_event),
        events_after,
        state: db // TODO: State at event
            .rooms
            .room_state_full(&body.room_id)?
            .values()
            .map(|pdu| pdu.to_state_event())
            .collect(),
    };

    Ok(resp.into())
}
Sqlite 2021-07-14 07:07:08 +00:00			`use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`use ruma::api::client::{error::ErrorKind, r0::context::get_context};`
Sqlite 2021-07-14 07:07:08 +00:00			`use std::convert::TryFrom;`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
			`#[cfg(feature = "conduit_bin")]`
			`use rocket::get;`

docs: documentation for every endpoint 2021-08-31 19:14:37 +02:00			/// # `GET /_matrix/client/r0/rooms/{roomId}/context`
			`///`
			`/// Allows loading room history around an event.`
			`///`
			`/// - Only works if the user is joined (TODO: always allow, but only show events if the user was`
			`/// joined, depending on history_visibility)`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`get("/_matrix/client/r0/rooms/<_>/context/<_>", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 12:41:03 +01:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 21:28:02 +02:00			`pub async fn get_context_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 17:32:03 +02:00			`body: Ruma<get_context::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`) -> ConduitResult<get_context::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 20:33:12 +02:00			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
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 20:33:12 +02:00			`if !db.rooms.is_joined(sender_user, &body.room_id)? {`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`return Err(Error::BadRequest(`
			`ErrorKind::Forbidden,`
			`"You don't have permission to view this room.",`
			`));`
			`}`

fix: various improvements and fixes 2021-03-23 12:59:27 +01:00			`let base_pdu_id = db`
			`.rooms`
			`.get_pdu_id(&body.event_id)?`
			`.ok_or(Error::BadRequest(`
			`ErrorKind::NotFound,`
			`"Base event id not found.",`
			`))?;`

			`let base_token = db.rooms.pdu_count(&base_pdu_id)?;`

refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`let base_event = db`
			`.rooms`
fix: various improvements and fixes 2021-03-23 12:59:27 +01:00			`.get_pdu_from_id(&base_pdu_id)?`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.ok_or(Error::BadRequest(`
			`ErrorKind::NotFound,`
			`"Base event not found.",`
			`))?`
			`.to_room_event();`

Reduce turbofish usage Should make the code a little bit easier to read. 2021-10-13 11:51:30 +02:00			`let events_before: Vec<_> = db`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.rooms`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`.pdus_until(sender_user, &body.room_id, base_token)?`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.take(`
			`u32::try_from(body.limit).map_err(\|_\| {`
			`Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.")`
			`})? as usize`
			`/ 2,`
			`)`
			`.filter_map(\|r\| r.ok()) // Remove buggy events`
Reduce turbofish usage Should make the code a little bit easier to read. 2021-10-13 11:51:30 +02:00			`.collect();`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
improvement: more efficient /sync with gaps 2020-09-17 14:44:47 +02:00			`let start_token = events_before`
			`.last()`
			`.and_then(\|(pdu_id, _)\| db.rooms.pdu_count(pdu_id).ok())`
			`.map(\|count\| count.to_string());`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
Reduce turbofish usage Should make the code a little bit easier to read. 2021-10-13 11:51:30 +02:00			`let events_before: Vec<_> = events_before`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.into_iter()`
			`.map(\|(_, pdu)\| pdu.to_room_event())`
Reduce turbofish usage Should make the code a little bit easier to read. 2021-10-13 11:51:30 +02:00			`.collect();`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
Reduce turbofish usage Should make the code a little bit easier to read. 2021-10-13 11:51:30 +02:00			`let events_after: Vec<_> = db`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.rooms`
Clean up (mostly automated with cargo clippy --fix) 2021-09-13 19:45:56 +02:00			`.pdus_after(sender_user, &body.room_id, base_token)?`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.take(`
			`u32::try_from(body.limit).map_err(\|_\| {`
			`Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.")`
			`})? as usize`
			`/ 2,`
			`)`
			`.filter_map(\|r\| r.ok()) // Remove buggy events`
Reduce turbofish usage Should make the code a little bit easier to read. 2021-10-13 11:51:30 +02:00			`.collect();`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
improvement: more efficient /sync with gaps 2020-09-17 14:44:47 +02:00			`let end_token = events_after`
			`.last()`
			`.and_then(\|(pdu_id, _)\| db.rooms.pdu_count(pdu_id).ok())`
			`.map(\|count\| count.to_string());`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
Reduce turbofish usage Should make the code a little bit easier to read. 2021-10-13 11:51:30 +02:00			`let events_after: Vec<_> = events_after`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`.into_iter()`
			`.map(\|(_, pdu)\| pdu.to_room_event())`
Reduce turbofish usage Should make the code a little bit easier to read. 2021-10-13 11:51:30 +02:00			`.collect();`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00
Use struct literals for consistency 2022-01-13 11:48:18 +01:00			`let resp = get_context::Response {`
			`start: start_token,`
			`end: end_token,`
			`events_before,`
			`event: Some(base_event),`
			`events_after,`
			`state: db // TODO: State at event`
			`.rooms`
			`.room_state_full(&body.room_id)?`
			`.values()`
			`.map(\|pdu\| pdu.to_state_event())`
			`.collect(),`
			`};`
Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state 2020-08-06 08:29:59 -04:00
			`Ok(resp.into())`
refactor: put endpoints into modules 2020-07-30 18:14:47 +02:00			`}`