magmaus3/continuwuity
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Clean up (mostly automated with cargo clippy --fix)

Browse source
This commit is contained in:
Jonas Platte 2021-09-13 19:45:56 +02:00
parent 979ec6b4fa
commit d68c93b5fa
No known key found for this signature in database
GPG key ID: CC154DE0E30B7C67
36 changed files with 364 additions and 393 deletions
Download patch file Download diff file Expand all files Collapse all files

24
src/client_server/account.rs
View file

@ -572,7 +572,7 @@ pub async fn change_password_route(
if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user,
sender_user,
sender_device,
auth,
&uiaainfo,
@ -586,24 +586,24 @@ pub async fn change_password_route(
} else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?;
.create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo));
} else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
}
db.users
.set_password(&sender_user, Some(&body.new_password))?;
.set_password(sender_user, Some(&body.new_password))?;
if body.logout_devices {
// Logout all devices except the current one
for id in db
.users
.all_device_ids(&sender_user)
.all_device_ids(sender_user)
.filter_map(|id| id.ok())
.filter(|id| id != sender_device)
{
db.users.remove_device(&sender_user, &id)?;
db.users.remove_device(sender_user, &id)?;
}
}
@ -664,8 +664,8 @@ pub async fn deactivate_route(
if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user,
&sender_device,
sender_user,
sender_device,
auth,
&uiaainfo,
&db.users,
@ -678,7 +678,7 @@ pub async fn deactivate_route(
} else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?;
.create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo));
} else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
@ -688,10 +688,10 @@ pub async fn deactivate_route(
// TODO: work over federation invites
let all_rooms = db
.rooms
.rooms_joined(&sender_user)
.rooms_joined(sender_user)
.chain(
db.rooms
.rooms_invited(&sender_user)
.rooms_invited(sender_user)
.map(|t| t.map(|(r, _)| r)),
)
.collect::<Vec<_>>();
@ -726,7 +726,7 @@ pub async fn deactivate_route(
state_key: Some(sender_user.to_string()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -734,7 +734,7 @@ pub async fn deactivate_route(
}
// Remove devices and mark account as deactivated
db.users.deactivate_account(&sender_user)?;
db.users.deactivate_account(sender_user)?;
info!("{} deactivated their account", sender_user);

4
src/client_server/alias.rs
View file

@ -112,7 +112,7 @@ pub(crate) async fn get_alias_helper(
}
let mut room_id = None;
match db.rooms.id_from_alias(&room_alias)? {
match db.rooms.id_from_alias(room_alias)? {
Some(r) => room_id = Some(r),
None => {
for (_id, registration) in db.appservice.all()? {
@ -140,7 +140,7 @@ pub(crate) async fn get_alias_helper(
.await
.is_ok()
{
room_id = Some(db.rooms.id_from_alias(&room_alias)?.ok_or_else(|| {
room_id = Some(db.rooms.id_from_alias(room_alias)?.ok_or_else(|| {
Error::bad_config("Appservice lied to us. Room does not exist.")
})?);
break;

39
src/client_server/backup.rs
View file

@ -27,7 +27,7 @@ pub async fn create_backup_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let version = db
.key_backups
.create_backup(&sender_user, &body.algorithm, &db.globals)?;
.create_backup(sender_user, &body.algorithm, &db.globals)?;
db.flush()?;
@ -48,7 +48,7 @@ pub async fn update_backup_route(
) -> ConduitResult<update_backup::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups
.update_backup(&sender_user, &body.version, &body.algorithm, &db.globals)?;
.update_backup(sender_user, &body.version, &body.algorithm, &db.globals)?;
db.flush()?;
@ -71,7 +71,7 @@ pub async fn get_latest_backup_route(
let (version, algorithm) =
db.key_backups
.get_latest_backup(&sender_user)?
.get_latest_backup(sender_user)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"Key backup does not exist.",
@ -101,7 +101,7 @@ pub async fn get_backup_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let algorithm = db
.key_backups
.get_backup(&sender_user, &body.version)?
.get_backup(sender_user, &body.version)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"Key backup does not exist.",
@ -132,7 +132,7 @@ pub async fn delete_backup_route(
) -> ConduitResult<delete_backup::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups.delete_backup(&sender_user, &body.version)?;
db.key_backups.delete_backup(sender_user, &body.version)?;
db.flush()?;
@ -172,11 +172,11 @@ pub async fn add_backup_keys_route(
for (room_id, room) in &body.rooms {
for (session_id, key_data) in &room.sessions {
db.key_backups.add_key(
&sender_user,
sender_user,
&body.version,
&room_id,
&session_id,
&key_data,
room_id,
session_id,
key_data,
&db.globals,
)?
}
@ -223,11 +223,11 @@ pub async fn add_backup_key_sessions_route(
for (session_id, key_data) in &body.sessions {
db.key_backups.add_key(
&sender_user,
sender_user,
&body.version,
&body.room_id,
&session_id,
&key_data,
session_id,
key_data,
&db.globals,
)?
}
@ -272,7 +272,7 @@ pub async fn add_backup_key_session_route(
}
db.key_backups.add_key(
&sender_user,
sender_user,
&body.version,
&body.room_id,
&body.session_id,
@ -303,7 +303,7 @@ pub async fn get_backup_keys_route(
) -> ConduitResult<get_backup_keys::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let rooms = db.key_backups.get_all(&sender_user, &body.version)?;
let rooms = db.key_backups.get_all(sender_user, &body.version)?;
Ok(get_backup_keys::Response { rooms }.into())
}
@ -324,7 +324,7 @@ pub async fn get_backup_key_sessions_route(
let sessions = db
.key_backups
.get_room(&sender_user, &body.version, &body.room_id)?;
.get_room(sender_user, &body.version, &body.room_id)?;
Ok(get_backup_key_sessions::Response { sessions }.into())
}
@ -345,7 +345,7 @@ pub async fn get_backup_key_session_route(
let key_data = db
.key_backups
.get_session(&sender_user, &body.version, &body.room_id, &body.session_id)?
.get_session(sender_user, &body.version, &body.room_id, &body.session_id)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"Backup key not found for this user's session.",
@ -368,8 +368,7 @@ pub async fn delete_backup_keys_route(
) -> ConduitResult<delete_backup_keys::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups
.delete_all_keys(&sender_user, &body.version)?;
db.key_backups.delete_all_keys(sender_user, &body.version)?;
db.flush()?;
@ -395,7 +394,7 @@ pub async fn delete_backup_key_sessions_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups
.delete_room_keys(&sender_user, &body.version, &body.room_id)?;
.delete_room_keys(sender_user, &body.version, &body.room_id)?;
db.flush()?;
@ -421,7 +420,7 @@ pub async fn delete_backup_key_session_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.key_backups
.delete_room_key(&sender_user, &body.version, &body.room_id, &body.session_id)?;
.delete_room_key(sender_user, &body.version, &body.room_id, &body.session_id)?;
db.flush()?;

3
src/client_server/capabilities.rs
View file

@ -1,5 +1,4 @@
use crate::ConduitResult;
use crate::Ruma;
use crate::{ConduitResult, Ruma};
use ruma::{
api::client::r0::capabilities::{
get_capabilities, Capabilities, RoomVersionStability, RoomVersionsCapability,

4
src/client_server/context.rs
View file

@ -50,7 +50,7 @@ pub async fn get_context_route(
let events_before = db
.rooms
.pdus_until(&sender_user, &body.room_id, base_token)?
.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.")
@ -72,7 +72,7 @@ pub async fn get_context_route(
let events_after = db
.rooms
.pdus_after(&sender_user, &body.room_id, base_token)?
.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.")

22
src/client_server/device.rs
View file

@ -50,7 +50,7 @@ pub async fn get_device_route(
let device = db
.users
.get_device_metadata(&sender_user, &body.body.device_id)?
.get_device_metadata(sender_user, &body.body.device_id)?
.ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;
Ok(get_device::Response { device }.into())
@ -72,13 +72,13 @@ pub async fn update_device_route(
let mut device = db
.users
.get_device_metadata(&sender_user, &body.device_id)?
.get_device_metadata(sender_user, &body.device_id)?
.ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;
device.display_name = body.display_name.clone();
db.users
.update_device_metadata(&sender_user, &body.device_id, &device)?;
.update_device_metadata(sender_user, &body.device_id, &device)?;
db.flush()?;
@ -119,8 +119,8 @@ pub async fn delete_device_route(
if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user,
&sender_device,
sender_user,
sender_device,
auth,
&uiaainfo,
&db.users,
@ -133,13 +133,13 @@ pub async fn delete_device_route(
} else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?;
.create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo));
} else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
}
db.users.remove_device(&sender_user, &body.device_id)?;
db.users.remove_device(sender_user, &body.device_id)?;
db.flush()?;
@ -182,8 +182,8 @@ pub async fn delete_devices_route(
if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user,
&sender_device,
sender_user,
sender_device,
auth,
&uiaainfo,
&db.users,
@ -196,14 +196,14 @@ pub async fn delete_devices_route(
} else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?;
.create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo));
} else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
}
for device_id in &body.devices {
db.users.remove_device(&sender_user, &device_id)?
db.users.remove_device(sender_user, device_id)?
}
db.flush()?;

18
src/client_server/keys.rs
View file

@ -158,8 +158,8 @@ pub async fn upload_signing_keys_route(
if let Some(auth) = &body.auth {
let (worked, uiaainfo) = db.uiaa.try_auth(
&sender_user,
&sender_device,
sender_user,
sender_device,
auth,
&uiaainfo,
&db.users,
@ -172,7 +172,7 @@ pub async fn upload_signing_keys_route(
} else if let Some(json) = body.json_body {
uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
db.uiaa
.create(&sender_user, &sender_device, &uiaainfo, &json)?;
.create(sender_user, sender_device, &uiaainfo, &json)?;
return Err(Error::Uiaa(uiaainfo));
} else {
return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
@ -181,7 +181,7 @@ pub async fn upload_signing_keys_route(
if let Some(master_key) = &body.master_key {
db.users.add_cross_signing_keys(
sender_user,
&master_key,
master_key,
&body.self_signing_key,
&body.user_signing_key,
&db.rooms,
@ -242,10 +242,10 @@ pub async fn upload_signatures_route(
.to_owned(),
);
db.users.sign_key(
&user_id,
&key_id,
user_id,
key_id,
signature,
&sender_user,
sender_user,
&db.rooms,
&db.globals,
)?;
@ -359,8 +359,8 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
} else {
for device_id in device_ids {
let mut container = BTreeMap::new();
if let Some(mut keys) = db.users.get_device_keys(&user_id.clone(), &device_id)? {
let metadata = db.users.get_device_metadata(user_id, &device_id)?.ok_or(
if let Some(mut keys) = db.users.get_device_keys(&user_id.clone(), device_id)? {
let metadata = db.users.get_device_metadata(user_id, device_id)?.ok_or(
Error::BadRequest(
ErrorKind::InvalidParam,
"Tried to get keys for nonexistent device.",

3
src/client_server/media.rs
View file

@ -1,5 +1,6 @@
use crate::{
database::media::FileMeta, database::DatabaseGuard, utils, ConduitResult, Error, Ruma,
database::{media::FileMeta, DatabaseGuard},
utils, ConduitResult, Error, Ruma,
};
use ruma::api::client::{
error::ErrorKind,

66
src/client_server/membership.rs
View file

@ -56,7 +56,7 @@ pub async fn join_room_by_id_route(
let mut servers = db
.rooms
.invite_state(&sender_user, &body.room_id)?
.invite_state(sender_user, &body.room_id)?
.unwrap_or_default()
.iter()
.filter_map(|event| {
@ -105,7 +105,7 @@ pub async fn join_room_by_id_or_alias_route(
Ok(room_id) => {
let mut servers = db
.rooms
.invite_state(&sender_user, &room_id)?
.invite_state(sender_user, &room_id)?
.unwrap_or_default()
.iter()
.filter_map(|event| {
@ -243,7 +243,7 @@ pub async fn kick_user_route(
state_key: Some(body.user_id.to_string()),
redacts: None,
},
&sender_user,
sender_user,
&body.room_id,
&db,
&state_lock,
@ -319,7 +319,7 @@ pub async fn ban_user_route(
state_key: Some(body.user_id.to_string()),
redacts: None,
},
&sender_user,
sender_user,
&body.room_id,
&db,
&state_lock,
@ -384,7 +384,7 @@ pub async fn unban_user_route(
state_key: Some(body.user_id.to_string()),
redacts: None,
},
&sender_user,
sender_user,
&body.room_id,
&db,
&state_lock,
@ -416,7 +416,7 @@ pub async fn forget_room_route(
) -> ConduitResult<forget_room::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.rooms.forget(&body.room_id, &sender_user)?;
db.rooms.forget(&body.room_id, sender_user)?;
db.flush()?;
@ -440,7 +440,7 @@ pub async fn joined_rooms_route(
Ok(joined_rooms::Response {
joined_rooms: db
.rooms
.rooms_joined(&sender_user)
.rooms_joined(sender_user)
.filter_map(|r| r.ok())
.collect(),
}
@ -500,7 +500,7 @@ pub async fn joined_members_route(
) -> ConduitResult<joined_members::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !db.rooms.is_joined(&sender_user, &body.room_id)? {
if !db.rooms.is_joined(sender_user, &body.room_id)? {
return Err(Error::BadRequest(
ErrorKind::Forbidden,
"You aren't a member of the room.",
@ -545,7 +545,7 @@ async fn join_room_by_id_helper(
let state_lock = mutex_state.lock().await;
// Ask a remote server if we don't have this room
if !db.rooms.exists(&room_id)? && room_id.server_name() != db.globals.server_name() {
if !db.rooms.exists(room_id)? && room_id.server_name() != db.globals.server_name() {
let mut make_join_response_and_server = Err(Error::BadServerResponse(
"No server available to assist in joining.",
));
@ -606,11 +606,11 @@ async fn join_room_by_id_helper(
"content".to_owned(),
to_canonical_value(member::MemberEventContent {
membership: member::MembershipState::Join,
displayname: db.users.displayname(&sender_user)?,
avatar_url: db.users.avatar_url(&sender_user)?,
displayname: db.users.displayname(sender_user)?,
avatar_url: db.users.avatar_url(sender_user)?,
is_direct: None,
third_party_invite: None,
blurhash: db.users.blurhash(&sender_user)?,
blurhash: db.users.blurhash(sender_user)?,
reason: None,
})
.expect("event is valid, we just created it"),
@ -658,7 +658,7 @@ async fn join_room_by_id_helper(
)
.await?;
db.rooms.get_or_create_shortroomid(&room_id, &db.globals)?;
db.rooms.get_or_create_shortroomid(room_id, &db.globals)?;
let pdu = PduEvent::from_id_val(&event_id, join_event.clone())
.map_err(|_| Error::BadServerResponse("Invalid join event PDU."))?;
@ -670,7 +670,7 @@ async fn join_room_by_id_helper(
&send_join_response,
&room_version,
&pub_key_map,
&db,
db,
)
.await?;
@ -678,7 +678,7 @@ async fn join_room_by_id_helper(
.room_state
.state
.iter()
.map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map, &db))
.map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map, db))
{
let (event_id, value) = match result {
Ok(t) => t,
@ -724,14 +724,14 @@ async fn join_room_by_id_helper(
.into_iter()
.map(|(k, id)| db.rooms.compress_state_event(k, &id, &db.globals))
.collect::<Result<HashSet<_>>>()?,
&db,
db,
)?;
for result in send_join_response
.room_state
.auth_chain
.iter()
.map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map, &db))
.map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map, db))
{
let (event_id, value) = match result {
Ok(t) => t,
@ -754,15 +754,15 @@ async fn join_room_by_id_helper(
// We set the room state after inserting the pdu, so that we never have a moment in time
// where events in the current room state do not exist
db.rooms.set_room_state(&room_id, statehashid)?;
db.rooms.set_room_state(room_id, statehashid)?;
} else {
let event = member::MemberEventContent {
membership: member::MembershipState::Join,
displayname: db.users.displayname(&sender_user)?,
avatar_url: db.users.avatar_url(&sender_user)?,
displayname: db.users.displayname(sender_user)?,
avatar_url: db.users.avatar_url(sender_user)?,
is_direct: None,
third_party_invite: None,
blurhash: db.users.blurhash(&sender_user)?,
blurhash: db.users.blurhash(sender_user)?,
reason: None,
};
@ -774,9 +774,9 @@ async fn join_room_by_id_helper(
state_key: Some(sender_user.to_string()),
redacts: None,
},
&sender_user,
&room_id,
&db,
sender_user,
room_id,
db,
&state_lock,
)?;
}
@ -800,7 +800,7 @@ fn validate_and_add_event_id(
})?;
let event_id = EventId::try_from(&*format!(
"${}",
ruma::signatures::reference_hash(&value, &room_version)
ruma::signatures::reference_hash(&value, room_version)
.expect("ruma can calculate reference hashes")
))
.expect("ruma's reference hashes are valid event ids");
@ -927,7 +927,7 @@ pub(crate) async fn invite_helper<'a>(
let auth_events = db.rooms.get_auth_events(
room_id,
&kind,
&sender_user,
sender_user,
Some(&state_key),
&content,
)?;
@ -1074,10 +1074,10 @@ pub(crate) async fn invite_helper<'a>(
let pdu_id = server_server::handle_incoming_pdu(
&origin,
&event_id,
&room_id,
room_id,
value,
true,
&db,
db,
&pub_key_map,
)
.await
@ -1119,11 +1119,11 @@ pub(crate) async fn invite_helper<'a>(
event_type: EventType::RoomMember,
content: serde_json::to_value(member::MemberEventContent {
membership: member::MembershipState::Invite,
displayname: db.users.displayname(&user_id)?,
avatar_url: db.users.avatar_url(&user_id)?,
displayname: db.users.displayname(user_id)?,
avatar_url: db.users.avatar_url(user_id)?,
is_direct: Some(is_direct),
third_party_invite: None,
blurhash: db.users.blurhash(&user_id)?,
blurhash: db.users.blurhash(user_id)?,
reason: None,
})
.expect("event is valid, we just created it"),
@ -1131,9 +1131,9 @@ pub(crate) async fn invite_helper<'a>(
state_key: Some(user_id.to_string()),
redacts: None,
},
&sender_user,
sender_user,
room_id,
&db,
db,
&state_lock,
)?;

6
src/client_server/message.rs
View file

@ -79,7 +79,7 @@ pub async fn send_message_event_route(
state_key: None,
redacts: None,
},
&sender_user,
sender_user,
&body.room_id,
&db,
&state_lock,
@ -141,7 +141,7 @@ pub async fn get_message_events_route(
get_message_events::Direction::Forward => {
let events_after = db
.rooms
.pdus_after(&sender_user, &body.room_id, from)?
.pdus_after(sender_user, &body.room_id, from)?
.take(limit)
.filter_map(|r| r.ok()) // Filter out buggy events
.filter_map(|(pdu_id, pdu)| {
@ -171,7 +171,7 @@ pub async fn get_message_events_route(
get_message_events::Direction::Backward => {
let events_before = db
.rooms
.pdus_until(&sender_user, &body.room_id, from)?
.pdus_until(sender_user, &body.room_id, from)?
.take(limit)
.filter_map(|r| r.ok()) // Filter out buggy events
.filter_map(|(pdu_id, pdu)| {

10
src/client_server/presence.rs
View file

@ -19,17 +19,17 @@ pub async fn set_presence_route(
) -> ConduitResult<set_presence::Response> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
for room_id in db.rooms.rooms_joined(&sender_user) {
for room_id in db.rooms.rooms_joined(sender_user) {
let room_id = room_id?;
db.rooms.edus.update_presence(
&sender_user,
sender_user,
&room_id,
ruma::events::presence::PresenceEvent {
content: ruma::events::presence::PresenceEventContent {
avatar_url: db.users.avatar_url(&sender_user)?,
avatar_url: db.users.avatar_url(sender_user)?,
currently_active: None,
displayname: db.users.displayname(&sender_user)?,
displayname: db.users.displayname(sender_user)?,
last_active_ago: Some(
utils::millis_since_unix_epoch()
.try_into()
@ -76,7 +76,7 @@ pub async fn get_presence_route(
if let Some(presence) = db
.rooms
.edus
.get_last_presence_event(&sender_user, &room_id)?
.get_last_presence_event(sender_user, &room_id)?
{
presence_event = Some(presence);
break;

34
src/client_server/profile.rs
View file

@ -34,12 +34,12 @@ pub async fn set_displayname_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.users
.set_displayname(&sender_user, body.displayname.clone())?;
.set_displayname(sender_user, body.displayname.clone())?;
// Send a new membership event and presence update into all joined rooms
let all_rooms_joined: Vec<_> = db
.rooms
.rooms_joined(&sender_user)
.rooms_joined(sender_user)
.filter_map(|r| r.ok())
.map(|room_id| {
Ok::<_, Error>((
@ -89,19 +89,19 @@ pub async fn set_displayname_route(
);
let state_lock = mutex_state.lock().await;
let _ =
db.rooms
.build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock);
let _ = db
.rooms
.build_and_append_pdu(pdu_builder, sender_user, &room_id, &db, &state_lock);
// Presence update
db.rooms.edus.update_presence(
&sender_user,
sender_user,
&room_id,
ruma::events::presence::PresenceEvent {
content: ruma::events::presence::PresenceEventContent {
avatar_url: db.users.avatar_url(&sender_user)?,
avatar_url: db.users.avatar_url(sender_user)?,
currently_active: None,
displayname: db.users.displayname(&sender_user)?,
displayname: db.users.displayname(sender_user)?,
last_active_ago: Some(
utils::millis_since_unix_epoch()
.try_into()
@ -177,14 +177,14 @@ pub async fn set_avatar_url_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
db.users
.set_avatar_url(&sender_user, body.avatar_url.clone())?;
.set_avatar_url(sender_user, body.avatar_url.clone())?;
db.users.set_blurhash(&sender_user, body.blurhash.clone())?;
db.users.set_blurhash(sender_user, body.blurhash.clone())?;
// Send a new membership event and presence update into all joined rooms
let all_joined_rooms: Vec<_> = db
.rooms
.rooms_joined(&sender_user)
.rooms_joined(sender_user)
.filter_map(|r| r.ok())
.map(|room_id| {
Ok::<_, Error>((
@ -234,19 +234,19 @@ pub async fn set_avatar_url_route(
);
let state_lock = mutex_state.lock().await;
let _ =
db.rooms
.build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock);
let _ = db
.rooms
.build_and_append_pdu(pdu_builder, sender_user, &room_id, &db, &state_lock);
// Presence update
db.rooms.edus.update_presence(
&sender_user,
sender_user,
&room_id,
ruma::events::presence::PresenceEvent {
content: ruma::events::presence::PresenceEventContent {
avatar_url: db.users.avatar_url(&sender_user)?,
avatar_url: db.users.avatar_url(sender_user)?,
currently_active: None,
displayname: db.users.displayname(&sender_user)?,
displayname: db.users.displayname(sender_user)?,
last_active_ago: Some(
utils::millis_since_unix_epoch()
.try_into()

52
src/client_server/push.rs
View file

@ -31,7 +31,7 @@ pub async fn get_pushrules_all_route(
let event = db
.account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
.get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
@ -59,7 +59,7 @@ pub async fn get_pushrule_route(
let event = db
.account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
.get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
@ -124,7 +124,7 @@ pub async fn set_pushrule_route(
let mut event = db
.account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
.get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
@ -193,13 +193,8 @@ pub async fn set_pushrule_route(
_ => {}
}
db.account_data.update(
None,
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.account_data
.update(None, sender_user, EventType::PushRules, &event, &db.globals)?;
db.flush()?;
@ -229,7 +224,7 @@ pub async fn get_pushrule_actions_route(
let mut event = db
.account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
.get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
@ -291,7 +286,7 @@ pub async fn set_pushrule_actions_route(
let mut event = db
.account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
.get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
@ -332,13 +327,8 @@ pub async fn set_pushrule_actions_route(
_ => {}
};
db.account_data.update(
None,
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.account_data
.update(None, sender_user, EventType::PushRules, &event, &db.globals)?;
db.flush()?;
@ -368,7 +358,7 @@ pub async fn get_pushrule_enabled_route(
let mut event = db
.account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
.get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
@ -432,7 +422,7 @@ pub async fn set_pushrule_enabled_route(
let mut event = db
.account_data
.get::<ruma::events::push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
.get::<ruma::events::push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
@ -478,13 +468,8 @@ pub async fn set_pushrule_enabled_route(
_ => {}
}
db.account_data.update(
None,
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.account_data
.update(None, sender_user, EventType::PushRules, &event, &db.globals)?;
db.flush()?;
@ -514,7 +499,7 @@ pub async fn delete_pushrule_route(
let mut event = db
.account_data
.get::<push_rules::PushRulesEvent>(None, &sender_user, EventType::PushRules)?
.get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
.ok_or(Error::BadRequest(
ErrorKind::NotFound,
"PushRules event not found.",
@ -550,13 +535,8 @@ pub async fn delete_pushrule_route(
_ => {}
}
db.account_data.update(
None,
&sender_user,
EventType::PushRules,
&event,
&db.globals,
)?;
db.account_data
.update(None, sender_user, EventType::PushRules, &event, &db.globals)?;
db.flush()?;

14
src/client_server/read_marker.rs
View file

@ -37,7 +37,7 @@ pub async fn set_read_marker_route(
};
db.account_data.update(
Some(&body.room_id),
&sender_user,
sender_user,
EventType::FullyRead,
&fully_read_event,
&db.globals,
@ -46,7 +46,7 @@ pub async fn set_read_marker_route(
if let Some(event) = &body.read_receipt {
db.rooms.edus.private_read_set(
&body.room_id,
&sender_user,
sender_user,
db.rooms.get_pdu_count(event)?.ok_or(Error::BadRequest(
ErrorKind::InvalidParam,
"Event does not exist.",
@ -54,7 +54,7 @@ pub async fn set_read_marker_route(
&db.globals,
)?;
db.rooms
.reset_notification_counts(&sender_user, &body.room_id)?;
.reset_notification_counts(sender_user, &body.room_id)?;
let mut user_receipts = BTreeMap::new();
user_receipts.insert(
@ -71,7 +71,7 @@ pub async fn set_read_marker_route(
receipt_content.insert(event.to_owned(), receipts);
db.rooms.edus.readreceipt_update(
&sender_user,
sender_user,
&body.room_id,
AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent {
content: ruma::events::receipt::ReceiptEventContent(receipt_content),
@ -102,7 +102,7 @@ pub async fn create_receipt_route(
db.rooms.edus.private_read_set(
&body.room_id,
&sender_user,
sender_user,
db.rooms
.get_pdu_count(&body.event_id)?
.ok_or(Error::BadRequest(
@ -112,7 +112,7 @@ pub async fn create_receipt_route(
&db.globals,
)?;
db.rooms
.reset_notification_counts(&sender_user, &body.room_id)?;
.reset_notification_counts(sender_user, &body.room_id)?;
let mut user_receipts = BTreeMap::new();
user_receipts.insert(
@ -128,7 +128,7 @@ pub async fn create_receipt_route(
receipt_content.insert(body.event_id.to_owned(), receipts);
db.rooms.edus.readreceipt_update(
&sender_user,
sender_user,
&body.room_id,
AnyEphemeralRoomEvent::Receipt(ruma::events::receipt::ReceiptEvent {
content: ruma::events::receipt::ReceiptEventContent(receipt_content),

2
src/client_server/redact.rs
View file

@ -46,7 +46,7 @@ pub async fn redact_event_route(
state_key: None,
redacts: Some(body.event_id.clone()),
},
&sender_user,
sender_user,
&body.room_id,
&db,
&state_lock,

32
src/client_server/room.rs
View file

@ -106,7 +106,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -118,11 +118,11 @@ pub async fn create_room_route(
event_type: EventType::RoomMember,
content: serde_json::to_value(member::MemberEventContent {
membership: member::MembershipState::Join,
displayname: db.users.displayname(&sender_user)?,
avatar_url: db.users.avatar_url(&sender_user)?,
displayname: db.users.displayname(sender_user)?,
avatar_url: db.users.avatar_url(sender_user)?,
is_direct: Some(body.is_direct),
third_party_invite: None,
blurhash: db.users.blurhash(&sender_user)?,
blurhash: db.users.blurhash(sender_user)?,
reason: None,
})
.expect("event is valid, we just created it"),
@ -130,7 +130,7 @@ pub async fn create_room_route(
state_key: Some(sender_user.to_string()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -185,7 +185,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -207,7 +207,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -235,7 +235,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -253,7 +253,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -279,7 +279,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -298,7 +298,7 @@ pub async fn create_room_route(
}
db.rooms
.build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock)?;
.build_and_append_pdu(pdu_builder, sender_user, &room_id, &db, &state_lock)?;
}
// 7. Events implied by name and topic
@ -312,7 +312,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -331,7 +331,7 @@ pub async fn create_room_route(
state_key: Some("".to_owned()),
redacts: None,
},
&sender_user,
sender_user,
&room_id,
&db,
&state_lock,
@ -551,11 +551,11 @@ pub async fn upgrade_room_route(
event_type: EventType::RoomMember,
content: serde_json::to_value(member::MemberEventContent {
membership: member::MembershipState::Join,
displayname: db.users.displayname(&sender_user)?,
avatar_url: db.users.avatar_url(&sender_user)?,
displayname: db.users.displayname(sender_user)?,
avatar_url: db.users.avatar_url(sender_user)?,
is_direct: None,
third_party_invite: None,
blurhash: db.users.blurhash(&sender_user)?,
blurhash: db.users.blurhash(sender_user)?,
reason: None,
})
.expect("event is valid, we just created it"),

4
src/client_server/search.rs
View file

@ -27,7 +27,7 @@ pub async fn search_events_route(
let room_ids = filter.rooms.clone().unwrap_or_else(|| {
db.rooms
.rooms_joined(&sender_user)
.rooms_joined(sender_user)
.filter_map(|r| r.ok())
.collect()
});
@ -88,7 +88,7 @@ pub async fn search_events_route(
rank: None,
result: db
.rooms
.get_pdu_from_id(&result)?
.get_pdu_from_id(result)?
.map(|pdu| pdu.to_room_event()),
})
})

8
src/client_server/session.rs
View file

@ -100,8 +100,8 @@ pub async fn login_route(
login::IncomingLoginInfo::Token { token } => {
if let Some(jwt_decoding_key) = db.globals.jwt_decoding_key() {
let token = jsonwebtoken::decode::<Claims>(
&token,
&jwt_decoding_key,
token,
jwt_decoding_key,
&jsonwebtoken::Validation::default(),
)
.map_err(|_| Error::BadRequest(ErrorKind::InvalidUsername, "Token is invalid."))?;
@ -179,7 +179,7 @@ pub async fn logout_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device = body.sender_device.as_ref().expect("user is authenticated");
db.users.remove_device(&sender_user, sender_device)?;
db.users.remove_device(sender_user, sender_device)?;
db.flush()?;
@ -209,7 +209,7 @@ pub async fn logout_all_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
for device_id in db.users.all_device_ids(sender_user).flatten() {
db.users.remove_device(&sender_user, &device_id)?;
db.users.remove_device(sender_user, &device_id)?;
}
db.flush()?;

6
src/client_server/state.rs
View file

@ -308,9 +308,9 @@ async fn send_state_event_for_key_helper(
state_key: Some(state_key),
redacts: None,
},
&sender_user,
&room_id,
&db,
sender_user,
room_id,
db,
&state_lock,
)?;

8
src/client_server/to_device.rs
View file

@ -68,8 +68,8 @@ pub async fn send_event_to_device_route(
match target_device_id_maybe {
DeviceIdOrAllDevices::DeviceId(target_device_id) => db.users.add_to_device_event(
sender_user,
&target_user_id,
&target_device_id,
target_user_id,
target_device_id,
&body.event_type,
event.deserialize_as().map_err(|_| {
Error::BadRequest(ErrorKind::InvalidParam, "Event is invalid")
@ -78,10 +78,10 @@ pub async fn send_event_to_device_route(
)?,
DeviceIdOrAllDevices::AllDevices => {
for target_device_id in db.users.all_device_ids(&target_user_id) {
for target_device_id in db.users.all_device_ids(target_user_id) {
db.users.add_to_device_event(
sender_user,
&target_user_id,
target_user_id,
&target_device_id?,
&body.event_type,
event.deserialize_as().map_err(|_| {

4
src/client_server/typing.rs
View file

@ -21,7 +21,7 @@ pub fn create_typing_event_route(
if let Typing::Yes(duration) = body.state {
db.rooms.edus.typing_add(
&sender_user,
sender_user,
&body.room_id,
duration.as_millis() as u64 + utils::millis_since_unix_epoch(),
&db.globals,
@ -29,7 +29,7 @@ pub fn create_typing_event_route(
} else {
db.rooms
.edus
.typing_remove(&sender_user, &body.room_id, &db.globals)?;
.typing_remove(sender_user, &body.room_id, &db.globals)?;
}
Ok(create_typing_event::Response {}.into())