Page MenuHomePhabricator
Differential D4999

[web] Implement darker thread color tint to blockquote container
ClosedPublic
Actions

Authored by ginsu on Aug 31 2022, 7:47 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 1, 10:31 AM
Unknown Object (File)
Tue, Apr 1, 10:31 AM
Unknown Object (File)
Tue, Apr 1, 10:31 AM
Unknown Object (File)
Tue, Apr 1, 10:31 AM
Unknown Object (File)
Tue, Apr 1, 10:31 AM
Unknown Object (File)
Tue, Apr 1, 10:31 AM
Unknown Object (File)
Tue, Apr 1, 10:31 AM
Unknown Object (File)
Tue, Apr 1, 10:31 AM
View All Files
Subscribers
• abosh
ashoat
atul
• jacek
kamil
tomek

Details

Reviewers
atul
ashoat
kamil
Commits
rCOMM5448df76c019: [web] Implement darker thread color tint to blockquote container
Summary

Linear issue: ENG-1712. Restyling the quotes by layering the blockquote with a low opacity black background to create the darker tint effect

Next Steps:

  1. Update non-viewer blockquote message container color to be the base thread color
Test Plan

Please view the attached screenshots to see the target design in the figma document and the before and after of the changes I implemented

Figma document: Figma.

Screen Shot 2022-09-03 at 3.22.23 PM.png (1×1 px, 92 KB)

Before:

Screen Shot 2022-09-07 at 2.02.57 PM.png (586×1 px, 74 KB)

After:

Screen Shot 2022-09-20 at 10.22.04 PM.png (554×1 px, 58 KB)

Screen Shot 2022-09-20 at 10.24.02 PM.png (552×1 px, 83 KB)

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

There are a very large number of changes, so older changes are hidden. Show Older Changes
Harbormaster completed remote builds in B11940: Diff 16391.Sep 7 2022, 12:10 AM
Harbormaster completed remote builds in B11941: Diff 16392.
atul requested changes to this revision.Sep 7 2022, 9:27 PM

Are you running into the following when you try to run things locally?

Error [ERR_MODULE_NOT_FOUND]: Cannot find module '/Users/atul/comm/keyserver/dist/web/markdown/markdown.css' imported from /Users/atul/comm/keyserver/dist/web/markdown/rules.react.js

I'm not able to patch in the changes and test it out. Assuming it's not just an issue on my end, we can schedule something to walk through it?

This revision now requires changes to proceed.Sep 7 2022, 9:27 PM
atul retitled this revision from [WEB] implemnted darker thread color tint to blockquote container to [web] Implement darker thread color tint to blockquote container.Sep 12 2022, 10:30 AM
ashoat requested changes to this revision.Sep 15 2022, 6:19 AM

Glad I caught this diff before it got accepted. It might be best for me to do a second-pass review of all Markdown diffs until @atul is able to get up to speed with the codebase

web/chat/text-message.react.js
77

Not a fan of the special-casing of threadInfo.color here. Can't this be moved to do something similar to this?

web/markdown/markdown.react.js
42–50

Is this the right place for this logic? I'd love to see if we can move it to rules.react.js

ginsu updated this revision to Diff 16787.Sep 18 2022, 5:44 AM

changed threadColor logic to go through rules.react.js

ginsu updated this revision to Diff 16788.Sep 18 2022, 5:47 AM

fixed weird git tracking issue

ginsu updated this revision to Diff 16789.Sep 18 2022, 5:51 AM

put back useDarkStyle logic in markdown.react.js

