conduit/src/client_server/read_marker.rs

use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
use ruma::{
    api::client::{
        error::ErrorKind,
        r0::{read_marker::set_read_marker, receipt::create_receipt},
    },
    events::{AnyEphemeralRoomEvent, EventType},
    receipt::ReceiptType,
    MilliSecondsSinceUnixEpoch,
};
use std::collections::BTreeMap;

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

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

    let fully_read_event = ruma::events::fully_read::FullyReadEvent {
        content: ruma::events::fully_read::FullyReadEventContent {
            event_id: body.fully_read.clone(),
        },
    };
    db.account_data.update(
        Some(&body.room_id),
        &sender_user,
        EventType::FullyRead,
        &fully_read_event,
        &db.globals,
    )?;

    if let Some(event) = &body.read_receipt {
        db.rooms.edus.private_read_set(
            &body.room_id,
            &sender_user,
            db.rooms.get_pdu_count(event)?.ok_or(Error::BadRequest(
                ErrorKind::InvalidParam,
                "Event does not exist.",
            ))?,
            &db.globals,
        )?;
        db.rooms
            .reset_notification_counts(&sender_user, &body.room_id)?;

        let mut user_receipts = BTreeMap::new();
        user_receipts.insert(
            sender_user.clone(),
            ruma::events::receipt::Receipt {
                ts: Some(MilliSecondsSinceUnixEpoch::now()),
            },
        );

        let mut receipts = BTreeMap::new();
        receipts.insert(ReceiptType::Read, user_receipts);

        let mut receipt_content = BTreeMap::new();
        receipt_content.insert(event.to_owned(), receipts);

        db.rooms.edus.readreceipt_update(
            &sender_user,
            &body.room_id,
            AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent {
                content: ruma::events::receipt::ReceiptEventContent(receipt_content),
                room_id: body.room_id.clone(),
            }),
            &db.globals,
        )?;
    }

    db.flush().await?;

    Ok(set_read_marker::Response.into())
}

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

    db.rooms.edus.private_read_set(
        &body.room_id,
        &sender_user,
        db.rooms
            .get_pdu_count(&body.event_id)?
            .ok_or(Error::BadRequest(
                ErrorKind::InvalidParam,
                "Event does not exist.",
            ))?,
        &db.globals,
    )?;
    db.rooms
        .reset_notification_counts(&sender_user, &body.room_id)?;

    let mut user_receipts = BTreeMap::new();
    user_receipts.insert(
        sender_user.clone(),
        ruma::events::receipt::Receipt {
            ts: Some(MilliSecondsSinceUnixEpoch::now()),
        },
    );
    let mut receipts = BTreeMap::new();
    receipts.insert(ReceiptType::Read, user_receipts);

    let mut receipt_content = BTreeMap::new();
    receipt_content.insert(body.event_id.to_owned(), receipts);

    db.rooms.edus.readreceipt_update(
        &sender_user,
        &body.room_id,
        AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent {
            content: ruma::events::receipt::ReceiptEventContent(receipt_content),
            room_id: body.room_id.clone(),
        }),
        &db.globals,
    )?;

    db.flush().await?;

    Ok(create_receipt::Response.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 16:14:47 +00:00			`use ruma::{`
feat: improved state store 2020-12-19 15:00:11 +00:00			`api::client::{`
Run cargo fmt using nightly 2021-01-27 02:53:03 +00:00			`error::ErrorKind,`
chore: get rid of warnings 2021-03-18 17:33:43 +00:00			`r0::{read_marker::set_read_marker, receipt::create_receipt},`
feat: improved state store 2020-12-19 15:00:11 +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::{AnyEphemeralRoomEvent, EventType},`
			`receipt::ReceiptType,`
			`MilliSecondsSinceUnixEpoch,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`};`
Sqlite 2021-07-14 07:07:08 +00:00			`use std::collections::BTreeMap;`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
			`#[cfg(feature = "conduit_bin")]`
			`use rocket::post;`

			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`post("/_matrix/client/r0/rooms/<_>/read_markers", 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_read_marker_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_read_marker::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`) -> ConduitResult<set_read_marker::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
			`let fully_read_event = ruma::events::fully_read::FullyReadEvent {`
			`content: ruma::events::fully_read::FullyReadEventContent {`
			`event_id: body.fully_read.clone(),`
			`},`
			`};`
			`db.account_data.update(`
			`Some(&body.room_id),`
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			`EventType::FullyRead,`
			`&fully_read_event,`
			`&db.globals,`
			`)?;`

			`if let Some(event) = &body.read_receipt {`
