conduit/src/client_server/state.rs

use crate::{
    database::DatabaseGuard, pdu::PduBuilder, ConduitResult, Database, Error, Result, Ruma,
};
use ruma::{
    api::client::{
        error::ErrorKind,
        r0::state::{get_state_events, get_state_events_for_key, send_state_event},
    },
    events::{
        room::{
            canonical_alias::CanonicalAliasEventContent,
            history_visibility::{HistoryVisibility, HistoryVisibilityEventContent},
        },
        AnyStateEventContent, EventType,
    },
    serde::Raw,
    EventId, RoomId, UserId,
};

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

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

    let event_id = send_state_event_for_key_helper(
        &db,
        sender_user,
        &body.room_id,
        EventType::from(&body.event_type),
        &body.body.body, // Yes, I hate it too
        body.state_key.to_owned(),
    )
    .await?;

    db.flush().await?;

    Ok(send_state_event::Response { event_id }.into())
}

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

    let event_id = send_state_event_for_key_helper(
        &db,
        sender_user,
        &body.room_id,
        EventType::from(&body.event_type),
        &body.body.body,
        body.state_key.to_owned(),
    )
    .await?;

    db.flush().await?;

    Ok(send_state_event::Response { event_id }.into())
}

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

    #[allow(clippy::blocks_in_if_conditions)]
    // Users not in the room should not be able to access the state unless history_visibility is
    // WorldReadable
    if !db.rooms.is_joined(sender_user, &body.room_id)?
        && !matches!(
            db.rooms
                .room_state_get(&body.room_id, &EventType::RoomHistoryVisibility, "")?
                .map(|event| {
                    serde_json::from_value::<HistoryVisibilityEventContent>(event.content.clone())
                        .map_err(|_| {
                            Error::bad_database(
                                "Invalid room history visibility event in database.",
                            )
                        })
                        .map(|e| e.history_visibility)
                }),
            Some(Ok(HistoryVisibility::WorldReadable))
        )
    {
        return Err(Error::BadRequest(
            ErrorKind::Forbidden,
            "You don't have permission to view the room state.",
        ));
    }

    Ok(get_state_events::Response {
        room_state: db
            .rooms
            .room_state_full(&body.room_id)?
            .values()
            .map(|pdu| pdu.to_state_event())
            .collect(),
    }
    .into())
}

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

    #[allow(clippy::blocks_in_if_conditions)]
    // Users not in the room should not be able to access the state unless history_visibility is
    // WorldReadable
    if !db.rooms.is_joined(sender_user, &body.room_id)?
        && !matches!(
            db.rooms
                .room_state_get(&body.room_id, &EventType::RoomHistoryVisibility, "")?
                .map(|event| {
                    serde_json::from_value::<HistoryVisibilityEventContent>(event.content.clone())
                        .map_err(|_| {
                            Error::bad_database(
                                "Invalid room history visibility event in database.",
                            )
                        })
                        .map(|e| e.history_visibility)
                }),
            Some(Ok(HistoryVisibility::WorldReadable))
        )
    {
        return Err(Error::BadRequest(
            ErrorKind::Forbidden,
            "You don't have permission to view the room state.",
        ));
    }

    let event = db
        .rooms
        .room_state_get(&body.room_id, &body.event_type, &body.state_key)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "State event not found.",
        ))?;

    Ok(get_state_events_for_key::Response {
        content: serde_json::from_value(event.content.clone())
            .map_err(|_| Error::bad_database("Invalid event content in database"))?,
    }
    .into())
}

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

    #[allow(clippy::blocks_in_if_conditions)]
    // Users not in the room should not be able to access the state unless history_visibility is
    // WorldReadable
    if !db.rooms.is_joined(sender_user, &body.room_id)?
        && !matches!(
            db.rooms
                .room_state_get(&body.room_id, &EventType::RoomHistoryVisibility, "")?
                .map(|event| {
                    serde_json::from_value::<HistoryVisibilityEventContent>(event.content.clone())
                        .map_err(|_| {
                            Error::bad_database(
                                "Invalid room history visibility event in database.",
                            )
                        })
                        .map(|e| e.history_visibility)
                }),
            Some(Ok(HistoryVisibility::WorldReadable))
        )
    {
        return Err(Error::BadRequest(
            ErrorKind::Forbidden,
            "You don't have permission to view the room state.",
        ));
    }

    let event = db
        .rooms
        .room_state_get(&body.room_id, &body.event_type, "")?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "State event not found.",
        ))?;

    Ok(get_state_events_for_key::Response {
        content: serde_json::from_value(event.content.clone())
            .map_err(|_| Error::bad_database("Invalid event content in database"))?,
    }
    .into())
}

pub async fn send_state_event_for_key_helper(
    db: &Database,
    sender: &UserId,
    room_id: &RoomId,
    event_type: EventType,
    json: &Raw<AnyStateEventContent>,
    state_key: String,
) -> Result<EventId> {
    let sender_user = sender;

    if let Ok(canonical_alias) =
        serde_json::from_str::<CanonicalAliasEventContent>(json.json().get())
    {
        let mut aliases = canonical_alias.alt_aliases.clone();

        if let Some(alias) = canonical_alias.alias {
            aliases.push(alias);
        }

        for alias in aliases {
            if alias.server_name() != db.globals.server_name()
                || db
                    .rooms
                    .id_from_alias(&alias)?
                    .filter(|room| room == room_id) // Make sure it's the right room
                    .is_none()
            {
                return Err(Error::BadRequest(
                    ErrorKind::Forbidden,
                    "You are only allowed to send canonical_alias \
                    events when it's aliases already exists",
                ));
            }
        }
    }

    let event_id = db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type,
            content: serde_json::from_str(json.json().get()).expect("content is valid json"),
            unsigned: None,
            state_key: Some(state_key),
            redacts: None,
        },
        &sender_user,
        &room_id,
        &db,
    )?;

    Ok(event_id)
}
Sqlite 2021-07-14 07:07:08 +00:00			`use crate::{`
			`database::DatabaseGuard, pdu::PduBuilder, ConduitResult, Database, Error, Result, Ruma,`
			`};`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`use ruma::{`
			`api::client::{`
			`error::ErrorKind,`
Upgrade ruma … and refactor push rule code along the way. 2021-04-05 19:25:10 +00:00			`r0::state::{get_state_events, get_state_events_for_key, send_state_event},`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`},`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`events::{`
improvement: update ruma 2021-04-22 09:26:20 +00:00			`room::{`
			`canonical_alias::CanonicalAliasEventContent,`
			`history_visibility::{HistoryVisibility, HistoryVisibilityEventContent},`
			`},`
			`AnyStateEventContent, EventType,`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`},`
improvement: update ruma 2021-04-22 09:26:20 +00:00			`serde::Raw,`
Fix review issues, move state-res to spec-comp branch 2020-08-26 15:15:52 +00:00			`EventId, RoomId, UserId,`
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/rooms/<_>/state/<_>/<_>", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 11:41:03 +00:00			`#[tracing::instrument(skip(db, body))]`
feat: send messages over federation 2020-09-14 18:23:19 +00:00			`pub async fn send_state_event_for_key_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Upgrade ruma … and refactor push rule code along the way. 2021-04-05 19:25:10 +00:00			`body: Ruma<send_state_event::Request<'_>>,`
			`) -> ConduitResult<send_state_event::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: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`let event_id = send_state_event_for_key_helper(`
			`&db,`
			`sender_user,`
			`&body.room_id,`
improvement: update ruma 2021-04-22 09:26:20 +00:00			`EventType::from(&body.event_type),`
			`&body.body.body, // Yes, I hate it too`
			`body.state_key.to_owned(),`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00			`)`
improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`.await?;`

			`db.flush().await?;`

Upgrade ruma … and refactor push rule code along the way. 2021-04-05 19:25:10 +00:00			`Ok(send_state_event::Response { event_id }.into())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`

			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`put("/_matrix/client/r0/rooms/<_>/state/<_>", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 11:41:03 +00:00			`#[tracing::instrument(skip(db, body))]`
feat: send messages over federation 2020-09-14 18:23:19 +00:00			`pub async fn send_state_event_for_empty_key_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Upgrade ruma … and refactor push rule code along the way. 2021-04-05 19:25:10 +00:00			`body: Ruma<send_state_event::Request<'_>>,`
			`) -> ConduitResult<send_state_event::Response> {`
improvement: update ruma 2021-04-22 09:26:20 +00:00			`let sender_user = body.sender_user.as_ref().expect("user is authenticated");`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00
improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`let event_id = send_state_event_for_key_helper(`
			`&db,`
improvement: update ruma 2021-04-22 09:26:20 +00:00			`sender_user,`
improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`&body.room_id,`
improvement: update ruma 2021-04-22 09:26:20 +00:00			`EventType::from(&body.event_type),`
			`&body.body.body,`
			`body.state_key.to_owned(),`
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 12:29:59 +00:00			`)`
improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`.await?;`

			`db.flush().await?;`

Upgrade ruma … and refactor push rule code along the way. 2021-04-05 19:25:10 +00:00			`Ok(send_state_event::Response { event_id }.into())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`

			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`get("/_matrix/client/r0/rooms/<_>/state", 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_state_events_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Update ruma to latest, fix unstable origin feature in ruma 2020-10-27 23:10:09 +00:00			`body: Ruma<get_state_events::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`) -> ConduitResult<get_state_events::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
Reformat imports and fix clippy warnings 2020-11-08 19:45:52 +00:00			`#[allow(clippy::blocks_in_if_conditions)]`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`// Users not in the room should not be able to access the state unless history_visibility is`
			`// WorldReadable`
Update ruma to latest, fix unstable origin feature in ruma 2020-10-27 23:10:09 +00:00			`if !db.rooms.is_joined(sender_user, &body.room_id)?`
			`&& !matches!(`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`db.rooms`
			`.room_state_get(&body.room_id, &EventType::RoomHistoryVisibility, "")?`
improvement: optimize state storage 2021-03-17 21:30:25 +00:00			`.map(\|event\| {`
improvement: pdu cache, /sync cache 2021-06-30 07:52:01 +00:00			`serde_json::from_value::<HistoryVisibilityEventContent>(event.content.clone())`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`.map_err(\|_\| {`
			`Error::bad_database(`
			`"Invalid room history visibility event in database.",`
			`)`
			`})`
			`.map(\|e\| e.history_visibility)`
			`}),`
			`Some(Ok(HistoryVisibility::WorldReadable))`
Update ruma to latest, fix unstable origin feature in ruma 2020-10-27 23:10:09 +00:00			`)`
			`{`
			`return Err(Error::BadRequest(`
			`ErrorKind::Forbidden,`
			`"You don't have permission to view the room state.",`
			`));`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`

			`Ok(get_state_events::Response {`
			`room_state: db`
			`.rooms`
			`.room_state_full(&body.room_id)?`
			`.values()`
			`.map(\|pdu\| pdu.to_state_event())`
			`.collect(),`
			`}`
			`.into())`
			`}`

			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`get("/_matrix/client/r0/rooms/<_>/state/<_>/<_>", 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_state_events_for_key_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Update ruma to latest, fix unstable origin feature in ruma 2020-10-27 23:10:09 +00:00			`body: Ruma<get_state_events_for_key::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`) -> ConduitResult<get_state_events_for_key::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
Reformat imports and fix clippy warnings 2020-11-08 19:45:52 +00:00			`#[allow(clippy::blocks_in_if_conditions)]`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`// Users not in the room should not be able to access the state unless history_visibility is`
			`// WorldReadable`
Update ruma to latest, fix unstable origin feature in ruma 2020-10-27 23:10:09 +00:00			`if !db.rooms.is_joined(sender_user, &body.room_id)?`
			`&& !matches!(`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`db.rooms`
			`.room_state_get(&body.room_id, &EventType::RoomHistoryVisibility, "")?`
improvement: optimize state storage 2021-03-17 21:30:25 +00:00			`.map(\|event\| {`
improvement: pdu cache, /sync cache 2021-06-30 07:52:01 +00:00			`serde_json::from_value::<HistoryVisibilityEventContent>(event.content.clone())`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`.map_err(\|_\| {`
			`Error::bad_database(`
			`"Invalid room history visibility event in database.",`
			`)`
			`})`
			`.map(\|e\| e.history_visibility)`
			`}),`
			`Some(Ok(HistoryVisibility::WorldReadable))`
Update ruma to latest, fix unstable origin feature in ruma 2020-10-27 23:10:09 +00:00			`)`
			`{`
			`return Err(Error::BadRequest(`
			`ErrorKind::Forbidden,`
			`"You don't have permission to view the room state.",`
			`));`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`

			`let event = db`
			`.rooms`
			`.room_state_get(&body.room_id, &body.event_type, &body.state_key)?`
			`.ok_or(Error::BadRequest(`
			`ErrorKind::NotFound,`
			`"State event not found.",`
improvement: optimize state storage 2021-03-17 21:30:25 +00:00			`))?;`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
			`Ok(get_state_events_for_key::Response {`
improvement: pdu cache, /sync cache 2021-06-30 07:52:01 +00:00			`content: serde_json::from_value(event.content.clone())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`.map_err(\|_\| Error::bad_database("Invalid event content in database"))?,`
			`}`
			`.into())`
			`}`

			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`get("/_matrix/client/r0/rooms/<_>/state/<_>", 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_state_events_for_empty_key_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Upgrade ruma … and refactor push rule code along the way. 2021-04-05 19:25:10 +00:00			`body: Ruma<get_state_events_for_key::Request<'_>>,`
			`) -> ConduitResult<get_state_events_for_key::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
Reformat imports and fix clippy warnings 2020-11-08 19:45:52 +00:00			`#[allow(clippy::blocks_in_if_conditions)]`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`// Users not in the room should not be able to access the state unless history_visibility is`
			`// WorldReadable`
Update ruma to latest, fix unstable origin feature in ruma 2020-10-27 23:10:09 +00:00			`if !db.rooms.is_joined(sender_user, &body.room_id)?`
			`&& !matches!(`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`db.rooms`
			`.room_state_get(&body.room_id, &EventType::RoomHistoryVisibility, "")?`
improvement: optimize state storage 2021-03-17 21:30:25 +00:00			`.map(\|event\| {`
improvement: pdu cache, /sync cache 2021-06-30 07:52:01 +00:00			`serde_json::from_value::<HistoryVisibilityEventContent>(event.content.clone())`
Allow reading state if history_visibility is world readable See https://matrix.org/docs/spec/client_server/r0.6.1#id87 2020-10-18 14:19:14 +00:00			`.map_err(\|_\| {`
			`Error::bad_database(`
			`"Invalid room history visibility event in database.",`
			`)`
			`})`
			`.map(\|e\| e.history_visibility)`
			`}),`
			`Some(Ok(HistoryVisibility::WorldReadable))`
Update ruma to latest, fix unstable origin feature in ruma 2020-10-27 23:10:09 +00:00			`)`
			`{`
			`return Err(Error::BadRequest(`
			`ErrorKind::Forbidden,`
			`"You don't have permission to view the room state.",`
			`));`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`

			`let event = db`
			`.rooms`
			`.room_state_get(&body.room_id, &body.event_type, "")?`
			`.ok_or(Error::BadRequest(`
			`ErrorKind::NotFound,`
			`"State event not found.",`
improvement: optimize state storage 2021-03-17 21:30:25 +00:00			`))?;`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
Upgrade ruma … and refactor push rule code along the way. 2021-04-05 19:25:10 +00:00			`Ok(get_state_events_for_key::Response {`
improvement: pdu cache, /sync cache 2021-06-30 07:52:01 +00:00			`content: serde_json::from_value(event.content.clone())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`.map_err(\|_\| Error::bad_database("Invalid event content in database"))?,`
			`}`
			`.into())`
			`}`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00
feat: send messages over federation 2020-09-14 18:23:19 +00:00			`pub async fn send_state_event_for_key_helper(`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00			`db: &Database,`
			`sender: &UserId,`
			`room_id: &RoomId,`
improvement: update ruma 2021-04-22 09:26:20 +00:00			`event_type: EventType,`
			`json: &Raw<AnyStateEventContent>,`
			`state_key: String,`
Fix review issues, move state-res to spec-comp branch 2020-08-26 15:15:52 +00:00			`) -> Result<EventId> {`
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 = sender;`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00
improvement: update ruma 2021-04-22 09:26:20 +00:00			`if let Ok(canonical_alias) =`
			`serde_json::from_str::<CanonicalAliasEventContent>(json.json().get())`
			`{`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00			`let mut aliases = canonical_alias.alt_aliases.clone();`

improvement: update ruma 2021-04-22 09:26:20 +00:00			`if let Some(alias) = canonical_alias.alias {`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00			`aliases.push(alias);`
			`}`

			`for alias in aliases {`
			`if alias.server_name() != db.globals.server_name()`
			`\|\| db`
			`.rooms`
			`.id_from_alias(&alias)?`
			`.filter(\|room\| room == room_id) // Make sure it's the right room`
			`.is_none()`
			`{`
			`return Err(Error::BadRequest(`
			`ErrorKind::Forbidden,`
			`"You are only allowed to send canonical_alias \`
			`events when it's aliases already exists",`
			`));`
			`}`
			`}`
			`}`

feat: admin room 2020-10-05 20:19:22 +00:00			`let event_id = db.rooms.build_and_append_pdu(`
			`PduBuilder {`
improvement: update ruma 2021-04-22 09:26:20 +00:00			`event_type,`
			`content: serde_json::from_str(json.json().get()).expect("content is valid json"),`
feat: admin room 2020-10-05 20:19:22 +00:00			`unsigned: None,`
improvement: update ruma 2021-04-22 09:26:20 +00:00			`state_key: Some(state_key),`
feat: admin room 2020-10-05 20:19:22 +00:00			`redacts: 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,`
feat: admin room 2020-10-05 20:19:22 +00:00			`&room_id,`
Fix ALL clippy warnings 2021-01-15 16:05:57 +00:00			`&db,`
feat: admin room 2020-10-05 20:19:22 +00:00			`)?;`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00
Fix review issues, move state-res to spec-comp branch 2020-08-26 15:15:52 +00:00			`Ok(event_id)`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00			`}`