Page MenuHomePhabricator
Differential D8139

[web] Confirm a user wants to exit if changes are made in the modal
ClosedPublic
Actions

Authored by rohan on Jun 7 2023, 5:06 AM.
Tags
None
Referenced Files
F6236929: D8139.diff
Thu, Apr 24, 4:01 PM
Unknown Object (File)
Sat, Apr 19, 11:28 AM
Unknown Object (File)
Fri, Apr 18, 3:54 PM
Unknown Object (File)
Fri, Apr 18, 10:25 AM
Unknown Object (File)
Fri, Apr 18, 8:35 AM
Unknown Object (File)
Fri, Apr 18, 1:19 AM
Unknown Object (File)
Thu, Apr 17, 11:21 PM
Unknown Object (File)
Thu, Apr 17, 6:35 AM
View All Files
Subscribers
ashoat
• ted
tomek

Details

Reviewers
atul
ginsu
Commits
rCOMMcbd9d2b8b5fe: [web] Confirm a user wants to exit if changes are made in the modal
Summary

Based on the designs, if a member's role is changed (not saved, but just different to their current role) in the dropdown menu, we need to add a confirmation exit modal to warn them that they will
lose their changes by closing the role change modal.

https://linear.app/comm/issue/ENG-4039/confirm-a-user-wants-to-exit-if-changes-are-made-in-the-modal

Depends on D8138

Test Plan

Please see the video below that covers the different use cases of no changes, changes, making a change but then changing the role back to the member's current role, etc.

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

rohan created this revision.Jun 7 2023, 5:06 AM
Herald added subscribers: • ted, tomek, ashoat. · View Herald TranscriptJun 7 2023, 5:06 AM
rohan added a child revision: D8140: [web] Add functionality on save to actually change a member's role.Jun 7 2023, 5:08 AM
rohan edited the test plan for this revision. (Show Details)Jun 7 2023, 5:23 AM
rohan attached a referenced file: F575232: Screen Recording 2023-06-07 at 8.22.09 AM.mov. (Show Details)
Harbormaster completed remote builds in B20081: Diff 27516.Jun 7 2023, 5:23 AM
rohan requested review of this revision.Jun 7 2023, 5:23 AM
rohan updated this revision to Diff 27546.Jun 8 2023, 6:11 AM

Rebase

Harbormaster completed remote builds in B20103: Diff 27546.Jun 8 2023, 6:27 AM
rohan updated this revision to Diff 27581.Jun 9 2023, 11:14 AM

Rebase on D8136

Harbormaster completed remote builds in B20131: Diff 27581.Jun 9 2023, 11:31 AM
atul accepted this revision.Jun 9 2023, 3:25 PM
atul added inline comments.
web/modals/unsaved-changes-modal.react.js
15–20 ↗(On Diff #27581)

Looks strange, but also reasonable?

This revision is now accepted and ready to land.Jun 9 2023, 3:25 PM
rohan updated this revision to Diff 27940.Jun 21 2023, 8:05 AM

Rebase

Harbormaster completed remote builds in B20386: Diff 27940.Jun 21 2023, 8:35 AM
Closed by commit rCOMMcbd9d2b8b5fe: [web] Confirm a user wants to exit if changes are made in the modal (authored by rohan). · Explain WhyJun 21 2023, 8:41 AM
This revision was automatically updated to reflect the committed changes.
rohan added a commit: rCOMMcbd9d2b8b5fe: [web] Confirm a user wants to exit if changes are made in the modal.
ashoat added inline comments.Jun 27 2023, 10:31 AM
web/modals/threads/members/change-member-role-modal.react.js
50 ↗(On Diff #27959)

It appears there there are other ways to close the modal that won't trigger UnsavedChangesModal. Is this addressed in later diffs?

rohan added inline comments.Jun 27 2023, 11:04 AM
web/modals/threads/members/change-member-role-modal.react.js
50 ↗(On Diff #27959)

It's not, I hadn't considered the default modal close. I think the easiest solution is to get rid of popModal and have Modal onClose={onBackClick} (just off the top of my head, will test it before I put up a quick diff to address this)

Revision Contents
Changeset List

PathSize
web/
modals/
threads/
members/
18 lines
27 lines
53 lines
1 line

Diff 27516

View Options

web/modals/threads/members/change-member-role-modal.react.js

// TODO: get rid of this // TODO: get rid of this
#![allow(dead_code)] #![allow(dead_code)]
use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::model::AttributeValue; use aws_sdk_dynamodb::model::AttributeValue;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use tracing::warn;
use crate::{ use crate::{
constants::devices_table::*, constants::devices_table::*,
database::parse_string_attribute, database::parse_string_attribute,
error::{DBItemAttributeError, DBItemError, FromAttributeValue}, error::{DBItemAttributeError, DBItemError, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
Show All 34 Lines
struct DeviceListKeyAttribute(DateTime<Utc>); struct DeviceListKeyAttribute(DateTime<Utc>);
impl From<DeviceIDAttribute> for AttributeValue { impl From<DeviceIDAttribute> for AttributeValue {
fn from(value: DeviceIDAttribute) -> Self { fn from(value: DeviceIDAttribute) -> Self {
AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0)) AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0))
} }
} }
impl From<DeviceListKeyAttribute> for AttributeValue {
fn from(value: DeviceListKeyAttribute) -> Self {
AttributeValue::S(format!(
"{DEVICE_LIST_KEY_PREFIX}{}",
value.0.to_rfc3339()
))
}
}
impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute { impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device- prefix // remove the device- prefix
let device_id = item_id let device_id = item_id
.strip_prefix(DEVICE_ITEM_KEY_PREFIX) .strip_prefix(DEVICE_ITEM_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())), attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
})? })?
.to_string(); .to_string();
Ok(Self(device_id)) Ok(Self(device_id))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute {
type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue,
})
.and_then(|s| {
s.parse().map_err(|e| {
DBItemError::new(
ATTR_ITEM_ID.to_string(),
Some(AttributeValue::S(item_id.clone())),
DBItemAttributeError::InvalidTimestamp(e),
)
})
})?;
Ok(Self(timestamp))
}
}
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<RawAttributes> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
attrs attrs
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow {
type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync
let timestamps_match = attrs
.remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis())
.is_some();
if !timestamps_match {
warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id,
timestamp.to_rfc3339()
);
}
// this should be a list of strings
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None,
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self {
user_id,
timestamp,
device_ids,
})
}
}
impl From<DeviceListRow> for RawAttributes {
fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new();
attrs.insert(
ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()),
);
attrs.insert(
ATTR_ITEM_ID.to_string(),
DeviceListKeyAttribute(device_list.timestamp).into(),
);
attrs.insert(
ATTR_TIMESTAMP.to_string(),
AttributeValue::N(device_list.timestamp.timestamp_millis().to_string()),
);
bartekAuthorUnsubmitted
Done
Inline Actions

Note that we use RFC 3339 string for ItemID while the ATTR_TIMESTAMP uses milliseconds number. Generally I use the former everywhere (simpler parsing without NaiveDateTime conversions) but I thought the latter is easier for DDB to sort by (it's used only as index sorting key and not read anywhere else)

bartek: Note that we use RFC 3339 string for `ItemID` while the `ATTR_TIMESTAMP` uses milliseconds…
attrs.insert(
ATTR_DEVICE_IDS.to_string(),
AttributeValue::L(
device_list
.device_ids
.into_iter()
.map(AttributeValue::S)
.collect(),
),
);
attrs
}
}
View Options

web/modals/unsaved-changes-modal.css

// TODO: get rid of this // TODO: get rid of this
#![allow(dead_code)] #![allow(dead_code)]
use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::model::AttributeValue; use aws_sdk_dynamodb::model::AttributeValue;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use tracing::warn;
use crate::{ use crate::{
constants::devices_table::*, constants::devices_table::*,
database::parse_string_attribute, database::parse_string_attribute,
error::{DBItemAttributeError, DBItemError, FromAttributeValue}, error::{DBItemAttributeError, DBItemError, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
Show All 34 Lines
struct DeviceListKeyAttribute(DateTime<Utc>); struct DeviceListKeyAttribute(DateTime<Utc>);
impl From<DeviceIDAttribute> for AttributeValue { impl From<DeviceIDAttribute> for AttributeValue {
fn from(value: DeviceIDAttribute) -> Self { fn from(value: DeviceIDAttribute) -> Self {
AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0)) AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0))
} }
} }
impl From<DeviceListKeyAttribute> for AttributeValue {
fn from(value: DeviceListKeyAttribute) -> Self {
AttributeValue::S(format!(
"{DEVICE_LIST_KEY_PREFIX}{}",
value.0.to_rfc3339()
))
}
}
impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute { impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device- prefix // remove the device- prefix
let device_id = item_id let device_id = item_id
.strip_prefix(DEVICE_ITEM_KEY_PREFIX) .strip_prefix(DEVICE_ITEM_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())), attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
})? })?
.to_string(); .to_string();
Ok(Self(device_id)) Ok(Self(device_id))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute {
type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue,
})
.and_then(|s| {
s.parse().map_err(|e| {
DBItemError::new(
ATTR_ITEM_ID.to_string(),
Some(AttributeValue::S(item_id.clone())),
DBItemAttributeError::InvalidTimestamp(e),
)
})
})?;
Ok(Self(timestamp))
}
}
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<RawAttributes> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
attrs attrs
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow {
type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync
let timestamps_match = attrs
.remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis())
.is_some();
if !timestamps_match {
warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id,
timestamp.to_rfc3339()
);
}
// this should be a list of strings
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None,
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self {
user_id,
timestamp,
device_ids,
})
}
}
impl From<DeviceListRow> for RawAttributes {
fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new();
attrs.insert(
ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()),
);
attrs.insert(
ATTR_ITEM_ID.to_string(),
DeviceListKeyAttribute(device_list.timestamp).into(),
);
attrs.insert(
ATTR_TIMESTAMP.to_string(),
AttributeValue::N(device_list.timestamp.timestamp_millis().to_string()),
);
bartekAuthorUnsubmitted
Done
Inline Actions

Note that we use RFC 3339 string for ItemID while the ATTR_TIMESTAMP uses milliseconds number. Generally I use the former everywhere (simpler parsing without NaiveDateTime conversions) but I thought the latter is easier for DDB to sort by (it's used only as index sorting key and not read anywhere else)

bartek: Note that we use RFC 3339 string for `ItemID` while the `ATTR_TIMESTAMP` uses milliseconds…
attrs.insert(
ATTR_DEVICE_IDS.to_string(),
AttributeValue::L(
device_list
.device_ids
.into_iter()
.map(AttributeValue::S)
.collect(),
),
);
attrs
}
}
View Options

web/modals/unsaved-changes-modal.react.js

// TODO: get rid of this // TODO: get rid of this
#![allow(dead_code)] #![allow(dead_code)]
use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::model::AttributeValue; use aws_sdk_dynamodb::model::AttributeValue;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use tracing::warn;
use crate::{ use crate::{
constants::devices_table::*, constants::devices_table::*,
database::parse_string_attribute, database::parse_string_attribute,
error::{DBItemAttributeError, DBItemError, FromAttributeValue}, error::{DBItemAttributeError, DBItemError, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
Show All 34 Lines
struct DeviceListKeyAttribute(DateTime<Utc>); struct DeviceListKeyAttribute(DateTime<Utc>);
impl From<DeviceIDAttribute> for AttributeValue { impl From<DeviceIDAttribute> for AttributeValue {
fn from(value: DeviceIDAttribute) -> Self { fn from(value: DeviceIDAttribute) -> Self {
AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0)) AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0))
} }
} }
impl From<DeviceListKeyAttribute> for AttributeValue {
fn from(value: DeviceListKeyAttribute) -> Self {
AttributeValue::S(format!(
"{DEVICE_LIST_KEY_PREFIX}{}",
value.0.to_rfc3339()
))
}
}
impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute { impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device- prefix // remove the device- prefix
let device_id = item_id let device_id = item_id
.strip_prefix(DEVICE_ITEM_KEY_PREFIX) .strip_prefix(DEVICE_ITEM_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())), attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
})? })?
.to_string(); .to_string();
Ok(Self(device_id)) Ok(Self(device_id))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute {
type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue,
})
.and_then(|s| {
s.parse().map_err(|e| {
DBItemError::new(
ATTR_ITEM_ID.to_string(),
Some(AttributeValue::S(item_id.clone())),
DBItemAttributeError::InvalidTimestamp(e),
)
})
})?;
Ok(Self(timestamp))
}
}
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<RawAttributes> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
attrs attrs
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow {
type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync
let timestamps_match = attrs
.remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis())
.is_some();
if !timestamps_match {
warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id,
timestamp.to_rfc3339()
);
}
// this should be a list of strings
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None,
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self {
user_id,
timestamp,
device_ids,
})
}
}
impl From<DeviceListRow> for RawAttributes {
fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new();
attrs.insert(
ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()),
);
attrs.insert(
ATTR_ITEM_ID.to_string(),
DeviceListKeyAttribute(device_list.timestamp).into(),
);
attrs.insert(
ATTR_TIMESTAMP.to_string(),
AttributeValue::N(device_list.timestamp.timestamp_millis().to_string()),
);
bartekAuthorUnsubmitted
Done
Inline Actions