Harbormaster completed remote builds in B12235: Diff 16787.Sep 18 2022, 5:54 AM
ginsu edited the summary of this revision. (Show Details)Sep 18 2022, 5:55 AM
ginsu edited the test plan for this revision. (Show Details)
ginsu attached a referenced file: F172911: Screen Shot 2022-09-18 at 9.52.44 PM.png. (Show Details)
Harbormaster completed remote builds in B12236: Diff 16788.Sep 18 2022, 5:57 AM
Harbormaster completed remote builds in B12237: Diff 16789.Sep 18 2022, 6:01 AM
ginsu edited the summary of this revision. (Show Details)Sep 18 2022, 6:38 AM
ashoat requested changes to this revision.Sep 18 2022, 1:48 PM
ashoat added a subscriber: kamil.
ashoat added inline comments.
web/markdown/rules.react.js
87 ↗(On Diff #16789)

Pretty sure you're reverting @kamil's recent changes in D5033 here...

106 ↗(On Diff #16789)

Can tinycolor really parse this? If so, how does it do it? Can you link to docs?

190 ↗(On Diff #16789)

Reverse this condition, see here

193 ↗(On Diff #16789)

We should avoid implicit returns like this, and explicitly return undefined so it's clear to the reader

This revision now requires changes to proceed.Sep 18 2022, 1:48 PM
ashoat added a reviewer: kamil.Sep 18 2022, 1:50 PM

Would be good for @kamil to take a look since he touched this code recently

kamil requested changes to this revision.Sep 19 2022, 5:06 AM

Hi @ginsu.
Not sure but looks like you unintentionally badly resolved conflicts after rebasing with master because this update: D4999#151387 has different base commit - this caused those changes you introduced.

web/markdown/rules.react.js
87 ↗(On Diff #16789)

Pretty sure you're reverting @kamil's recent changes in D5033 here...

That is correct.

You should use SharedMarkdown.matchBlockQuote(SharedMarkdown.blockQuoteRegex) as matching function which basically does the same but adds nested quotation limit.

88–97 ↗(On Diff #16789)

Here should be different parsing function: SharedMarkdown.parseBlockQuote

ginsu updated this revision to Diff 16830.EditedSep 19 2022, 6:17 AM
ginsu edited the summary of this revision. (Show Details)

resovled ashoat's and kamil's comments, my bad on unintentionally reverting kamils changes. Also good shout on tinycolor not parsing CSS custom properties, I made some changes to fix that

Harbormaster completed remote builds in B12268: Diff 16830.Sep 19 2022, 6:27 AM
ginsu added a child revision: D5178: [web] Changed non-viewer blockquote message container color to be the base thread color.Sep 19 2022, 7:06 AM
ashoat requested changes to this revision.Sep 19 2022, 10:20 AM
ashoat added inline comments.
web/markdown/rules.react.js
104 ↗(On Diff #16830)
  1. What happens if you pass undefined to tinycolor?
  2. How does this get handled in the SSR (Server-Side Rendering) context? Seems like it may lead to errors due to inconsistent results on server vs. client

My instinct is that we might have to find another way to pass this info to web... pulling it from CSS might not work in our case. Some ideas:

  1. We could try using the first option on this tutorial, and then to update web/theme.css to reference those variables
  2. We could just copy-paste the CSS variable value into JS, and add code comments indicating that the two values should be kept in sync. Not a great solution, but an acceptable fallback if 1 doesn't work
This revision now requires changes to proceed.Sep 19 2022, 10:20 AM
ashoat added a comment.Sep 19 2022, 10:24 AM

Separately, how confident are you that we absolutely NEED to pass in the threadColor here? Is there no way to use CSS with opacity or something to avoid needing the threadColor as an input? My suspicion is that there is a way more simple solution here that you haven't explored...

ginsu updated this revision to Diff 16892.Sep 20 2022, 3:51 AM

reimplemented solution by removing threadColor logic and creating an opacity layer

ginsu updated this revision to Diff 16893.Sep 20 2022, 3:53 AM

removed extra blank line

ginsu edited the test plan for this revision. (Show Details)Sep 20 2022, 3:56 AM
ginsu attached a referenced file: F175276: Screen Shot 2022-09-20 at 7.56.15 PM.png. (Show Details)
ginsu updated this revision to Diff 16894.Sep 20 2022, 3:59 AM

cleaned up border-left css

Harbormaster completed remote builds in B12304: Diff 16892.Sep 20 2022, 4:00 AM
Harbormaster completed remote builds in B12305: Diff 16893.Sep 20 2022, 4:03 AM
ginsu edited the test plan for this revision. (Show Details)Sep 20 2022, 4:03 AM
ginsu attached a referenced file: F175318: Screen Shot 2022-09-20 at 8.03.19 PM.png. (Show Details)
ginsu edited the summary of this revision. (Show Details)
ginsu edited the summary of this revision. (Show Details)Sep 20 2022, 4:06 AM
Harbormaster completed remote builds in B12306: Diff 16894.Sep 20 2022, 4:09 AM
ashoat accepted this revision.Sep 20 2022, 4:52 AM

Looks WAY cleaner!!

atul accepted this revision.Sep 20 2022, 5:51 AM

Nice!

As an aside, I really liked the design with the drop shadow you shared in the Linear issue (https://linear.app/comm/issue/ENG-1712/restyle-quotes-in-messages-to-match-new-designs):

quote_w_dropshadow.png (1×1 px, 686 KB)

I thought it provided more "contrast" between quotes when there are multiple levels of nesting, and just generally looked a lot better.

CC @ashoat for thoughts. I realize the design was already determined in the Linear issue, but wanted to re-open discussion because I strongly prefer the design with drop shadows.

ashoat added a comment.Sep 20 2022, 5:57 AM

Ah yeah, I got confused and thought there were only 3 options... I should've specified my fav using the title. I think "Left Border with chat theme and drop shadow" is the best in that list

If it's easy to implement with CSS I think we should give it a go!

ginsu added a comment.Sep 20 2022, 6:00 AM

I'll take a look into it right now!

ginsu updated this revision to Diff 16907.Sep 20 2022, 6:24 AM

added box-shadow property

ginsu edited the test plan for this revision. (Show Details)Sep 20 2022, 6:26 AM
ginsu attached a referenced file: F175567: Screen Shot 2022-09-20 at 10.22.04 PM.png. (Show Details)
ginsu attached a referenced file: F175569: Screen Shot 2022-09-20 at 10.24.02 PM.png. (Show Details)
atul accepted this revision.Sep 20 2022, 6:31 AM

nice

atul removed a reviewer: • abosh.Sep 20 2022, 6:32 AM

removing @abosh to unblock since A) he's out this week B) his feedback was addressed or is no longer relevant given the changes

Harbormaster completed remote builds in B12316: Diff 16907.Sep 20 2022, 6:34 AM
ginsu mentioned this in D5178: [web] Changed non-viewer blockquote message container color to be the base thread color.Sep 21 2022, 5:14 AM
kamil accepted this revision.Sep 21 2022, 10:18 AM

My request is no longer relevant so accepting this to unblock.

This revision is now accepted and ready to land.Sep 21 2022, 10:18 AM
ginsu updated this revision to Diff 17085.Sep 26 2022, 10:02 AM

update

ginsu updated this revision to Diff 17086.Sep 26 2022, 10:05 AM

fix

This revision was landed with ongoing or failed builds.Sep 26 2022, 10:06 AM
Closed by commit rCOMM5448df76c019: [web] Implement darker thread color tint to blockquote container (authored by ginsu). · Explain Why
This revision was automatically updated to reflect the committed changes.
ginsu added a commit: rCOMM5448df76c019: [web] Implement darker thread color tint to blockquote container.
Harbormaster completed remote builds in B12440: Diff 17085.Sep 26 2022, 10:13 AM
Harbormaster completed remote builds in B12441: Diff 17086.Sep 26 2022, 10:16 AM
atul mentioned this in D5347: Add spoiler rule to native in fullMarkdownRules.Oct 12 2022, 4:33 PM

Revision Contents
Changeset List

PathSize
web/
chat/
8 lines
markdown/
11 lines
21 lines
17 lines

Diff 16392

View Options

web/chat/text-message.react.js

Show All 10 Linesuse comm_lib::database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError, AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
TryFromAttribute, TryFromAttribute,
}; };
use constant_time_eq::constant_time_eq; use constant_time_eq::constant_time_eq;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::str::FromStr; use std::str::FromStr;
use std::sync::Arc; use std::sync::Arc;
use crate::ddb_utils::{ use crate::{
constants::USERS_TABLE_DEVICES_ATTRIBUTE,
ddb_utils::{
create_one_time_key_partition_key, into_one_time_put_requests, Identifier, create_one_time_key_partition_key, into_one_time_put_requests, Identifier,
OlmAccountType, OlmAccountType,
},
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
},
reserved_users::UserDetail,
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
},
error::{consume_error, Error},
}; };
use crate::error::{consume_error, Error};
use crate::reserved_users::UserDetail;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use tracing::{debug, error, info, warn}; use tracing::{debug, error, info, warn};
use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo}; use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::{ use crate::constants::{
ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE, ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE,
ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE, ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE,
ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE, ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE,
ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE, ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE,
NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE, NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE,
NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY, NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY,
NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE, NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE,
RESERVED_USERNAMES_TABLE_PARTITION_KEY, RESERVED_USERNAMES_TABLE_PARTITION_KEY,
RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE, RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE,
USERS_TABLE_DEVICES_ATTRIBUTE,
USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME, USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE, USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE,
USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX, USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX,
USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX, USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX,
}; };
use crate::error::{AttributeValueFromHashMap, FromAttributeValue}; use crate::error::AttributeValueFromHashMap;
use crate::id::generate_uuid; use crate::id::generate_uuid;
use crate::nonce::NonceData; use crate::nonce::NonceData;
use crate::token::{AccessTokenData, AuthType}; use crate::token::{AccessTokenData, AuthType};
pub use grpc_clients::identity::DeviceType; pub use grpc_clients::identity::DeviceType;
mod device_list; mod device_list;
pub use device_list::DeviceListRow; pub use device_list::DeviceListRow;
▲ Show 20 Lines • Show All 306 Lines • ▼ Show 20 Lines pub async fn get_keyserver_keys_for_user(
&self, &self,
user_id: &str, user_id: &str,
) -> Result<Option<OutboundKeys>, Error> { ) -> Result<Option<OutboundKeys>, Error> {
use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType; use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType;
// DynamoDB doesn't have a way to "pop" a value from a list, so we must // DynamoDB doesn't have a way to "pop" a value from a list, so we must
// first read in user info, then update one_time_keys with value we // first read in user info, then update one_time_keys with value we
// gave to requester // gave to requester
let user_info = self let mut user_info = self
.get_item_from_users_table(user_id) .get_item_from_users_table(user_id)
.await? .await?
.item .item
.ok_or(Error::MissingItem)?; .ok_or(Error::MissingItem)?;
let user_id = user_info let user_id: String = user_info.take_attr(USERS_TABLE_PARTITION_KEY)?;
.get(USERS_TABLE_PARTITION_KEY)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_PARTITION_KEY)?;
let devices = user_info
.get(USERS_TABLE_DEVICES_ATTRIBUTE)
.ok_or(Error::MissingItem)?
.to_hashmap(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let user_devices = self.get_current_devices(user_id).await?; let user_devices = self.get_current_devices(user_id).await?;
let maybe_keyserver_device = user_devices let maybe_keyserver_device = user_devices
.into_iter() .into_iter()
.find(|device| device.device_type == GrpcDeviceType::Keyserver); .find(|device| device.device_type == GrpcDeviceType::Keyserver);
if let Some(keyserver) = maybe_keyserver_device { let Some(keyserver) = maybe_keyserver_device else {
return Ok(None);
};
debug!( debug!(
"Found keyserver in devices table (ID={})", "Found keyserver in devices table (ID={})",
&keyserver.device_id &keyserver.device_id
); );
let notif_one_time_key: Option<String> = self let notif_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Notification) .get_one_time_key(&keyserver.device_id, OlmAccountType::Notification)
.await?; .await?;
let content_one_time_key: Option<String> = self let content_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Content) .get_one_time_key(&keyserver.device_id, OlmAccountType::Content)
.await?; .await?;
debug!( debug!(
"Able to get notif one-time key for keyserver {}: {}", "Able to get notif one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
notif_one_time_key.is_some() notif_one_time_key.is_some()
); );
debug!( debug!(
"Able to get content one-time key for keyserver {}: {}", "Able to get content one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
content_one_time_key.is_some() content_one_time_key.is_some()
); );
let outbound_payload = OutboundKeys { let outbound_payload = OutboundKeys {
key_payload: keyserver.device_key_info.key_payload, key_payload: keyserver.device_key_info.key_payload,
key_payload_signature: keyserver.device_key_info.key_payload_signature, key_payload_signature: keyserver.device_key_info.key_payload_signature,
social_proof: keyserver.device_key_info.social_proof, social_proof: keyserver.device_key_info.social_proof,
content_prekey: PreKey { content_prekey: PreKey {
prekey: keyserver.content_prekey.pre_key, prekey: keyserver.content_prekey.pre_key,
prekey_signature: keyserver.content_prekey.pre_key_signature, prekey_signature: keyserver.content_prekey.pre_key_signature,
}, },
notif_prekey: PreKey { notif_prekey: PreKey {
prekey: keyserver.notif_prekey.pre_key, prekey: keyserver.notif_prekey.pre_key,
prekey_signature: keyserver.notif_prekey.pre_key_signature, prekey_signature: keyserver.notif_prekey.pre_key_signature,
}, },
content_one_time_key, content_one_time_key,
notif_one_time_key, notif_one_time_key,
}; };
return Ok(Some(outbound_payload));
}
let mut maybe_keyserver_id = None;
for (device_id, device_info) in devices {
let device_type = device_info
.to_hashmap("device_id")?
.get(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)?;
if device_type == "keyserver" {
maybe_keyserver_id = Some(device_id);
break;
}
}
// Assert that the user has a keyserver, if they don't return None
let keyserver_id = match maybe_keyserver_id {
None => return Ok(None),
Some(id) => id,
};
let keyserver = devices.get_map(keyserver_id)?;
let notif_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Notification)
.await?;
let content_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Content)
.await?;
debug!(
"Able to get notif one-time key for keyserver {}: {}",
keyserver_id,
notif_one_time_key.is_some()
);
debug!(
"Able to get content one-time key for keyserver {}: {}",
keyserver_id,
content_one_time_key.is_some()
);
let content_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME)?;
let content_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let notif_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME)?;
let notif_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let key_payload = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME)?
.to_string();
let key_payload_signature = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME)?
.to_string();
let social_proof = keyserver
.get(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.and_then(|s| {
s.to_string(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.ok()
})
.map(|s| s.to_owned());
let full_content_prekey = PreKey {
prekey: content_prekey.to_string(),
prekey_signature: content_prekey_signature.to_string(),
};
let full_notif_prekey = PreKey {
prekey: notif_prekey.to_string(),
prekey_signature: notif_prekey_signature.to_string(),
};
let outbound_payload = OutboundKeys {
key_payload,
key_payload_signature,
social_proof,
content_prekey: full_content_prekey,
notif_prekey: full_notif_prekey,
content_one_time_key,
notif_one_time_key,
};
Ok(Some(outbound_payload)) Ok(Some(outbound_payload))
} }
/// Will "mint" a single one-time key by attempting to successfully delete a /// Will "mint" a single one-time key by attempting to successfully delete a
/// key /// key
pub async fn get_one_time_key( pub async fn get_one_time_key(
&self, &self,
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines self
let capacity_units = response let capacity_units = response
.consumed_capacity() .consumed_capacity()
.and_then(|it| it.capacity_units()); .and_then(|it| it.capacity_units());
debug!("OTK read consumed capacity: {:?}", capacity_units); debug!("OTK read consumed capacity: {:?}", capacity_units);
response response
}) })
} }
pub async fn set_prekey( pub async fn set_prekey(
&self, &self,
user_id: String, user_id: String,
device_id: String, device_id: String,
content_prekey: String, content_prekey: String,
content_prekey_signature: String, content_prekey_signature: String,
notif_prekey: String, notif_prekey: String,
notif_prekey_signature: String, notif_prekey_signature: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// update new device list too
self self
.update_device_prekeys( .update_device_prekeys(
user_id.clone(), user_id,
device_id.clone(), device_id,
content_prekey.clone(), content_prekey,
content_prekey_signature.clone(), content_prekey_signature,
notif_prekey.clone(), notif_prekey,
notif_prekey_signature.clone(), notif_prekey_signature,
) )
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
.await?;
let notif_prekey_av = AttributeValue::S(notif_prekey);
let notif_prekey_signature_av = AttributeValue::S(notif_prekey_signature);
let content_prekey_av = AttributeValue::S(content_prekey);
let content_prekey_signature_av =
AttributeValue::S(content_prekey_signature);
let update_expression =
format!("SET {0}.#{1}.{2} = :n, {0}.#{1}.{3} = :p, {0}.#{1}.{4} = :c, {0}.#{1}.{5} = :d",
USERS_TABLE_DEVICES_ATTRIBUTE,
"deviceID",
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
);
let expression_attribute_names = HashMap::from([
(format!("#{}", "deviceID"), device_id),
(
"#user_id".to_string(),
USERS_TABLE_PARTITION_KEY.to_string(),
),
]);
let expression_attribute_values = HashMap::from([
(":n".to_string(), notif_prekey_av),
(":p".to_string(), notif_prekey_signature_av),
(":c".to_string(), content_prekey_av),
(":d".to_string(), content_prekey_signature_av),
]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.condition_expression("attribute_exists(#user_id)")
.set_expression_attribute_names(Some(expression_attribute_names))
.set_expression_attribute_values(Some(expression_attribute_values))
.send()
.await .await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn append_one_time_prekeys( pub async fn append_one_time_prekeys(
&self, &self,
device_id: String, device_id: String,
content_one_time_keys: Vec<String>, content_one_time_keys: Vec<String>,
notif_one_time_keys: Vec<String>, notif_one_time_keys: Vec<String>,
) -> Result<(), Error> { ) -> Result<(), Error> {
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines self
content_one_time_keys, content_one_time_keys,
notif_one_time_keys, notif_one_time_keys,
) )
.await?; .await?;
Ok(()) Ok(())
} }
pub async fn remove_device_from_users_table( pub async fn remove_device_from_users_table(
&self, &self,
user_id: String, user_id: String,
device_id_key: String, device_id_key: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// delete from new device list too self.remove_device(&user_id, &device_id_key).await
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
self.remove_device(&user_id, &device_id_key).await?;
let update_expression =
format!("REMOVE {}.{}", USERS_TABLE_DEVICES_ATTRIBUTE, "#deviceID");
let expression_attribute_names =
HashMap::from([("#deviceID".to_string(), device_id_key)]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.set_expression_attribute_names(Some(expression_attribute_names))
.send()
.await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn update_user_password( pub async fn update_user_password(
&self, &self,
user_id: String, user_id: String,
password_file: Vec<u8>, password_file: Vec<u8>,
) -> Result<(), Error> { ) -> Result<(), Error> {
let update_expression = let update_expression =
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Linesimpl DatabaseClient {
} }
async fn get_keys_for_user( async fn get_keys_for_user(
&self, &self,
mut user: AttributeMap, mut user: AttributeMap,
get_one_time_keys: bool, get_one_time_keys: bool,
) -> Result<Option<Devices>, Error> { ) -> Result<Option<Devices>, Error> {
let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?; let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?;
let devices: AttributeMap =
user.take_attr(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let mut devices_response = self.get_keys_for_user_devices(user_id).await?; let mut devices_response = self.get_keys_for_user_devices(user_id).await?;
for (device_id_key, device_info) in devices {
let device_info_map =
AttributeMap::try_from_attr(&device_id_key, Some(device_info))?;
let mut device_info_string_map = HashMap::new();
for (attribute_name, attribute_value) in device_info_map {
// Excluding one-time keys since we're moving them to a separate table
if attribute_name
== USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME
|| attribute_name
== USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME
{
continue;
}
// Excluding info already taken from device list response
if devices_response
.get(&device_id_key)
.map(|device| device.contains_key(&attribute_name))
.unwrap_or(false)
{
continue;
}
let attribute_value_str =
String::try_from_attr(&attribute_name, Some(attribute_value))?;
device_info_string_map.insert(attribute_name, attribute_value_str);
}
bartekAuthorUnsubmitted
Done
Inline Actions

Previously, we were merging legacy and new device list attribute by attribute, now we no longer need that.

bartek: Previously, we were merging legacy and new device list attribute by attribute, now we no longer…
if get_one_time_keys { if get_one_time_keys {
for (device_id_key, device_info_map) in devices_response.iter_mut() {
if let Some(notif_one_time_key) = self if let Some(notif_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Notification) .get_one_time_key(device_id_key, OlmAccountType::Notification)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key); .insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key);
} }
if let Some(content_one_time_key) = self if let Some(content_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Content) .get_one_time_key(device_id_key, OlmAccountType::Content)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key); .insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key);
} }
} }
devices_response.insert(device_id_key, device_info_string_map);
} }
Ok(Some(devices_response)) Ok(Some(devices_response))
} }
pub async fn get_user_id_from_user_info( pub async fn get_user_id_from_user_info(
&self, &self,
user_info: String, user_info: String,
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines
View Options

web/markdown/markdown.css

Show All 10 Linesuse comm_lib::database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError, AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
TryFromAttribute, TryFromAttribute,
}; };
use constant_time_eq::constant_time_eq; use constant_time_eq::constant_time_eq;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::str::FromStr; use std::str::FromStr;
use std::sync::Arc; use std::sync::Arc;
use crate::ddb_utils::{ use crate::{
constants::USERS_TABLE_DEVICES_ATTRIBUTE,
ddb_utils::{
create_one_time_key_partition_key, into_one_time_put_requests, Identifier, create_one_time_key_partition_key, into_one_time_put_requests, Identifier,
OlmAccountType, OlmAccountType,
},
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
},
reserved_users::UserDetail,
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
},
error::{consume_error, Error},
}; };
use crate::error::{consume_error, Error};
use crate::reserved_users::UserDetail;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use tracing::{debug, error, info, warn}; use tracing::{debug, error, info, warn};
use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo}; use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::{ use crate::constants::{
ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE, ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE,
ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE, ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE,
ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE, ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE,
ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE, ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE,
NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE, NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE,
NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY, NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY,
NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE, NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE,
RESERVED_USERNAMES_TABLE_PARTITION_KEY, RESERVED_USERNAMES_TABLE_PARTITION_KEY,
RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE, RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE,
USERS_TABLE_DEVICES_ATTRIBUTE,
USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME, USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE, USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE,
USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX, USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX,
USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX, USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX,
}; };
use crate::error::{AttributeValueFromHashMap, FromAttributeValue}; use crate::error::AttributeValueFromHashMap;
use crate::id::generate_uuid; use crate::id::generate_uuid;
use crate::nonce::NonceData; use crate::nonce::NonceData;
use crate::token::{AccessTokenData, AuthType}; use crate::token::{AccessTokenData, AuthType};
pub use grpc_clients::identity::DeviceType; pub use grpc_clients::identity::DeviceType;
mod device_list; mod device_list;
pub use device_list::DeviceListRow; pub use device_list::DeviceListRow;
▲ Show 20 Lines • Show All 306 Lines • ▼ Show 20 Lines pub async fn get_keyserver_keys_for_user(
&self, &self,
user_id: &str, user_id: &str,
) -> Result<Option<OutboundKeys>, Error> { ) -> Result<Option<OutboundKeys>, Error> {
use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType; use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType;
// DynamoDB doesn't have a way to "pop" a value from a list, so we must // DynamoDB doesn't have a way to "pop" a value from a list, so we must
// first read in user info, then update one_time_keys with value we // first read in user info, then update one_time_keys with value we
// gave to requester // gave to requester
let user_info = self let mut user_info = self
.get_item_from_users_table(user_id) .get_item_from_users_table(user_id)
.await? .await?
.item .item
.ok_or(Error::MissingItem)?; .ok_or(Error::MissingItem)?;
let user_id = user_info let user_id: String = user_info.take_attr(USERS_TABLE_PARTITION_KEY)?;
.get(USERS_TABLE_PARTITION_KEY)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_PARTITION_KEY)?;
let devices = user_info
.get(USERS_TABLE_DEVICES_ATTRIBUTE)
.ok_or(Error::MissingItem)?
.to_hashmap(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let user_devices = self.get_current_devices(user_id).await?; let user_devices = self.get_current_devices(user_id).await?;
let maybe_keyserver_device = user_devices let maybe_keyserver_device = user_devices
.into_iter() .into_iter()
.find(|device| device.device_type == GrpcDeviceType::Keyserver); .find(|device| device.device_type == GrpcDeviceType::Keyserver);
if let Some(keyserver) = maybe_keyserver_device { let Some(keyserver) = maybe_keyserver_device else {
return Ok(None);
};
debug!( debug!(
"Found keyserver in devices table (ID={})", "Found keyserver in devices table (ID={})",
&keyserver.device_id &keyserver.device_id
); );
let notif_one_time_key: Option<String> = self let notif_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Notification) .get_one_time_key(&keyserver.device_id, OlmAccountType::Notification)
.await?; .await?;
let content_one_time_key: Option<String> = self let content_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Content) .get_one_time_key(&keyserver.device_id, OlmAccountType::Content)
.await?; .await?;
debug!( debug!(
"Able to get notif one-time key for keyserver {}: {}", "Able to get notif one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
notif_one_time_key.is_some() notif_one_time_key.is_some()
); );
debug!( debug!(
"Able to get content one-time key for keyserver {}: {}", "Able to get content one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
content_one_time_key.is_some() content_one_time_key.is_some()
); );
let outbound_payload = OutboundKeys { let outbound_payload = OutboundKeys {
key_payload: keyserver.device_key_info.key_payload, key_payload: keyserver.device_key_info.key_payload,
key_payload_signature: keyserver.device_key_info.key_payload_signature, key_payload_signature: keyserver.device_key_info.key_payload_signature,
social_proof: keyserver.device_key_info.social_proof, social_proof: keyserver.device_key_info.social_proof,
content_prekey: PreKey { content_prekey: PreKey {
prekey: keyserver.content_prekey.pre_key, prekey: keyserver.content_prekey.pre_key,
prekey_signature: keyserver.content_prekey.pre_key_signature, prekey_signature: keyserver.content_prekey.pre_key_signature,
}, },
notif_prekey: PreKey { notif_prekey: PreKey {
prekey: keyserver.notif_prekey.pre_key, prekey: keyserver.notif_prekey.pre_key,
prekey_signature: keyserver.notif_prekey.pre_key_signature, prekey_signature: keyserver.notif_prekey.pre_key_signature,
}, },
content_one_time_key, content_one_time_key,
notif_one_time_key, notif_one_time_key,
}; };
return Ok(Some(outbound_payload));
}
let mut maybe_keyserver_id = None;
for (device_id, device_info) in devices {
let device_type = device_info
.to_hashmap("device_id")?
.get(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)?;
if device_type == "keyserver" {
maybe_keyserver_id = Some(device_id);
break;
}
}
// Assert that the user has a keyserver, if they don't return None
let keyserver_id = match maybe_keyserver_id {
None => return Ok(None),
Some(id) => id,
};
let keyserver = devices.get_map(keyserver_id)?;
let notif_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Notification)
.await?;
let content_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Content)
.await?;
debug!(
"Able to get notif one-time key for keyserver {}: {}",
keyserver_id,
notif_one_time_key.is_some()
);
debug!(
"Able to get content one-time key for keyserver {}: {}",
keyserver_id,
content_one_time_key.is_some()
);
let content_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME)?;
let content_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let notif_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME)?;
let notif_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let key_payload = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME)?
.to_string();
let key_payload_signature = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME)?
.to_string();
let social_proof = keyserver
.get(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.and_then(|s| {
s.to_string(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.ok()
})
.map(|s| s.to_owned());
let full_content_prekey = PreKey {
prekey: content_prekey.to_string(),
prekey_signature: content_prekey_signature.to_string(),
};
let full_notif_prekey = PreKey {
prekey: notif_prekey.to_string(),
prekey_signature: notif_prekey_signature.to_string(),
};
let outbound_payload = OutboundKeys {
key_payload,
key_payload_signature,
social_proof,
content_prekey: full_content_prekey,
notif_prekey: full_notif_prekey,
content_one_time_key,
notif_one_time_key,
};
Ok(Some(outbound_payload)) Ok(Some(outbound_payload))
} }
/// Will "mint" a single one-time key by attempting to successfully delete a /// Will "mint" a single one-time key by attempting to successfully delete a
/// key /// key
pub async fn get_one_time_key( pub async fn get_one_time_key(
&self, &self,
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines self
let capacity_units = response let capacity_units = response
.consumed_capacity() .consumed_capacity()
.and_then(|it| it.capacity_units()); .and_then(|it| it.capacity_units());
debug!("OTK read consumed capacity: {:?}", capacity_units); debug!("OTK read consumed capacity: {:?}", capacity_units);
response response
}) })
} }
pub async fn set_prekey( pub async fn set_prekey(
&self, &self,
user_id: String, user_id: String,
device_id: String, device_id: String,
content_prekey: String, content_prekey: String,
content_prekey_signature: String, content_prekey_signature: String,
notif_prekey: String, notif_prekey: String,
notif_prekey_signature: String, notif_prekey_signature: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// update new device list too
self self
.update_device_prekeys( .update_device_prekeys(
user_id.clone(), user_id,
device_id.clone(), device_id,
content_prekey.clone(), content_prekey,
content_prekey_signature.clone(), content_prekey_signature,
notif_prekey.clone(), notif_prekey,
notif_prekey_signature.clone(), notif_prekey_signature,
) )
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
.await?;
let notif_prekey_av = AttributeValue::S(notif_prekey);
let notif_prekey_signature_av = AttributeValue::S(notif_prekey_signature);
let content_prekey_av = AttributeValue::S(content_prekey);
let content_prekey_signature_av =
AttributeValue::S(content_prekey_signature);
let update_expression =
format!("SET {0}.#{1}.{2} = :n, {0}.#{1}.{3} = :p, {0}.#{1}.{4} = :c, {0}.#{1}.{5} = :d",
USERS_TABLE_DEVICES_ATTRIBUTE,
"deviceID",
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
);
let expression_attribute_names = HashMap::from([
(format!("#{}", "deviceID"), device_id),
(
"#user_id".to_string(),
USERS_TABLE_PARTITION_KEY.to_string(),
),
]);
let expression_attribute_values = HashMap::from([
(":n".to_string(), notif_prekey_av),
(":p".to_string(), notif_prekey_signature_av),
(":c".to_string(), content_prekey_av),
(":d".to_string(), content_prekey_signature_av),
]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.condition_expression("attribute_exists(#user_id)")
.set_expression_attribute_names(Some(expression_attribute_names))
.set_expression_attribute_values(Some(expression_attribute_values))
.send()
.await .await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn append_one_time_prekeys( pub async fn append_one_time_prekeys(
&self, &self,
device_id: String, device_id: String,
content_one_time_keys: Vec<String>, content_one_time_keys: Vec<String>,
notif_one_time_keys: Vec<String>, notif_one_time_keys: Vec<String>,
) -> Result<(), Error> { ) -> Result<(), Error> {
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines self
content_one_time_keys, content_one_time_keys,
notif_one_time_keys, notif_one_time_keys,
) )
.await?; .await?;
Ok(()) Ok(())
} }
pub async fn remove_device_from_users_table( pub async fn remove_device_from_users_table(
&self, &self,
user_id: String, user_id: String,
device_id_key: String, device_id_key: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// delete from new device list too self.remove_device(&user_id, &device_id_key).await
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
self.remove_device(&user_id, &device_id_key).await?;
let update_expression =
format!("REMOVE {}.{}", USERS_TABLE_DEVICES_ATTRIBUTE, "#deviceID");
let expression_attribute_names =
HashMap::from([("#deviceID".to_string(), device_id_key)]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.set_expression_attribute_names(Some(expression_attribute_names))
.send()
.await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn update_user_password( pub async fn update_user_password(
&self, &self,
user_id: String, user_id: String,
password_file: Vec<u8>, password_file: Vec<u8>,
) -> Result<(), Error> { ) -> Result<(), Error> {
let update_expression = let update_expression =
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Linesimpl DatabaseClient {
} }
async fn get_keys_for_user( async fn get_keys_for_user(
&self, &self,
mut user: AttributeMap, mut user: AttributeMap,
get_one_time_keys: bool, get_one_time_keys: bool,
) -> Result<Option<Devices>, Error> { ) -> Result<Option<Devices>, Error> {
let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?; let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?;
let devices: AttributeMap =
user.take_attr(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let mut devices_response = self.get_keys_for_user_devices(user_id).await?; let mut devices_response = self.get_keys_for_user_devices(user_id).await?;
for (device_id_key, device_info) in devices {
let device_info_map =
AttributeMap::try_from_attr(&device_id_key, Some(device_info))?;
let mut device_info_string_map = HashMap::new();
for (attribute_name, attribute_value) in device_info_map {
// Excluding one-time keys since we're moving them to a separate table
if attribute_name
== USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME
|| attribute_name
== USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME
{
continue;
}
// Excluding info already taken from device list response
if devices_response
.get(&device_id_key)
.map(|device| device.contains_key(&attribute_name))
.unwrap_or(false)
{
continue;
}
let attribute_value_str =
String::try_from_attr(&attribute_name, Some(attribute_value))?;
device_info_string_map.insert(attribute_name, attribute_value_str);
}
bartekAuthorUnsubmitted
Done
Inline Actions

Previously, we were merging legacy and new device list attribute by attribute, now we no longer need that.

bartek: Previously, we were merging legacy and new device list attribute by attribute, now we no longer…
if get_one_time_keys { if get_one_time_keys {
for (device_id_key, device_info_map) in devices_response.iter_mut() {
if let Some(notif_one_time_key) = self if let Some(notif_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Notification) .get_one_time_key(device_id_key, OlmAccountType::Notification)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key); .insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key);
} }
if let Some(content_one_time_key) = self if let Some(content_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Content) .get_one_time_key(device_id_key, OlmAccountType::Content)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key); .insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key);
} }
} }
devices_response.insert(device_id_key, device_info_string_map);
} }
Ok(Some(devices_response)) Ok(Some(devices_response))
} }
pub async fn get_user_id_from_user_info( pub async fn get_user_id_from_user_info(
&self, &self,
user_info: String, user_info: String,
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines
View Options

web/markdown/markdown.react.js

Show All 10 Linesuse comm_lib::database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError, AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
TryFromAttribute, TryFromAttribute,
}; };
use constant_time_eq::constant_time_eq; use constant_time_eq::constant_time_eq;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::str::FromStr; use std::str::FromStr;
use std::sync::Arc; use std::sync::Arc;
use crate::ddb_utils::{ use crate::{
constants::USERS_TABLE_DEVICES_ATTRIBUTE,
ddb_utils::{
create_one_time_key_partition_key, into_one_time_put_requests, Identifier, create_one_time_key_partition_key, into_one_time_put_requests, Identifier,
OlmAccountType, OlmAccountType,
},
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
},
reserved_users::UserDetail,
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
},
error::{consume_error, Error},
}; };
use crate::error::{consume_error, Error};
use crate::reserved_users::UserDetail;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use tracing::{debug, error, info, warn}; use tracing::{debug, error, info, warn};
use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo}; use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::{ use crate::constants::{
ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE, ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE,
ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE, ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE,
ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE, ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE,
ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE, ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE,
NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE, NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE,
NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY, NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY,
NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE, NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE,
RESERVED_USERNAMES_TABLE_PARTITION_KEY, RESERVED_USERNAMES_TABLE_PARTITION_KEY,
RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE, RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE,
USERS_TABLE_DEVICES_ATTRIBUTE,
USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME, USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE, USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE,
USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX, USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX,
USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX, USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX,
}; };
use crate::error::{AttributeValueFromHashMap, FromAttributeValue}; use crate::error::AttributeValueFromHashMap;
use crate::id::generate_uuid; use crate::id::generate_uuid;
use crate::nonce::NonceData; use crate::nonce::NonceData;
use crate::token::{AccessTokenData, AuthType}; use crate::token::{AccessTokenData, AuthType};
pub use grpc_clients::identity::DeviceType; pub use grpc_clients::identity::DeviceType;
mod device_list; mod device_list;
pub use device_list::DeviceListRow; pub use device_list::DeviceListRow;
▲ Show 20 Lines • Show All 306 Lines • ▼ Show 20 Lines pub async fn get_keyserver_keys_for_user(
&self, &self,
user_id: &str, user_id: &str,
) -> Result<Option<OutboundKeys>, Error> { ) -> Result<Option<OutboundKeys>, Error> {
use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType; use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType;
// DynamoDB doesn't have a way to "pop" a value from a list, so we must // DynamoDB doesn't have a way to "pop" a value from a list, so we must
// first read in user info, then update one_time_keys with value we // first read in user info, then update one_time_keys with value we
// gave to requester // gave to requester
let user_info = self let mut user_info = self
.get_item_from_users_table(user_id) .get_item_from_users_table(user_id)
.await? .await?
.item .item
.ok_or(Error::MissingItem)?; .ok_or(Error::MissingItem)?;
let user_id = user_info let user_id: String = user_info.take_attr(USERS_TABLE_PARTITION_KEY)?;
.get(USERS_TABLE_PARTITION_KEY)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_PARTITION_KEY)?;
let devices = user_info
.get(USERS_TABLE_DEVICES_ATTRIBUTE)
.ok_or(Error::MissingItem)?
.to_hashmap(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let user_devices = self.get_current_devices(user_id).await?; let user_devices = self.get_current_devices(user_id).await?;
let maybe_keyserver_device = user_devices let maybe_keyserver_device = user_devices
.into_iter() .into_iter()
.find(|device| device.device_type == GrpcDeviceType::Keyserver); .find(|device| device.device_type == GrpcDeviceType::Keyserver);
if let Some(keyserver) = maybe_keyserver_device { let Some(keyserver) = maybe_keyserver_device else {
return Ok(None);
};
debug!( debug!(
"Found keyserver in devices table (ID={})", "Found keyserver in devices table (ID={})",
&keyserver.device_id &keyserver.device_id
); );
let notif_one_time_key: Option<String> = self let notif_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Notification) .get_one_time_key(&keyserver.device_id, OlmAccountType::Notification)
.await?; .await?;
let content_one_time_key: Option<String> = self let content_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Content) .get_one_time_key(&keyserver.device_id, OlmAccountType::Content)
.await?; .await?;
debug!( debug!(
"Able to get notif one-time key for keyserver {}: {}", "Able to get notif one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
notif_one_time_key.is_some() notif_one_time_key.is_some()
); );
debug!( debug!(
"Able to get content one-time key for keyserver {}: {}", "Able to get content one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
content_one_time_key.is_some() content_one_time_key.is_some()
); );
let outbound_payload = OutboundKeys { let outbound_payload = OutboundKeys {
key_payload: keyserver.device_key_info.key_payload, key_payload: keyserver.device_key_info.key_payload,
key_payload_signature: keyserver.device_key_info.key_payload_signature, key_payload_signature: keyserver.device_key_info.key_payload_signature,
social_proof: keyserver.device_key_info.social_proof, social_proof: keyserver.device_key_info.social_proof,
content_prekey: PreKey { content_prekey: PreKey {
prekey: keyserver.content_prekey.pre_key, prekey: keyserver.content_prekey.pre_key,
prekey_signature: keyserver.content_prekey.pre_key_signature, prekey_signature: keyserver.content_prekey.pre_key_signature,
}, },
notif_prekey: PreKey { notif_prekey: PreKey {
prekey: keyserver.notif_prekey.pre_key, prekey: keyserver.notif_prekey.pre_key,
prekey_signature: keyserver.notif_prekey.pre_key_signature, prekey_signature: keyserver.notif_prekey.pre_key_signature,
}, },
content_one_time_key, content_one_time_key,
notif_one_time_key, notif_one_time_key,
}; };
return Ok(Some(outbound_payload));
}
let mut maybe_keyserver_id = None;
for (device_id, device_info) in devices {
let device_type = device_info
.to_hashmap("device_id")?
.get(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)?;
if device_type == "keyserver" {
maybe_keyserver_id = Some(device_id);
break;
}
}
// Assert that the user has a keyserver, if they don't return None
let keyserver_id = match maybe_keyserver_id {
None => return Ok(None),
Some(id) => id,
};
let keyserver = devices.get_map(keyserver_id)?;
let notif_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Notification)
.await?;
let content_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Content)
.await?;
debug!(
"Able to get notif one-time key for keyserver {}: {}",
keyserver_id,
notif_one_time_key.is_some()
);
debug!(
"Able to get content one-time key for keyserver {}: {}",
keyserver_id,
content_one_time_key.is_some()
);
let content_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME)?;
let content_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let notif_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME)?;
let notif_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let key_payload = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME)?
.to_string();
let key_payload_signature = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME)?
.to_string();
let social_proof = keyserver
.get(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.and_then(|s| {
s.to_string(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.ok()
})
.map(|s| s.to_owned());
let full_content_prekey = PreKey {
prekey: content_prekey.to_string(),
prekey_signature: content_prekey_signature.to_string(),
};
let full_notif_prekey = PreKey {
prekey: notif_prekey.to_string(),
prekey_signature: notif_prekey_signature.to_string(),
};
let outbound_payload = OutboundKeys {
key_payload,
key_payload_signature,
social_proof,
content_prekey: full_content_prekey,
notif_prekey: full_notif_prekey,
content_one_time_key,
notif_one_time_key,
};
Ok(Some(outbound_payload)) Ok(Some(outbound_payload))
} }
/// Will "mint" a single one-time key by attempting to successfully delete a /// Will "mint" a single one-time key by attempting to successfully delete a
/// key /// key
pub async fn get_one_time_key( pub async fn get_one_time_key(
&self, &self,
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines self
let capacity_units = response let capacity_units = response
.consumed_capacity() .consumed_capacity()
.and_then(|it| it.capacity_units()); .and_then(|it| it.capacity_units());
debug!("OTK read consumed capacity: {:?}", capacity_units); debug!("OTK read consumed capacity: {:?}", capacity_units);
response response
}) })
} }
pub async fn set_prekey( pub async fn set_prekey(
&self, &self,
user_id: String, user_id: String,
device_id: String, device_id: String,
content_prekey: String, content_prekey: String,
content_prekey_signature: String, content_prekey_signature: String,
notif_prekey: String, notif_prekey: String,
notif_prekey_signature: String, notif_prekey_signature: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// update new device list too
self self
.update_device_prekeys( .update_device_prekeys(
user_id.clone(), user_id,
device_id.clone(), device_id,
content_prekey.clone(), content_prekey,
content_prekey_signature.clone(), content_prekey_signature,
notif_prekey.clone(), notif_prekey,
notif_prekey_signature.clone(), notif_prekey_signature,
) )
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
.await?;
let notif_prekey_av = AttributeValue::S(notif_prekey);
let notif_prekey_signature_av = AttributeValue::S(notif_prekey_signature);
let content_prekey_av = AttributeValue::S(content_prekey);
let content_prekey_signature_av =
AttributeValue::S(content_prekey_signature);
let update_expression =
format!("SET {0}.#{1}.{2} = :n, {0}.#{1}.{3} = :p, {0}.#{1}.{4} = :c, {0}.#{1}.{5} = :d",
USERS_TABLE_DEVICES_ATTRIBUTE,
"deviceID",
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
);
let expression_attribute_names = HashMap::from([
(format!("#{}", "deviceID"), device_id),
(
"#user_id".to_string(),
USERS_TABLE_PARTITION_KEY.to_string(),
),
]);
let expression_attribute_values = HashMap::from([
(":n".to_string(), notif_prekey_av),
(":p".to_string(), notif_prekey_signature_av),
(":c".to_string(), content_prekey_av),
(":d".to_string(), content_prekey_signature_av),
]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.condition_expression("attribute_exists(#user_id)")
.set_expression_attribute_names(Some(expression_attribute_names))
.set_expression_attribute_values(Some(expression_attribute_values))
.send()
.await .await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn append_one_time_prekeys( pub async fn append_one_time_prekeys(
&self, &self,
device_id: String, device_id: String,
content_one_time_keys: Vec<String>, content_one_time_keys: Vec<String>,
notif_one_time_keys: Vec<String>, notif_one_time_keys: Vec<String>,
) -> Result<(), Error> { ) -> Result<(), Error> {
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines self
content_one_time_keys, content_one_time_keys,
notif_one_time_keys, notif_one_time_keys,
) )
.await?; .await?;
Ok(()) Ok(())
} }
pub async fn remove_device_from_users_table( pub async fn remove_device_from_users_table(
&self, &self,
user_id: String, user_id: String,
device_id_key: String, device_id_key: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// delete from new device list too self.remove_device(&user_id, &device_id_key).await
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
self.remove_device(&user_id, &device_id_key).await?;
let update_expression =
format!("REMOVE {}.{}", USERS_TABLE_DEVICES_ATTRIBUTE, "#deviceID");
let expression_attribute_names =
HashMap::from([("#deviceID".to_string(), device_id_key)]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.set_expression_attribute_names(Some(expression_attribute_names))
.send()
.await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn update_user_password( pub async fn update_user_password(
&self, &self,
user_id: String, user_id: String,
password_file: Vec<u8>, password_file: Vec<u8>,
) -> Result<(), Error> { ) -> Result<(), Error> {
let update_expression = let update_expression =
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Linesimpl DatabaseClient {
} }
async fn get_keys_for_user( async fn get_keys_for_user(
&self, &self,
mut user: AttributeMap, mut user: AttributeMap,
get_one_time_keys: bool, get_one_time_keys: bool,
) -> Result<Option<Devices>, Error> { ) -> Result<Option<Devices>, Error> {
let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?; let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?;
let devices: AttributeMap =
user.take_attr(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let mut devices_response = self.get_keys_for_user_devices(user_id).await?; let mut devices_response = self.get_keys_for_user_devices(user_id).await?;
for (device_id_key, device_info) in devices {
let device_info_map =
AttributeMap::try_from_attr(&device_id_key, Some(device_info))?;
let mut device_info_string_map = HashMap::new();
for (attribute_name, attribute_value) in device_info_map {
// Excluding one-time keys since we're moving them to a separate table
if attribute_name
== USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME
|| attribute_name
== USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME
{
continue;
}
// Excluding info already taken from device list response
if devices_response
.get(&device_id_key)
.map(|device| device.contains_key(&attribute_name))
.unwrap_or(false)
{
continue;
}
let attribute_value_str =
String::try_from_attr(&attribute_name, Some(attribute_value))?;
device_info_string_map.insert(attribute_name, attribute_value_str);
}
bartekAuthorUnsubmitted
Done
Inline Actions

Previously, we were merging legacy and new device list attribute by attribute, now we no longer need that.

bartek: Previously, we were merging legacy and new device list attribute by attribute, now we no longer…
if get_one_time_keys { if get_one_time_keys {
for (device_id_key, device_info_map) in devices_response.iter_mut() {
if let Some(notif_one_time_key) = self if let Some(notif_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Notification) .get_one_time_key(device_id_key, OlmAccountType::Notification)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key); .insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key);
} }
if let Some(content_one_time_key) = self if let Some(content_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Content) .get_one_time_key(device_id_key, OlmAccountType::Content)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key); .insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key);
} }
} }
devices_response.insert(device_id_key, device_info_string_map);
} }
Ok(Some(devices_response)) Ok(Some(devices_response))
} }
pub async fn get_user_id_from_user_info( pub async fn get_user_id_from_user_info(
&self, &self,
user_info: String, user_info: String,
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines
View Options

web/markdown/rules.react.js

Show All 10 Linesuse comm_lib::database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError, AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
TryFromAttribute, TryFromAttribute,
}; };
use constant_time_eq::constant_time_eq; use constant_time_eq::constant_time_eq;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::str::FromStr; use std::str::FromStr;
use std::sync::Arc; use std::sync::Arc;
use crate::ddb_utils::{ use crate::{
constants::USERS_TABLE_DEVICES_ATTRIBUTE,
ddb_utils::{
create_one_time_key_partition_key, into_one_time_put_requests, Identifier, create_one_time_key_partition_key, into_one_time_put_requests, Identifier,
OlmAccountType, OlmAccountType,
},
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
},
reserved_users::UserDetail,
};
use crate::{
constants::{
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
},
error::{consume_error, Error},
}; };
use crate::error::{consume_error, Error};
use crate::reserved_users::UserDetail;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use tracing::{debug, error, info, warn}; use tracing::{debug, error, info, warn};
use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo}; use crate::client_service::{FlattenedDeviceKeyUpload, UserRegistrationInfo};
use crate::config::CONFIG; use crate::config::CONFIG;
use crate::constants::{ use crate::constants::{
ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE, ACCESS_TOKEN_SORT_KEY, ACCESS_TOKEN_TABLE,
ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE, ACCESS_TOKEN_TABLE_AUTH_TYPE_ATTRIBUTE, ACCESS_TOKEN_TABLE_CREATED_ATTRIBUTE,
ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE, ACCESS_TOKEN_TABLE_PARTITION_KEY, ACCESS_TOKEN_TABLE_TOKEN_ATTRIBUTE,
ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE, ACCESS_TOKEN_TABLE_VALID_ATTRIBUTE, CONTENT_ONE_TIME_KEY, NONCE_TABLE,
NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE, NONCE_TABLE_CREATED_ATTRIBUTE, NONCE_TABLE_EXPIRATION_TIME_ATTRIBUTE,
NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY, NONCE_TABLE_EXPIRATION_TIME_UNIX_ATTRIBUTE, NONCE_TABLE_PARTITION_KEY,
NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE, NOTIF_ONE_TIME_KEY, RESERVED_USERNAMES_TABLE,
RESERVED_USERNAMES_TABLE_PARTITION_KEY, RESERVED_USERNAMES_TABLE_PARTITION_KEY,
RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE, RESERVED_USERNAMES_TABLE_USER_ID_ATTRIBUTE, USERS_TABLE,
USERS_TABLE_DEVICES_ATTRIBUTE,
USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME, USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE, USERS_TABLE_PARTITION_KEY, USERS_TABLE_REGISTRATION_ATTRIBUTE,
USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX, USERS_TABLE_USERNAME_ATTRIBUTE, USERS_TABLE_USERNAME_INDEX,
USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX, USERS_TABLE_WALLET_ADDRESS_ATTRIBUTE, USERS_TABLE_WALLET_ADDRESS_INDEX,
}; };
use crate::error::{AttributeValueFromHashMap, FromAttributeValue}; use crate::error::AttributeValueFromHashMap;
use crate::id::generate_uuid; use crate::id::generate_uuid;
use crate::nonce::NonceData; use crate::nonce::NonceData;
use crate::token::{AccessTokenData, AuthType}; use crate::token::{AccessTokenData, AuthType};
pub use grpc_clients::identity::DeviceType; pub use grpc_clients::identity::DeviceType;
mod device_list; mod device_list;
pub use device_list::DeviceListRow; pub use device_list::DeviceListRow;
▲ Show 20 Lines • Show All 306 Lines • ▼ Show 20 Lines pub async fn get_keyserver_keys_for_user(
&self, &self,
user_id: &str, user_id: &str,
) -> Result<Option<OutboundKeys>, Error> { ) -> Result<Option<OutboundKeys>, Error> {
use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType; use crate::grpc_services::protos::unauth::DeviceType as GrpcDeviceType;
// DynamoDB doesn't have a way to "pop" a value from a list, so we must // DynamoDB doesn't have a way to "pop" a value from a list, so we must
// first read in user info, then update one_time_keys with value we // first read in user info, then update one_time_keys with value we
// gave to requester // gave to requester
let user_info = self let mut user_info = self
.get_item_from_users_table(user_id) .get_item_from_users_table(user_id)
.await? .await?
.item .item
.ok_or(Error::MissingItem)?; .ok_or(Error::MissingItem)?;
let user_id = user_info let user_id: String = user_info.take_attr(USERS_TABLE_PARTITION_KEY)?;
.get(USERS_TABLE_PARTITION_KEY)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_PARTITION_KEY)?;
let devices = user_info
.get(USERS_TABLE_DEVICES_ATTRIBUTE)
.ok_or(Error::MissingItem)?
.to_hashmap(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let user_devices = self.get_current_devices(user_id).await?; let user_devices = self.get_current_devices(user_id).await?;
let maybe_keyserver_device = user_devices let maybe_keyserver_device = user_devices
.into_iter() .into_iter()
.find(|device| device.device_type == GrpcDeviceType::Keyserver); .find(|device| device.device_type == GrpcDeviceType::Keyserver);
if let Some(keyserver) = maybe_keyserver_device { let Some(keyserver) = maybe_keyserver_device else {
return Ok(None);
};
debug!( debug!(
"Found keyserver in devices table (ID={})", "Found keyserver in devices table (ID={})",
&keyserver.device_id &keyserver.device_id
); );
let notif_one_time_key: Option<String> = self let notif_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Notification) .get_one_time_key(&keyserver.device_id, OlmAccountType::Notification)
.await?; .await?;
let content_one_time_key: Option<String> = self let content_one_time_key: Option<String> = self
.get_one_time_key(&keyserver.device_id, OlmAccountType::Content) .get_one_time_key(&keyserver.device_id, OlmAccountType::Content)
.await?; .await?;
debug!( debug!(
"Able to get notif one-time key for keyserver {}: {}", "Able to get notif one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
notif_one_time_key.is_some() notif_one_time_key.is_some()
); );
debug!( debug!(
"Able to get content one-time key for keyserver {}: {}", "Able to get content one-time key for keyserver {}: {}",
&keyserver.device_id, &keyserver.device_id,
content_one_time_key.is_some() content_one_time_key.is_some()
); );
let outbound_payload = OutboundKeys { let outbound_payload = OutboundKeys {
key_payload: keyserver.device_key_info.key_payload, key_payload: keyserver.device_key_info.key_payload,
key_payload_signature: keyserver.device_key_info.key_payload_signature, key_payload_signature: keyserver.device_key_info.key_payload_signature,
social_proof: keyserver.device_key_info.social_proof, social_proof: keyserver.device_key_info.social_proof,
content_prekey: PreKey { content_prekey: PreKey {
prekey: keyserver.content_prekey.pre_key, prekey: keyserver.content_prekey.pre_key,
prekey_signature: keyserver.content_prekey.pre_key_signature, prekey_signature: keyserver.content_prekey.pre_key_signature,
}, },
notif_prekey: PreKey { notif_prekey: PreKey {
prekey: keyserver.notif_prekey.pre_key, prekey: keyserver.notif_prekey.pre_key,
prekey_signature: keyserver.notif_prekey.pre_key_signature, prekey_signature: keyserver.notif_prekey.pre_key_signature,
}, },
content_one_time_key, content_one_time_key,
notif_one_time_key, notif_one_time_key,
}; };
return Ok(Some(outbound_payload));
}
let mut maybe_keyserver_id = None;
for (device_id, device_info) in devices {
let device_type = device_info
.to_hashmap("device_id")?
.get(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)
.ok_or(Error::MissingItem)?
.to_string(USERS_TABLE_DEVICES_MAP_DEVICE_TYPE_ATTRIBUTE_NAME)?;
if device_type == "keyserver" {
maybe_keyserver_id = Some(device_id);
break;
}
}
// Assert that the user has a keyserver, if they don't return None
let keyserver_id = match maybe_keyserver_id {
None => return Ok(None),
Some(id) => id,
};
let keyserver = devices.get_map(keyserver_id)?;
let notif_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Notification)
.await?;
let content_one_time_key: Option<String> = self
.get_one_time_key(keyserver_id, OlmAccountType::Content)
.await?;
debug!(
"Able to get notif one-time key for keyserver {}: {}",
keyserver_id,
notif_one_time_key.is_some()
);
debug!(
"Able to get content one-time key for keyserver {}: {}",
keyserver_id,
content_one_time_key.is_some()
);
let content_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME)?;
let content_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let notif_prekey = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME)?;
let notif_prekey_signature = keyserver.get_string(
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
)?;
let key_payload = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_ATTRIBUTE_NAME)?
.to_string();
let key_payload_signature = keyserver
.get_string(USERS_TABLE_DEVICES_MAP_KEY_PAYLOAD_SIGNATURE_ATTRIBUTE_NAME)?
.to_string();
let social_proof = keyserver
.get(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.and_then(|s| {
s.to_string(USERS_TABLE_DEVICES_MAP_SOCIAL_PROOF_ATTRIBUTE_NAME)
.ok()
})
.map(|s| s.to_owned());
let full_content_prekey = PreKey {
prekey: content_prekey.to_string(),
prekey_signature: content_prekey_signature.to_string(),
};
let full_notif_prekey = PreKey {
prekey: notif_prekey.to_string(),
prekey_signature: notif_prekey_signature.to_string(),
};
let outbound_payload = OutboundKeys {
key_payload,
key_payload_signature,
social_proof,
content_prekey: full_content_prekey,
notif_prekey: full_notif_prekey,
content_one_time_key,
notif_one_time_key,
};
Ok(Some(outbound_payload)) Ok(Some(outbound_payload))
} }
/// Will "mint" a single one-time key by attempting to successfully delete a /// Will "mint" a single one-time key by attempting to successfully delete a
/// key /// key
pub async fn get_one_time_key( pub async fn get_one_time_key(
&self, &self,
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines self
let capacity_units = response let capacity_units = response
.consumed_capacity() .consumed_capacity()
.and_then(|it| it.capacity_units()); .and_then(|it| it.capacity_units());
debug!("OTK read consumed capacity: {:?}", capacity_units); debug!("OTK read consumed capacity: {:?}", capacity_units);
response response
}) })
} }
pub async fn set_prekey( pub async fn set_prekey(
&self, &self,
user_id: String, user_id: String,
device_id: String, device_id: String,
content_prekey: String, content_prekey: String,
content_prekey_signature: String, content_prekey_signature: String,
notif_prekey: String, notif_prekey: String,
notif_prekey_signature: String, notif_prekey_signature: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// update new device list too
self self
.update_device_prekeys( .update_device_prekeys(
user_id.clone(), user_id,
device_id.clone(), device_id,
content_prekey.clone(), content_prekey,
content_prekey_signature.clone(), content_prekey_signature,
notif_prekey.clone(), notif_prekey,
notif_prekey_signature.clone(), notif_prekey_signature,
) )
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
.await?;
let notif_prekey_av = AttributeValue::S(notif_prekey);
let notif_prekey_signature_av = AttributeValue::S(notif_prekey_signature);
let content_prekey_av = AttributeValue::S(content_prekey);
let content_prekey_signature_av =
AttributeValue::S(content_prekey_signature);
let update_expression =
format!("SET {0}.#{1}.{2} = :n, {0}.#{1}.{3} = :p, {0}.#{1}.{4} = :c, {0}.#{1}.{5} = :d",
USERS_TABLE_DEVICES_ATTRIBUTE,
"deviceID",
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_NOTIF_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_ATTRIBUTE_NAME,
USERS_TABLE_DEVICES_MAP_CONTENT_PREKEY_SIGNATURE_ATTRIBUTE_NAME,
);
let expression_attribute_names = HashMap::from([
(format!("#{}", "deviceID"), device_id),
(
"#user_id".to_string(),
USERS_TABLE_PARTITION_KEY.to_string(),
),
]);
let expression_attribute_values = HashMap::from([
(":n".to_string(), notif_prekey_av),
(":p".to_string(), notif_prekey_signature_av),
(":c".to_string(), content_prekey_av),
(":d".to_string(), content_prekey_signature_av),
]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.condition_expression("attribute_exists(#user_id)")
.set_expression_attribute_names(Some(expression_attribute_names))
.set_expression_attribute_values(Some(expression_attribute_values))
.send()
.await .await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn append_one_time_prekeys( pub async fn append_one_time_prekeys(
&self, &self,
device_id: String, device_id: String,
content_one_time_keys: Vec<String>, content_one_time_keys: Vec<String>,
notif_one_time_keys: Vec<String>, notif_one_time_keys: Vec<String>,
) -> Result<(), Error> { ) -> Result<(), Error> {
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines self
content_one_time_keys, content_one_time_keys,
notif_one_time_keys, notif_one_time_keys,
) )
.await?; .await?;
Ok(()) Ok(())
} }
pub async fn remove_device_from_users_table( pub async fn remove_device_from_users_table(
&self, &self,
user_id: String, user_id: String,
device_id_key: String, device_id_key: String,
) -> Result<(), Error> { ) -> Result<(), Error> {
// delete from new device list too self.remove_device(&user_id, &device_id_key).await
bartekAuthorUnsubmitted
Done
Inline Actions

This intermediate function is removed in the next diff

bartek: This intermediate function is removed in the next diff
self.remove_device(&user_id, &device_id_key).await?;
let update_expression =
format!("REMOVE {}.{}", USERS_TABLE_DEVICES_ATTRIBUTE, "#deviceID");
let expression_attribute_names =
HashMap::from([("#deviceID".to_string(), device_id_key)]);
self
.client
.update_item()
.table_name(USERS_TABLE)
.key(USERS_TABLE_PARTITION_KEY, AttributeValue::S(user_id))
.update_expression(update_expression)
.set_expression_attribute_names(Some(expression_attribute_names))
.send()
.await
.map_err(|e| Error::AwsSdk(e.into()))?;
Ok(())
} }
pub async fn update_user_password( pub async fn update_user_password(
&self, &self,
user_id: String, user_id: String,
password_file: Vec<u8>, password_file: Vec<u8>,
) -> Result<(), Error> { ) -> Result<(), Error> {
let update_expression = let update_expression =
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Linesimpl DatabaseClient {
} }
async fn get_keys_for_user( async fn get_keys_for_user(
&self, &self,
mut user: AttributeMap, mut user: AttributeMap,
get_one_time_keys: bool, get_one_time_keys: bool,
) -> Result<Option<Devices>, Error> { ) -> Result<Option<Devices>, Error> {
let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?; let user_id: String = user.take_attr(USERS_TABLE_PARTITION_KEY)?;
let devices: AttributeMap =
user.take_attr(USERS_TABLE_DEVICES_ATTRIBUTE)?;
let mut devices_response = self.get_keys_for_user_devices(user_id).await?; let mut devices_response = self.get_keys_for_user_devices(user_id).await?;
for (device_id_key, device_info) in devices {
let device_info_map =
AttributeMap::try_from_attr(&device_id_key, Some(device_info))?;
let mut device_info_string_map = HashMap::new();
for (attribute_name, attribute_value) in device_info_map {
// Excluding one-time keys since we're moving them to a separate table
if attribute_name
== USERS_TABLE_DEVICES_MAP_NOTIF_ONE_TIME_KEYS_ATTRIBUTE_NAME
|| attribute_name
== USERS_TABLE_DEVICES_MAP_CONTENT_ONE_TIME_KEYS_ATTRIBUTE_NAME
{
continue;
}
// Excluding info already taken from device list response
if devices_response
.get(&device_id_key)
.map(|device| device.contains_key(&attribute_name))
.unwrap_or(false)
{
continue;
}
let attribute_value_str =
String::try_from_attr(&attribute_name, Some(attribute_value))?;
device_info_string_map.insert(attribute_name, attribute_value_str);
}
bartekAuthorUnsubmitted
Done
Inline Actions

Previously, we were merging legacy and new device list attribute by attribute, now we no longer need that.

bartek: Previously, we were merging legacy and new device list attribute by attribute, now we no longer…
if get_one_time_keys { if get_one_time_keys {
for (device_id_key, device_info_map) in devices_response.iter_mut() {
if let Some(notif_one_time_key) = self if let Some(notif_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Notification) .get_one_time_key(device_id_key, OlmAccountType::Notification)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key); .insert(NOTIF_ONE_TIME_KEY.to_string(), notif_one_time_key);
} }
if let Some(content_one_time_key) = self if let Some(content_one_time_key) = self
.get_one_time_key(&device_id_key, OlmAccountType::Content) .get_one_time_key(device_id_key, OlmAccountType::Content)
.await? .await?
{ {
device_info_string_map device_info_map
.insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key); .insert(CONTENT_ONE_TIME_KEY.to_string(), content_one_time_key);
} }
} }
devices_response.insert(device_id_key, device_info_string_map);
} }
Ok(Some(devices_response)) Ok(Some(devices_response))
} }
pub async fn get_user_id_from_user_info( pub async fn get_user_id_from_user_info(
&self, &self,
user_info: String, user_info: String,
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines