char
/
conduit
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
conduit/src/client_server/push.rs

715 lines
21 KiB
Rust
Raw Normal View History

refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
use super::State;
use crate::{ConduitResult, Database, Error, Ruma};
use ruma::{
api::client::{
error::ErrorKind,
feature: push rule settings
2021-01-24 15:05:52 +00:00
r0::push::{
delete_pushrule, get_pushers, get_pushrule, get_pushrule_actions, get_pushrule_enabled,
Run cargo fmt using nightly
2021-01-27 02:53:03 +00:00
get_pushrules_all, set_pusher, set_pushrule, set_pushrule_actions,
set_pushrule_enabled, RuleKind,
feature: push rule settings
2021-01-24 15:05:52 +00:00
},
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
},
Run cargo fmt using nightly
2021-01-27 02:53:03 +00:00
events::{push_rules, EventType},
feature: push rule settings
2021-01-24 15:05:52 +00:00
push::{
ConditionalPushRuleInit, ContentPushRule, OverridePushRule, PatternedPushRuleInit,
RoomPushRule, SenderPushRule, SimplePushRuleInit, UnderridePushRule,
},
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
};
#[cfg(feature = "conduit_bin")]
feature: push rule settings
2021-01-24 15:05:52 +00:00
use rocket::{delete, get, post, put};
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
#[cfg_attr(
feature = "conduit_bin",
get("/_matrix/client/r0/pushrules", 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_pushrules_all_route(
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
db: State<'_, Database>,
body: Ruma<get_pushrules_all::Request>,
) -> ConduitResult<get_pushrules_all::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 event = db
.account_data
Run cargo fmt using nightly
2021-01-27 02:53:03 +00:00
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
))?;
Ok(get_pushrules_all::Response {
global: event.content.global,
}
.into())
}
feature: push rule settings
2021-01-24 15:05:52 +00:00
#[cfg_attr(
feature = "conduit_bin",
get("/_matrix/client/r0/pushrules/<_>/<_>/<_>", data = "<body>")
)]
feat: opentelemetry/jaeger support
2021-02-28 11:41:03 +00:00
#[tracing::instrument(skip(db, body))]
feature: push rule settings
2021-01-24 15:05:52 +00:00
pub async fn get_pushrule_route(
db: State<'_, Database>,
body: Ruma<get_pushrule::Request<'_>>,
) -> ConduitResult<get_pushrule::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = db
.account_data
Run cargo fmt using nightly
2021-01-27 02:53:03 +00:00
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
feature: push rule settings
2021-01-24 15:05:52 +00:00
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
))?;
let global = event.content.global;
let rule = match body.kind {
RuleKind::Override => global
.override_
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.clone().into()),
RuleKind::Underride => global
.underride
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.clone().into()),
RuleKind::Sender => global
.sender
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.clone().into()),
RuleKind::Room => global
.room
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.clone().into()),
RuleKind::Content => global
.content
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.clone().into()),
RuleKind::_Custom(_) => None,
};
if let Some(rule) = rule {
Ok(get_pushrule::Response { rule }.into())
} else {
Prevent admin room from recursively spamming itself and user -> user
2021-01-29 19:19:56 +00:00
Err(Error::BadRequest(
ErrorKind::NotFound,
"Push rule not found.",
))
feature: push rule settings
2021-01-24 15:05:52 +00:00
}
}
#[cfg_attr(
feature = "conduit_bin",
put("/_matrix/client/r0/pushrules/<_>/<_>/<_>", 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_pushrule_route(
db: State<'_, Database>,
feature: push rule settings
2021-01-24 15:05:52 +00:00
body: Ruma<set_pushrule::Request<'_>>,
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
) -> ConduitResult<set_pushrule::Response> {
feature: push rule settings
2021-01-24 15:05:52 +00:00
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != "global" {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
"Scopes other than 'global' are not supported.",
));
}
let mut event = db
.account_data
Run cargo fmt using nightly
2021-01-27 02:53:03 +00:00
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
feature: push rule settings
2021-01-24 15:05:52 +00:00
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
))?;
let global = &mut event.content.global;
match body.kind {
RuleKind::Override => {
if let Some(rule) = global
.override_
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.override_.remove(&rule);
}
global.override_.insert(OverridePushRule(
ConditionalPushRuleInit {
actions: body.actions.clone(),
default: false,
enabled: true,
rule_id: body.rule_id.clone(),
conditions: body.conditions.clone(),
}
.into(),
));
}
RuleKind::Underride => {
if let Some(rule) = global
.underride
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.underride.remove(&rule);
}
global.underride.insert(UnderridePushRule(
ConditionalPushRuleInit {
actions: body.actions.clone(),
default: false,
enabled: true,
rule_id: body.rule_id.clone(),
conditions: body.conditions.clone(),
}
.into(),
));
}
RuleKind::Sender => {
if let Some(rule) = global
.sender
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.sender.remove(&rule);
}
global.sender.insert(SenderPushRule(
SimplePushRuleInit {
actions: body.actions.clone(),
default: false,
enabled: true,
rule_id: body.rule_id.clone(),
}
.into(),
));
}
RuleKind::Room => {
if let Some(rule) = global
.room
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.room.remove(&rule);
}
global.room.insert(RoomPushRule(
SimplePushRuleInit {
actions: body.actions.clone(),
default: false,
enabled: true,
rule_id: body.rule_id.clone(),
}
.into(),
));
}
RuleKind::Content => {
if let Some(rule) = global
.content
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.content.remove(&rule);
}
global.content.insert(ContentPushRule(
PatternedPushRuleInit {
actions: body.actions.clone(),
default: false,
enabled: true,
rule_id: body.rule_id.clone(),
pattern: body.pattern.clone().unwrap_or_default(),
}
.into(),
));
}
RuleKind::_Custom(_) => {}
}
db.account_data.update(
None,
&sender_user,
EventType::PushRules,
&event,
&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_pushrule::Response.into())
}
#[cfg_attr(
feature = "conduit_bin",
feature: push rule settings
2021-01-24 15:05:52 +00:00
get("/_matrix/client/r0/pushrules/<_>/<_>/<_>/actions", data = "<body>")
)]
feat: opentelemetry/jaeger support
2021-02-28 11:41:03 +00:00
#[tracing::instrument(skip(db, body))]
feature: push rule settings
2021-01-24 15:05:52 +00:00
pub async fn get_pushrule_actions_route(
db: State<'_, Database>,
body: Ruma<get_pushrule_actions::Request<'_>>,
) -> ConduitResult<get_pushrule_actions::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != "global" {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
"Scopes other than 'global' are not supported.",
));
}
let mut event = db
.account_data
Run cargo fmt using nightly
2021-01-27 02:53:03 +00:00
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
feature: push rule settings
2021-01-24 15:05:52 +00:00
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
))?;
let global = &mut event.content.global;
let actions = match body.kind {
RuleKind::Override => global
.override_
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.actions.clone()),
RuleKind::Underride => global
.underride
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.actions.clone()),
RuleKind::Sender => global
.sender
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.actions.clone()),
RuleKind::Room => global
.room
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.actions.clone()),
RuleKind::Content => global
.content
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map(|rule| rule.0.actions.clone()),
RuleKind::_Custom(_) => None,
};
db.flush().await?;
Ok(get_pushrule_actions::Response {
actions: actions.unwrap_or_default(),
}
.into())
}
#[cfg_attr(
feature = "conduit_bin",
put("/_matrix/client/r0/pushrules/<_>/<_>/<_>/actions", data = "<body>")
)]
feat: opentelemetry/jaeger support
2021-02-28 11:41:03 +00:00
#[tracing::instrument(skip(db, body))]
feature: push rule settings
2021-01-24 15:05:52 +00:00
pub async fn set_pushrule_actions_route(
db: State<'_, Database>,
body: Ruma<set_pushrule_actions::Request<'_>>,
) -> ConduitResult<set_pushrule_actions::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != "global" {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
"Scopes other than 'global' are not supported.",
));
}
let mut event = db
.account_data
Run cargo fmt using nightly
2021-01-27 02:53:03 +00:00
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
feature: push rule settings
2021-01-24 15:05:52 +00:00
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
))?;
let global = &mut event.content.global;
match body.kind {
RuleKind::Override => {
if let Some(mut rule) = global
.override_
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.override_.remove(&rule);
rule.0.actions = body.actions.clone();
global.override_.insert(rule);
}
}
RuleKind::Underride => {
if let Some(mut rule) = global
.underride
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.underride.remove(&rule);
rule.0.actions = body.actions.clone();
global.underride.insert(rule);
}
}
RuleKind::Sender => {
if let Some(mut rule) = global
.sender
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.sender.remove(&rule);
rule.0.actions = body.actions.clone();
global.sender.insert(rule);
}
}
RuleKind::Room => {
if let Some(mut rule) = global
.room
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.room.remove(&rule);
rule.0.actions = body.actions.clone();
global.room.insert(rule);
}
}
RuleKind::Content => {
if let Some(mut rule) = global
.content
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.content.remove(&rule);
rule.0.actions = body.actions.clone();
global.content.insert(rule);
}
}
RuleKind::_Custom(_) => {}
};
db.account_data.update(
None,
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.flush().await?;
Ok(set_pushrule_actions::Response.into())
}
#[cfg_attr(
feature = "conduit_bin",
get("/_matrix/client/r0/pushrules/<_>/<_>/<_>/enabled", data = "<body>")
)]
feat: opentelemetry/jaeger support
2021-02-28 11:41:03 +00:00
#[tracing::instrument(skip(db, body))]
feature: push rule settings
2021-01-24 15:05:52 +00:00
pub async fn get_pushrule_enabled_route(
db: State<'_, Database>,
body: Ruma<get_pushrule_enabled::Request<'_>>,
) -> ConduitResult<get_pushrule_enabled::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != "global" {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
"Scopes other than 'global' are not supported.",
));
}
let mut event = db
.account_data
Run cargo fmt using nightly
2021-01-27 02:53:03 +00:00
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
feature: push rule settings
2021-01-24 15:05:52 +00:00
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
))?;
let global = &mut event.content.global;
let enabled = match body.kind {
RuleKind::Override => global
.override_
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map_or(false, |rule| rule.0.enabled),
RuleKind::Underride => global
.underride
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map_or(false, |rule| rule.0.enabled),
RuleKind::Sender => global
.sender
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map_or(false, |rule| rule.0.enabled),
RuleKind::Room => global
.room
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map_or(false, |rule| rule.0.enabled),
RuleKind::Content => global
.content
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.map_or(false, |rule| rule.0.enabled),
RuleKind::_Custom(_) => false,
};
db.flush().await?;
Ok(get_pushrule_enabled::Response { enabled }.into())
}
#[cfg_attr(
feature = "conduit_bin",
put("/_matrix/client/r0/pushrules/<_>/<_>/<_>/enabled", data = "<body>")
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
)]
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_pushrule_enabled_route(
db: State<'_, Database>,
feature: push rule settings
2021-01-24 15:05:52 +00:00
body: Ruma<set_pushrule_enabled::Request<'_>>,
improvement: flush after every request that manipulates the db
2020-10-21 19:28:02 +00:00
) -> ConduitResult<set_pushrule_enabled::Response> {
feature: push rule settings
2021-01-24 15:05:52 +00:00
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != "global" {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
"Scopes other than 'global' are not supported.",
));
}
let mut event = db
.account_data
feature: push rule settings
2021-01-24 15:05:52 +00:00
.get::<ruma::events::push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
feature: push rule settings
2021-01-24 15:05:52 +00:00
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
))?;
let global = &mut event.content.global;
match body.kind {
RuleKind::Override => {
if let Some(mut rule) = global
.override_
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.override_.remove(&rule);
rule.0.enabled = body.enabled;
global.override_.insert(rule);
}
}
RuleKind::Underride => {
if let Some(mut rule) = global
.underride
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.underride.remove(&rule);
rule.0.enabled = body.enabled;
global.underride.insert(rule);
}
}
RuleKind::Sender => {
if let Some(mut rule) = global
.sender
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.sender.remove(&rule);
rule.0.enabled = body.enabled;
global.sender.insert(rule);
}
}
RuleKind::Room => {
if let Some(mut rule) = global
.room
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.room.remove(&rule);
rule.0.enabled = body.enabled;
global.room.insert(rule);
}
}
RuleKind::Content => {
if let Some(mut rule) = global
.content
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.content.remove(&rule);
rule.0.enabled = body.enabled;
global.content.insert(rule);
}
}
RuleKind::_Custom(_) => {}
}
db.account_data.update(
None,
&sender_user,
EventType::PushRules,
&event,
&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_pushrule_enabled::Response.into())
}
feature: push rule settings
2021-01-24 15:05:52 +00:00
#[cfg_attr(
feature = "conduit_bin",
delete("/_matrix/client/r0/pushrules/<_>/<_>/<_>", data = "<body>")
)]
feat: opentelemetry/jaeger support
2021-02-28 11:41:03 +00:00
#[tracing::instrument(skip(db, body))]
feature: push rule settings
2021-01-24 15:05:52 +00:00
pub async fn delete_pushrule_route(
db: State<'_, Database>,
body: Ruma<delete_pushrule::Request<'_>>,
) -> ConduitResult<delete_pushrule::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != "global" {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
"Scopes other than 'global' are not supported.",
));
}
let mut event = db
.account_data
Run cargo fmt using nightly
2021-01-27 02:53:03 +00:00
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
feature: push rule settings
2021-01-24 15:05:52 +00:00
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
))?;
let global = &mut event.content.global;
match body.kind {
RuleKind::Override => {
if let Some(rule) = global
.override_
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.override_.remove(&rule);
}
}
RuleKind::Underride => {
if let Some(rule) = global
.underride
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.underride.remove(&rule);
}
}
RuleKind::Sender => {
if let Some(rule) = global
.sender
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.sender.remove(&rule);
}
}
RuleKind::Room => {
if let Some(rule) = global
.room
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.room.remove(&rule);
}
}
RuleKind::Content => {
if let Some(rule) = global
.content
.iter()
.find(|rule| rule.0.rule_id == body.rule_id)
.cloned()
{
global.content.remove(&rule);
}
}
RuleKind::_Custom(_) => {}
}
db.account_data.update(
None,
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.flush().await?;
Ok(delete_pushrule::Response.into())
}
WIP: send out push notification, impl pusher routes It seems in order to test this I may also have to impl the email 3pid route? I need to call the set_pusher route somehow.
2021-01-27 02:54:35 +00:00
#[cfg_attr(
feature = "conduit_bin",
get("/_matrix/client/r0/pushers", data = "<body>")
)]
Merge branch 'correct-sendtxn' into pushers
2021-03-15 08:48:19 +00:00
#[tracing::instrument(skip(db, body))]
WIP: send out push notification, impl pusher routes It seems in order to test this I may also have to impl the email 3pid route? I need to call the set_pusher route somehow.
2021-01-27 02:54:35 +00:00
pub async fn get_pushers_route(
db: State<'_, Database>,
body: Ruma<get_pushers::Request>,
) -> ConduitResult<get_pushers::Response> {
fix: multiple federation/pusher fixes
2021-03-16 17:00:26 +00:00
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
WIP: send out push notification, impl pusher routes It seems in order to test this I may also have to impl the email 3pid route? I need to call the set_pusher route somehow.
2021-01-27 02:54:35 +00:00
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
Ok(get_pushers::Response {
fix: signature key fetching, optimize push sending
2021-03-22 13:04:11 +00:00
pushers: db.pusher.get_pushers(sender_user)?,
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
}
.into())
}
WIP: send out push notification, impl pusher routes It seems in order to test this I may also have to impl the email 3pid route? I need to call the set_pusher route somehow.
2021-01-27 02:54:35 +00:00
#[cfg_attr(
feature = "conduit_bin",
post("/_matrix/client/r0/pushers/set", data = "<body>")
)]
Merge branch 'correct-sendtxn' into pushers
2021-03-15 08:48:19 +00:00
#[tracing::instrument(skip(db, body))]
WIP: send out push notification, impl pusher routes It seems in order to test this I may also have to impl the email 3pid route? I need to call the set_pusher route somehow.
2021-01-27 02:54:35 +00:00
pub async fn set_pushers_route(
db: State<'_, Database>,
body: Ruma<set_pusher::Request>,
) -> ConduitResult<set_pusher::Response> {
fix: multiple federation/pusher fixes
2021-03-16 17:00:26 +00:00
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
WIP: send out push notification, impl pusher routes It seems in order to test this I may also have to impl the email 3pid route? I need to call the set_pusher route somehow.
2021-01-27 02:54:35 +00:00
let pusher = body.pusher.clone();
fix: multiple federation/pusher fixes
2021-03-16 17:00:26 +00:00
db.pusher.set_pusher(sender_user, pusher)?;
WIP: send out push notification, impl pusher routes It seems in order to test this I may also have to impl the email 3pid route? I need to call the set_pusher route somehow.
2021-01-27 02:54:35 +00:00
improvement: flush after every request that manipulates the db
2020-10-21 19:28:02 +00:00
db.flush().await?;
WIP: send out push notification, impl pusher routes It seems in order to test this I may also have to impl the email 3pid route? I need to call the set_pusher route somehow.
2021-01-27 02:54:35 +00:00
Ok(set_pusher::Response::default().into())
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
}