Note that we use RFC 3339 string for ItemID while the ATTR_TIMESTAMP uses milliseconds number. Generally I use the former everywhere (simpler parsing without NaiveDateTime conversions) but I thought the latter is easier for DDB to sort by (it's used only as index sorting key and not read anywhere else)

bartek: Note that we use RFC 3339 string for `ItemID` while the `ATTR_TIMESTAMP` uses milliseconds…
attrs.insert(
ATTR_DEVICE_IDS.to_string(),
AttributeValue::L(
device_list
.device_ids
.into_iter()
.map(AttributeValue::S)
.collect(),
),
);
attrs
}
}
View Options

web/theme.css

// TODO: get rid of this // TODO: get rid of this
#![allow(dead_code)] #![allow(dead_code)]
use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::model::AttributeValue; use aws_sdk_dynamodb::model::AttributeValue;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use tracing::warn;
use crate::{ use crate::{
constants::devices_table::*, constants::devices_table::*,
database::parse_string_attribute, database::parse_string_attribute,
error::{DBItemAttributeError, DBItemError, FromAttributeValue}, error::{DBItemAttributeError, DBItemError, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
Show All 34 Lines
struct DeviceListKeyAttribute(DateTime<Utc>); struct DeviceListKeyAttribute(DateTime<Utc>);
impl From<DeviceIDAttribute> for AttributeValue { impl From<DeviceIDAttribute> for AttributeValue {
fn from(value: DeviceIDAttribute) -> Self { fn from(value: DeviceIDAttribute) -> Self {
AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0)) AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0))
} }
} }
impl From<DeviceListKeyAttribute> for AttributeValue {
fn from(value: DeviceListKeyAttribute) -> Self {
AttributeValue::S(format!(
"{DEVICE_LIST_KEY_PREFIX}{}",
value.0.to_rfc3339()
))
}
}
impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute { impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device- prefix // remove the device- prefix
let device_id = item_id let device_id = item_id
.strip_prefix(DEVICE_ITEM_KEY_PREFIX) .strip_prefix(DEVICE_ITEM_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())), attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
})? })?
.to_string(); .to_string();
Ok(Self(device_id)) Ok(Self(device_id))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute {
type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue,
})
.and_then(|s| {
s.parse().map_err(|e| {
DBItemError::new(
ATTR_ITEM_ID.to_string(),
Some(AttributeValue::S(item_id.clone())),
DBItemAttributeError::InvalidTimestamp(e),
)
})
})?;
Ok(Self(timestamp))
}
}
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<RawAttributes> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?; parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
attrs attrs
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow {
type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync
let timestamps_match = attrs
.remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis())
.is_some();
if !timestamps_match {
warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id,
timestamp.to_rfc3339()
);
}
// this should be a list of strings
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None,
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self {
user_id,
timestamp,
device_ids,
})
}
}
impl From<DeviceListRow> for RawAttributes {
fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new();
attrs.insert(
ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()),
);
attrs.insert(
ATTR_ITEM_ID.to_string(),
DeviceListKeyAttribute(device_list.timestamp).into(),
);
attrs.insert(
ATTR_TIMESTAMP.to_string(),
AttributeValue::N(device_list.timestamp.timestamp_millis().to_string()),
);
bartekAuthorUnsubmitted
Done
Inline Actions

Note that we use RFC 3339 string for ItemID while the ATTR_TIMESTAMP uses milliseconds number. Generally I use the former everywhere (simpler parsing without NaiveDateTime conversions) but I thought the latter is easier for DDB to sort by (it's used only as index sorting key and not read anywhere else)

bartek: Note that we use RFC 3339 string for `ItemID` while the `ATTR_TIMESTAMP` uses milliseconds…
attrs.insert(
ATTR_DEVICE_IDS.to_string(),
AttributeValue::L(
device_list
.device_ids
.into_iter()
.map(AttributeValue::S)
.collect(),
),
);
attrs
}
}