fix: send notification count updates when private read receipts change 2020-08-23 15:29:39 +00:00			`db.rooms.edus.private_read_set(`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`&body.room_id,`
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			`db.rooms.get_pdu_count(event)?.ok_or(Error::BadRequest(`
			`ErrorKind::InvalidParam,`
			`"Event does not exist.",`
			`))?,`
fix: send notification count updates when private read receipts change 2020-08-23 15:29:39 +00:00			`&db.globals,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`)?;`
improvement: better and more efficient message count calculation 2021-04-12 10:40:16 +00:00			`db.rooms`
			`.reset_notification_counts(&sender_user, &body.room_id)?;`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
			`let mut user_receipts = BTreeMap::new();`
			`user_receipts.insert(`
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.clone(),`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`ruma::events::receipt::Receipt {`
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			`ts: Some(MilliSecondsSinceUnixEpoch::now()),`
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 mut receipts = BTreeMap::new();`
			`receipts.insert(ReceiptType::Read, user_receipts);`

refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`let mut receipt_content = BTreeMap::new();`
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			`receipt_content.insert(event.to_owned(), receipts);`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
fix: send notification count updates when private read receipts change 2020-08-23 15:29:39 +00:00			`db.rooms.edus.readreceipt_update(`
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			`&body.room_id,`
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			`AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent {`
			`content: ruma::events::receipt::ReceiptEventContent(receipt_content),`
			`room_id: body.room_id.clone(),`
			`}),`
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?;`

refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`Ok(set_read_marker::Response.into())`
			`}`
feat: improved state store 2020-12-19 15:00:11 +00:00
			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`post("/_matrix/client/r0/rooms/<_>/receipt/<_>/<_>", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 11:41:03 +00:00			`#[tracing::instrument(skip(db, body))]`
improvement: implement /receipt 2021-03-02 13:32:30 +00:00			`pub async fn create_receipt_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
improvement: implement /receipt 2021-03-02 13:32:30 +00:00			`body: Ruma<create_receipt::Request<'_>>,`
			`) -> ConduitResult<create_receipt::Response> {`
			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`

			`db.rooms.edus.private_read_set(`
			`&body.room_id,`
			`&sender_user,`
			`db.rooms`
			`.get_pdu_count(&body.event_id)?`
			`.ok_or(Error::BadRequest(`
			`ErrorKind::InvalidParam,`
			`"Event does not exist.",`
			`))?,`
			`&db.globals,`
			`)?;`
improvement: better and more efficient message count calculation 2021-04-12 10:40:16 +00:00			`db.rooms`
			`.reset_notification_counts(&sender_user, &body.room_id)?;`
improvement: implement /receipt 2021-03-02 13:32:30 +00:00
			`let mut user_receipts = BTreeMap::new();`
			`user_receipts.insert(`
			`sender_user.clone(),`
			`ruma::events::receipt::Receipt {`
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			`ts: Some(MilliSecondsSinceUnixEpoch::now()),`
improvement: implement /receipt 2021-03-02 13:32:30 +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 mut receipts = BTreeMap::new();`
			`receipts.insert(ReceiptType::Read, user_receipts);`

improvement: implement /receipt 2021-03-02 13:32:30 +00:00			`let mut receipt_content = BTreeMap::new();`
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			`receipt_content.insert(body.event_id.to_owned(), receipts);`
improvement: implement /receipt 2021-03-02 13:32:30 +00:00
			`db.rooms.edus.readreceipt_update(`
			`&sender_user,`
			`&body.room_id,`
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			`AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent {`
			`content: ruma::events::receipt::ReceiptEventContent(receipt_content),`
			`room_id: body.room_id.clone(),`
			`}),`
improvement: implement /receipt 2021-03-02 13:32:30 +00:00			`&db.globals,`
			`)?;`
feat: improved state store 2020-12-19 15:00:11 +00:00
			`db.flush().await?;`

improvement: implement /receipt 2021-03-02 13:32:30 +00:00			`Ok(create_receipt::Response.into())`
feat: improved state store 2020-12-19 15:00:11 +00:00			`}`