Page MenuHomePhabricator
Differential D10133

[lib] `ResolvedThreadInfo` -> `LegacyResolvedThreadInfo`
ClosedPublic
Actions

Authored by atul on Dec 1 2023, 5:49 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 16, 7:45 PM
Unknown Object (File)
Wed, Apr 9, 12:13 PM
Unknown Object (File)
Tue, Apr 8, 2:47 PM
Unknown Object (File)
Tue, Apr 8, 12:11 PM
Unknown Object (File)
Tue, Apr 8, 8:04 AM
Unknown Object (File)
Mon, Apr 7, 7:41 AM
Unknown Object (File)
Feb 27 2025, 7:23 PM
Unknown Object (File)
Feb 27 2025, 7:15 PM
View All 80 Files
Subscribers
None

Details

Reviewers
ashoat
ginsu
tomek
rohan
Commits
rCOMM774b77618c90: [lib] `ResolvedThreadInfo` -> `LegacyResolvedThreadInfo`
Summary

Simple rename similar to D10077 and D10095, but for ResolvedThreadInfo

Depends on D10128

Test Plan

CI/flow/etc

Diff Detail

Repository
rCOMM Comm
Branch
master
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

Diff 34104

View Options

lib/components/chat-mention-provider.react.js

Show All 20 Lines
// eslint-disable-next-line no-unused-vars // eslint-disable-next-line no-unused-vars
function SecondaryDeviceQRCodeScanner(props: Props): React.Node { function SecondaryDeviceQRCodeScanner(props: Props): React.Node {
const [hasPermission, setHasPermission] = React.useState<?boolean>(null); const [hasPermission, setHasPermission] = React.useState<?boolean>(null);
const [scanned, setScanned] = React.useState(false); const [scanned, setScanned] = React.useState(false);
const styles = useStyles(unboundStyles); const styles = useStyles(unboundStyles);
const navigation = useNavigation(); const navigation = useNavigation();
const tunnelbrokerContext = useTunnelbroker();
const identityContext = React.useContext(IdentityClientContext);
const addDeviceToList = React.useCallback(
async (newDeviceID: string) => {
invariant(identityContext, 'identity context not set');
const { getDeviceListHistoryForUser, updateDeviceList } =
identityContext.identityClient;
invariant(
updateDeviceList,
'updateDeviceList() should be defined for primary device',
);
const authMetadata = await identityContext.getAuthMetadata();
if (!authMetadata?.userID) {
throw new Error('missing auth metadata');
}
const deviceLists = await getDeviceListHistoryForUser(
authMetadata.userID,
);
const lastSignedDeviceList = deviceLists[deviceLists.length - 1];
const deviceList: RawDeviceList = JSON.parse(
lastSignedDeviceList.rawDeviceList,
);
const { devices } = deviceList;
if (!devices.includes(newDeviceID)) {
const newDeviceList: RawDeviceList = {
devices: [...devices, newDeviceID],
timestamp: Date.now(),
};
await updateDeviceList({
rawDeviceList: JSON.stringify(newDeviceList),
});
return true;
} else {
return false;
}
},
[identityContext],
);
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const { status } = await BarCodeScanner.requestPermissionsAsync(); const { status } = await BarCodeScanner.requestPermissionsAsync();
setHasPermission(status === 'granted'); setHasPermission(status === 'granted');
if (status !== 'granted') { if (status !== 'granted') {
Alert.alert( Alert.alert(
'No access to camera', 'No access to camera',
'Please allow Comm to access your camera in order to scan the QR code.', 'Please allow Comm to access your camera in order to scan the QR code.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
navigation.goBack(); navigation.goBack();
} }
})(); })();
}, [navigation]); }, [navigation]);
const onConnect = React.useCallback((barCodeEvent: BarCodeEvent) => { const onConnect = React.useCallback(
(barCodeEvent: BarCodeEvent) => {
const { data } = barCodeEvent; const { data } = barCodeEvent;
const parsedData = parseDataFromDeepLink(data); const parsedData = parseDataFromDeepLink(data);
const keysMatch = parsedData?.data?.keys; const keysMatch = parsedData?.data?.keys;
if (!parsedData || !keysMatch) { if (!parsedData || !keysMatch) {
Alert.alert( Alert.alert(
'Scan failed', 'Scan failed',
'QR code does not contain a valid pair of keys.', 'QR code does not contain a valid pair of keys.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
return; return;
} }
const keys = JSON.parse(decodeURIComponent(keysMatch)); const keys = JSON.parse(decodeURIComponent(keysMatch));
const { aes256, ed25519 } = keys;
void (async () => {
try {
invariant(identityContext, 'identity context not set');
const { deviceID: primaryDeviceID, userID } =
await identityContext.getAuthMetadata();
if (!primaryDeviceID || !userID) {
throw new Error('missing auth metadata');
}
await addDeviceToList(ed25519);
const message = createQRAuthTunnelbrokerMessage(aes256, {
type: qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS,
userID,
primaryDeviceID,
});
await tunnelbrokerContext.sendMessage({
deviceID: ed25519,
payload: JSON.stringify(message),
});
} catch (err) {
console.log('Primary device error:', err);
Alert.alert( Alert.alert(
'Scan successful', 'Adding device failed',
`QR code contains the following keys: ${JSON.stringify(keys)}`, 'Failed to update the device list',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
}, []); navigation.goBack();
}
})();
},
[
tunnelbrokerContext,
addDeviceToList,
identityContext,
navigation,
],
);
const onCancelScan = React.useCallback(() => setScanned(false), []); const onCancelScan = React.useCallback(() => setScanned(false), []);
const handleBarCodeScanned = React.useCallback( const handleBarCodeScanned = React.useCallback(
(barCodeEvent: BarCodeEvent) => { (barCodeEvent: BarCodeEvent) => {
setScanned(true); setScanned(true);
Alert.alert( Alert.alert(
'Connect with this device?', 'Connect with this device?',
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines
View Options

lib/shared/markdown.js

Show All 20 Lines
// eslint-disable-next-line no-unused-vars // eslint-disable-next-line no-unused-vars
function SecondaryDeviceQRCodeScanner(props: Props): React.Node { function SecondaryDeviceQRCodeScanner(props: Props): React.Node {
const [hasPermission, setHasPermission] = React.useState<?boolean>(null); const [hasPermission, setHasPermission] = React.useState<?boolean>(null);
const [scanned, setScanned] = React.useState(false); const [scanned, setScanned] = React.useState(false);
const styles = useStyles(unboundStyles); const styles = useStyles(unboundStyles);
const navigation = useNavigation(); const navigation = useNavigation();
const tunnelbrokerContext = useTunnelbroker();
const identityContext = React.useContext(IdentityClientContext);
const addDeviceToList = React.useCallback(
async (newDeviceID: string) => {
invariant(identityContext, 'identity context not set');
const { getDeviceListHistoryForUser, updateDeviceList } =
identityContext.identityClient;
invariant(
updateDeviceList,
'updateDeviceList() should be defined for primary device',
);
const authMetadata = await identityContext.getAuthMetadata();
if (!authMetadata?.userID) {
throw new Error('missing auth metadata');
}
const deviceLists = await getDeviceListHistoryForUser(
authMetadata.userID,
);
const lastSignedDeviceList = deviceLists[deviceLists.length - 1];
const deviceList: RawDeviceList = JSON.parse(
lastSignedDeviceList.rawDeviceList,
);
const { devices } = deviceList;
if (!devices.includes(newDeviceID)) {
const newDeviceList: RawDeviceList = {
devices: [...devices, newDeviceID],
timestamp: Date.now(),
};
await updateDeviceList({
rawDeviceList: JSON.stringify(newDeviceList),
});
return true;
} else {
return false;
}
},
[identityContext],
);
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const { status } = await BarCodeScanner.requestPermissionsAsync(); const { status } = await BarCodeScanner.requestPermissionsAsync();
setHasPermission(status === 'granted'); setHasPermission(status === 'granted');
if (status !== 'granted') { if (status !== 'granted') {
Alert.alert( Alert.alert(
'No access to camera', 'No access to camera',
'Please allow Comm to access your camera in order to scan the QR code.', 'Please allow Comm to access your camera in order to scan the QR code.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
navigation.goBack(); navigation.goBack();
} }
})(); })();
}, [navigation]); }, [navigation]);
const onConnect = React.useCallback((barCodeEvent: BarCodeEvent) => { const onConnect = React.useCallback(
(barCodeEvent: BarCodeEvent) => {
const { data } = barCodeEvent; const { data } = barCodeEvent;
const parsedData = parseDataFromDeepLink(data); const parsedData = parseDataFromDeepLink(data);
const keysMatch = parsedData?.data?.keys; const keysMatch = parsedData?.data?.keys;
if (!parsedData || !keysMatch) { if (!parsedData || !keysMatch) {
Alert.alert( Alert.alert(
'Scan failed', 'Scan failed',
'QR code does not contain a valid pair of keys.', 'QR code does not contain a valid pair of keys.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
return; return;
} }
const keys = JSON.parse(decodeURIComponent(keysMatch)); const keys = JSON.parse(decodeURIComponent(keysMatch));
const { aes256, ed25519 } = keys;
void (async () => {
try {
invariant(identityContext, 'identity context not set');
const { deviceID: primaryDeviceID, userID } =
await identityContext.getAuthMetadata();
if (!primaryDeviceID || !userID) {
throw new Error('missing auth metadata');
}
await addDeviceToList(ed25519);
const message = createQRAuthTunnelbrokerMessage(aes256, {
type: qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS,
userID,
primaryDeviceID,
});
await tunnelbrokerContext.sendMessage({
deviceID: ed25519,
payload: JSON.stringify(message),
});
} catch (err) {
console.log('Primary device error:', err);
Alert.alert( Alert.alert(
'Scan successful', 'Adding device failed',
`QR code contains the following keys: ${JSON.stringify(keys)}`, 'Failed to update the device list',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
}, []); navigation.goBack();
}
})();
},
[
tunnelbrokerContext,
addDeviceToList,
identityContext,
navigation,
],
);
const onCancelScan = React.useCallback(() => setScanned(false), []); const onCancelScan = React.useCallback(() => setScanned(false), []);
const handleBarCodeScanned = React.useCallback( const handleBarCodeScanned = React.useCallback(
(barCodeEvent: BarCodeEvent) => { (barCodeEvent: BarCodeEvent) => {
setScanned(true); setScanned(true);
Alert.alert( Alert.alert(
'Connect with this device?', 'Connect with this device?',
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines
View Options

lib/shared/mention-utils.js

Show All 20 Lines
// eslint-disable-next-line no-unused-vars // eslint-disable-next-line no-unused-vars
function SecondaryDeviceQRCodeScanner(props: Props): React.Node { function SecondaryDeviceQRCodeScanner(props: Props): React.Node {
const [hasPermission, setHasPermission] = React.useState<?boolean>(null); const [hasPermission, setHasPermission] = React.useState<?boolean>(null);
const [scanned, setScanned] = React.useState(false); const [scanned, setScanned] = React.useState(false);
const styles = useStyles(unboundStyles); const styles = useStyles(unboundStyles);
const navigation = useNavigation(); const navigation = useNavigation();
const tunnelbrokerContext = useTunnelbroker();
const identityContext = React.useContext(IdentityClientContext);
const addDeviceToList = React.useCallback(
async (newDeviceID: string) => {
invariant(identityContext, 'identity context not set');
const { getDeviceListHistoryForUser, updateDeviceList } =
identityContext.identityClient;
invariant(
updateDeviceList,
'updateDeviceList() should be defined for primary device',
);
const authMetadata = await identityContext.getAuthMetadata();
if (!authMetadata?.userID) {
throw new Error('missing auth metadata');
}
const deviceLists = await getDeviceListHistoryForUser(
authMetadata.userID,
);
const lastSignedDeviceList = deviceLists[deviceLists.length - 1];
const deviceList: RawDeviceList = JSON.parse(
lastSignedDeviceList.rawDeviceList,
);
const { devices } = deviceList;
if (!devices.includes(newDeviceID)) {
const newDeviceList: RawDeviceList = {
devices: [...devices, newDeviceID],
timestamp: Date.now(),
};
await updateDeviceList({
rawDeviceList: JSON.stringify(newDeviceList),
});
return true;
} else {
return false;
}
},
[identityContext],
);
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const { status } = await BarCodeScanner.requestPermissionsAsync(); const { status } = await BarCodeScanner.requestPermissionsAsync();
setHasPermission(status === 'granted'); setHasPermission(status === 'granted');
if (status !== 'granted') { if (status !== 'granted') {
Alert.alert( Alert.alert(
'No access to camera', 'No access to camera',
'Please allow Comm to access your camera in order to scan the QR code.', 'Please allow Comm to access your camera in order to scan the QR code.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
navigation.goBack(); navigation.goBack();
} }
})(); })();
}, [navigation]); }, [navigation]);
const onConnect = React.useCallback((barCodeEvent: BarCodeEvent) => { const onConnect = React.useCallback(
(barCodeEvent: BarCodeEvent) => {
const { data } = barCodeEvent; const { data } = barCodeEvent;
const parsedData = parseDataFromDeepLink(data); const parsedData = parseDataFromDeepLink(data);
const keysMatch = parsedData?.data?.keys; const keysMatch = parsedData?.data?.keys;
if (!parsedData || !keysMatch) { if (!parsedData || !keysMatch) {
Alert.alert( Alert.alert(
'Scan failed', 'Scan failed',
'QR code does not contain a valid pair of keys.', 'QR code does not contain a valid pair of keys.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
return; return;
} }
const keys = JSON.parse(decodeURIComponent(keysMatch)); const keys = JSON.parse(decodeURIComponent(keysMatch));
const { aes256, ed25519 } = keys;
void (async () => {
try {
invariant(identityContext, 'identity context not set');
const { deviceID: primaryDeviceID, userID } =
await identityContext.getAuthMetadata();
if (!primaryDeviceID || !userID) {
throw new Error('missing auth metadata');
}
await addDeviceToList(ed25519);
const message = createQRAuthTunnelbrokerMessage(aes256, {
type: qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS,
userID,
primaryDeviceID,
});
await tunnelbrokerContext.sendMessage({
deviceID: ed25519,
payload: JSON.stringify(message),
});
} catch (err) {
console.log('Primary device error:', err);
Alert.alert( Alert.alert(
'Scan successful', 'Adding device failed',
`QR code contains the following keys: ${JSON.stringify(keys)}`, 'Failed to update the device list',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
}, []); navigation.goBack();
}
})();
},
[
tunnelbrokerContext,
addDeviceToList,
identityContext,
navigation,
],
);
const onCancelScan = React.useCallback(() => setScanned(false), []); const onCancelScan = React.useCallback(() => setScanned(false), []);
const handleBarCodeScanned = React.useCallback( const handleBarCodeScanned = React.useCallback(
(barCodeEvent: BarCodeEvent) => { (barCodeEvent: BarCodeEvent) => {
setScanned(true); setScanned(true);
Alert.alert( Alert.alert(
'Connect with this device?', 'Connect with this device?',
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines
View Options

lib/shared/mention-utils.test.js

Show All 20 Lines
// eslint-disable-next-line no-unused-vars // eslint-disable-next-line no-unused-vars
function SecondaryDeviceQRCodeScanner(props: Props): React.Node { function SecondaryDeviceQRCodeScanner(props: Props): React.Node {
const [hasPermission, setHasPermission] = React.useState<?boolean>(null); const [hasPermission, setHasPermission] = React.useState<?boolean>(null);
const [scanned, setScanned] = React.useState(false); const [scanned, setScanned] = React.useState(false);
const styles = useStyles(unboundStyles); const styles = useStyles(unboundStyles);
const navigation = useNavigation(); const navigation = useNavigation();
const tunnelbrokerContext = useTunnelbroker();
const identityContext = React.useContext(IdentityClientContext);
const addDeviceToList = React.useCallback(
async (newDeviceID: string) => {
invariant(identityContext, 'identity context not set');
const { getDeviceListHistoryForUser, updateDeviceList } =
identityContext.identityClient;
invariant(
updateDeviceList,
'updateDeviceList() should be defined for primary device',
);
const authMetadata = await identityContext.getAuthMetadata();
if (!authMetadata?.userID) {
throw new Error('missing auth metadata');
}
const deviceLists = await getDeviceListHistoryForUser(
authMetadata.userID,
);
const lastSignedDeviceList = deviceLists[deviceLists.length - 1];
const deviceList: RawDeviceList = JSON.parse(
lastSignedDeviceList.rawDeviceList,
);
const { devices } = deviceList;
if (!devices.includes(newDeviceID)) {
const newDeviceList: RawDeviceList = {
devices: [...devices, newDeviceID],
timestamp: Date.now(),
};
await updateDeviceList({
rawDeviceList: JSON.stringify(newDeviceList),
});
return true;
} else {
return false;
}
},
[identityContext],
);
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const { status } = await BarCodeScanner.requestPermissionsAsync(); const { status } = await BarCodeScanner.requestPermissionsAsync();
setHasPermission(status === 'granted'); setHasPermission(status === 'granted');
if (status !== 'granted') { if (status !== 'granted') {
Alert.alert( Alert.alert(
'No access to camera', 'No access to camera',
'Please allow Comm to access your camera in order to scan the QR code.', 'Please allow Comm to access your camera in order to scan the QR code.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
navigation.goBack(); navigation.goBack();
} }
})(); })();
}, [navigation]); }, [navigation]);
const onConnect = React.useCallback((barCodeEvent: BarCodeEvent) => { const onConnect = React.useCallback(
(barCodeEvent: BarCodeEvent) => {
const { data } = barCodeEvent; const { data } = barCodeEvent;
const parsedData = parseDataFromDeepLink(data); const parsedData = parseDataFromDeepLink(data);
const keysMatch = parsedData?.data?.keys; const keysMatch = parsedData?.data?.keys;
if (!parsedData || !keysMatch) { if (!parsedData || !keysMatch) {
Alert.alert( Alert.alert(
'Scan failed', 'Scan failed',
'QR code does not contain a valid pair of keys.', 'QR code does not contain a valid pair of keys.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
return; return;
} }
const keys = JSON.parse(decodeURIComponent(keysMatch)); const keys = JSON.parse(decodeURIComponent(keysMatch));
const { aes256, ed25519 } = keys;
void (async () => {
try {
invariant(identityContext, 'identity context not set');
const { deviceID: primaryDeviceID, userID } =
await identityContext.getAuthMetadata();
if (!primaryDeviceID || !userID) {
throw new Error('missing auth metadata');
}
await addDeviceToList(ed25519);
const message = createQRAuthTunnelbrokerMessage(aes256, {
type: qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS,
userID,
primaryDeviceID,
});
await tunnelbrokerContext.sendMessage({
deviceID: ed25519,
payload: JSON.stringify(message),
});
} catch (err) {
console.log('Primary device error:', err);
Alert.alert( Alert.alert(
'Scan successful', 'Adding device failed',
`QR code contains the following keys: ${JSON.stringify(keys)}`, 'Failed to update the device list',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
}, []); navigation.goBack();
}
})();
},
[
tunnelbrokerContext,
addDeviceToList,
identityContext,
navigation,
],
);
const onCancelScan = React.useCallback(() => setScanned(false), []); const onCancelScan = React.useCallback(() => setScanned(false), []);
const handleBarCodeScanned = React.useCallback( const handleBarCodeScanned = React.useCallback(
(barCodeEvent: BarCodeEvent) => { (barCodeEvent: BarCodeEvent) => {
setScanned(true); setScanned(true);
Alert.alert( Alert.alert(
'Connect with this device?', 'Connect with this device?',
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines
View Options

lib/types/filter-types.js

Show All 20 Lines
// eslint-disable-next-line no-unused-vars // eslint-disable-next-line no-unused-vars
function SecondaryDeviceQRCodeScanner(props: Props): React.Node { function SecondaryDeviceQRCodeScanner(props: Props): React.Node {
const [hasPermission, setHasPermission] = React.useState<?boolean>(null); const [hasPermission, setHasPermission] = React.useState<?boolean>(null);
const [scanned, setScanned] = React.useState(false); const [scanned, setScanned] = React.useState(false);
const styles = useStyles(unboundStyles); const styles = useStyles(unboundStyles);
const navigation = useNavigation(); const navigation = useNavigation();
const tunnelbrokerContext = useTunnelbroker();
const identityContext = React.useContext(IdentityClientContext);
const addDeviceToList = React.useCallback(
async (newDeviceID: string) => {
invariant(identityContext, 'identity context not set');
const { getDeviceListHistoryForUser, updateDeviceList } =
identityContext.identityClient;
invariant(
updateDeviceList,
'updateDeviceList() should be defined for primary device',
);
const authMetadata = await identityContext.getAuthMetadata();
if (!authMetadata?.userID) {
throw new Error('missing auth metadata');
}
const deviceLists = await getDeviceListHistoryForUser(
authMetadata.userID,
);
const lastSignedDeviceList = deviceLists[deviceLists.length - 1];
const deviceList: RawDeviceList = JSON.parse(
lastSignedDeviceList.rawDeviceList,
);
const { devices } = deviceList;
if (!devices.includes(newDeviceID)) {
const newDeviceList: RawDeviceList = {
devices: [...devices, newDeviceID],
timestamp: Date.now(),
};
await updateDeviceList({
rawDeviceList: JSON.stringify(newDeviceList),
});
return true;
} else {
return false;
}
},
[identityContext],
);
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const { status } = await BarCodeScanner.requestPermissionsAsync(); const { status } = await BarCodeScanner.requestPermissionsAsync();
setHasPermission(status === 'granted'); setHasPermission(status === 'granted');
if (status !== 'granted') { if (status !== 'granted') {
Alert.alert( Alert.alert(
'No access to camera', 'No access to camera',
'Please allow Comm to access your camera in order to scan the QR code.', 'Please allow Comm to access your camera in order to scan the QR code.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
navigation.goBack(); navigation.goBack();
} }
})(); })();
}, [navigation]); }, [navigation]);
const onConnect = React.useCallback((barCodeEvent: BarCodeEvent) => { const onConnect = React.useCallback(
(barCodeEvent: BarCodeEvent) => {
const { data } = barCodeEvent; const { data } = barCodeEvent;
const parsedData = parseDataFromDeepLink(data); const parsedData = parseDataFromDeepLink(data);
const keysMatch = parsedData?.data?.keys; const keysMatch = parsedData?.data?.keys;
if (!parsedData || !keysMatch) { if (!parsedData || !keysMatch) {
Alert.alert( Alert.alert(
'Scan failed', 'Scan failed',
'QR code does not contain a valid pair of keys.', 'QR code does not contain a valid pair of keys.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
return; return;
} }
const keys = JSON.parse(decodeURIComponent(keysMatch)); const keys = JSON.parse(decodeURIComponent(keysMatch));
const { aes256, ed25519 } = keys;
void (async () => {
try {
invariant(identityContext, 'identity context not set');
const { deviceID: primaryDeviceID, userID } =
await identityContext.getAuthMetadata();
if (!primaryDeviceID || !userID) {
throw new Error('missing auth metadata');
}
await addDeviceToList(ed25519);
const message = createQRAuthTunnelbrokerMessage(aes256, {
type: qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS,
userID,
primaryDeviceID,
});
await tunnelbrokerContext.sendMessage({
deviceID: ed25519,
payload: JSON.stringify(message),
});
} catch (err) {
console.log('Primary device error:', err);
Alert.alert( Alert.alert(
'Scan successful', 'Adding device failed',
`QR code contains the following keys: ${JSON.stringify(keys)}`, 'Failed to update the device list',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
}, []); navigation.goBack();
}
})();
},
[
tunnelbrokerContext,
addDeviceToList,
identityContext,
navigation,
],
);
const onCancelScan = React.useCallback(() => setScanned(false), []); const onCancelScan = React.useCallback(() => setScanned(false), []);
const handleBarCodeScanned = React.useCallback( const handleBarCodeScanned = React.useCallback(
(barCodeEvent: BarCodeEvent) => { (barCodeEvent: BarCodeEvent) => {
setScanned(true); setScanned(true);
Alert.alert( Alert.alert(
'Connect with this device?', 'Connect with this device?',
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines
View Options

lib/types/thread-types.js

Show All 20 Lines
// eslint-disable-next-line no-unused-vars // eslint-disable-next-line no-unused-vars
function SecondaryDeviceQRCodeScanner(props: Props): React.Node { function SecondaryDeviceQRCodeScanner(props: Props): React.Node {
const [hasPermission, setHasPermission] = React.useState<?boolean>(null); const [hasPermission, setHasPermission] = React.useState<?boolean>(null);
const [scanned, setScanned] = React.useState(false); const [scanned, setScanned] = React.useState(false);
const styles = useStyles(unboundStyles); const styles = useStyles(unboundStyles);
const navigation = useNavigation(); const navigation = useNavigation();
const tunnelbrokerContext = useTunnelbroker();
const identityContext = React.useContext(IdentityClientContext);
const addDeviceToList = React.useCallback(
async (newDeviceID: string) => {
invariant(identityContext, 'identity context not set');
const { getDeviceListHistoryForUser, updateDeviceList } =
identityContext.identityClient;
invariant(
updateDeviceList,
'updateDeviceList() should be defined for primary device',
);
const authMetadata = await identityContext.getAuthMetadata();
if (!authMetadata?.userID) {
throw new Error('missing auth metadata');
}
const deviceLists = await getDeviceListHistoryForUser(
authMetadata.userID,
);
const lastSignedDeviceList = deviceLists[deviceLists.length - 1];
const deviceList: RawDeviceList = JSON.parse(
lastSignedDeviceList.rawDeviceList,
);
const { devices } = deviceList;
if (!devices.includes(newDeviceID)) {
const newDeviceList: RawDeviceList = {
devices: [...devices, newDeviceID],
timestamp: Date.now(),
};
await updateDeviceList({
rawDeviceList: JSON.stringify(newDeviceList),
});
return true;
} else {
return false;
}
},
[identityContext],
);
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const { status } = await BarCodeScanner.requestPermissionsAsync(); const { status } = await BarCodeScanner.requestPermissionsAsync();
setHasPermission(status === 'granted'); setHasPermission(status === 'granted');
if (status !== 'granted') { if (status !== 'granted') {
Alert.alert( Alert.alert(
'No access to camera', 'No access to camera',
'Please allow Comm to access your camera in order to scan the QR code.', 'Please allow Comm to access your camera in order to scan the QR code.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
navigation.goBack(); navigation.goBack();
} }
})(); })();
}, [navigation]); }, [navigation]);
const onConnect = React.useCallback((barCodeEvent: BarCodeEvent) => { const onConnect = React.useCallback(
(barCodeEvent: BarCodeEvent) => {
const { data } = barCodeEvent; const { data } = barCodeEvent;
const parsedData = parseDataFromDeepLink(data); const parsedData = parseDataFromDeepLink(data);
const keysMatch = parsedData?.data?.keys; const keysMatch = parsedData?.data?.keys;
if (!parsedData || !keysMatch) { if (!parsedData || !keysMatch) {
Alert.alert( Alert.alert(
'Scan failed', 'Scan failed',
'QR code does not contain a valid pair of keys.', 'QR code does not contain a valid pair of keys.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
return; return;
} }
const keys = JSON.parse(decodeURIComponent(keysMatch)); const keys = JSON.parse(decodeURIComponent(keysMatch));
const { aes256, ed25519 } = keys;
void (async () => {
try {
invariant(identityContext, 'identity context not set');
const { deviceID: primaryDeviceID, userID } =
await identityContext.getAuthMetadata();
if (!primaryDeviceID || !userID) {
throw new Error('missing auth metadata');
}
await addDeviceToList(ed25519);
const message = createQRAuthTunnelbrokerMessage(aes256, {
type: qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS,
userID,
primaryDeviceID,
});
await tunnelbrokerContext.sendMessage({
deviceID: ed25519,
payload: JSON.stringify(message),
});
} catch (err) {
console.log('Primary device error:', err);
Alert.alert( Alert.alert(
'Scan successful', 'Adding device failed',
`QR code contains the following keys: ${JSON.stringify(keys)}`, 'Failed to update the device list',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
}, []); navigation.goBack();
}
})();
},
[
tunnelbrokerContext,
addDeviceToList,
identityContext,
navigation,
],
);
const onCancelScan = React.useCallback(() => setScanned(false), []); const onCancelScan = React.useCallback(() => setScanned(false), []);
const handleBarCodeScanned = React.useCallback( const handleBarCodeScanned = React.useCallback(
(barCodeEvent: BarCodeEvent) => { (barCodeEvent: BarCodeEvent) => {
setScanned(true); setScanned(true);
Alert.alert( Alert.alert(
'Connect with this device?', 'Connect with this device?',
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines
View Options

lib/utils/drawer-utils.react.js

Show All 20 Lines
// eslint-disable-next-line no-unused-vars // eslint-disable-next-line no-unused-vars
function SecondaryDeviceQRCodeScanner(props: Props): React.Node { function SecondaryDeviceQRCodeScanner(props: Props): React.Node {
const [hasPermission, setHasPermission] = React.useState<?boolean>(null); const [hasPermission, setHasPermission] = React.useState<?boolean>(null);
const [scanned, setScanned] = React.useState(false); const [scanned, setScanned] = React.useState(false);
const styles = useStyles(unboundStyles); const styles = useStyles(unboundStyles);
const navigation = useNavigation(); const navigation = useNavigation();
const tunnelbrokerContext = useTunnelbroker();
const identityContext = React.useContext(IdentityClientContext);
const addDeviceToList = React.useCallback(
async (newDeviceID: string) => {
invariant(identityContext, 'identity context not set');
const { getDeviceListHistoryForUser, updateDeviceList } =
identityContext.identityClient;
invariant(
updateDeviceList,
'updateDeviceList() should be defined for primary device',
);
const authMetadata = await identityContext.getAuthMetadata();
if (!authMetadata?.userID) {
throw new Error('missing auth metadata');
}
const deviceLists = await getDeviceListHistoryForUser(
authMetadata.userID,
);
const lastSignedDeviceList = deviceLists[deviceLists.length - 1];
const deviceList: RawDeviceList = JSON.parse(
lastSignedDeviceList.rawDeviceList,
);
const { devices } = deviceList;
if (!devices.includes(newDeviceID)) {
const newDeviceList: RawDeviceList = {
devices: [...devices, newDeviceID],
timestamp: Date.now(),
};
await updateDeviceList({
rawDeviceList: JSON.stringify(newDeviceList),
});
return true;
} else {
return false;
}
},
[identityContext],
);
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const { status } = await BarCodeScanner.requestPermissionsAsync(); const { status } = await BarCodeScanner.requestPermissionsAsync();
setHasPermission(status === 'granted'); setHasPermission(status === 'granted');
if (status !== 'granted') { if (status !== 'granted') {
Alert.alert( Alert.alert(
'No access to camera', 'No access to camera',
'Please allow Comm to access your camera in order to scan the QR code.', 'Please allow Comm to access your camera in order to scan the QR code.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
navigation.goBack(); navigation.goBack();
} }
})(); })();
}, [navigation]); }, [navigation]);
const onConnect = React.useCallback((barCodeEvent: BarCodeEvent) => { const onConnect = React.useCallback(
(barCodeEvent: BarCodeEvent) => {
const { data } = barCodeEvent; const { data } = barCodeEvent;
const parsedData = parseDataFromDeepLink(data); const parsedData = parseDataFromDeepLink(data);
const keysMatch = parsedData?.data?.keys; const keysMatch = parsedData?.data?.keys;
if (!parsedData || !keysMatch) { if (!parsedData || !keysMatch) {
Alert.alert( Alert.alert(
'Scan failed', 'Scan failed',
'QR code does not contain a valid pair of keys.', 'QR code does not contain a valid pair of keys.',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
return; return;
} }
const keys = JSON.parse(decodeURIComponent(keysMatch)); const keys = JSON.parse(decodeURIComponent(keysMatch));
const { aes256, ed25519 } = keys;
void (async () => {
try {
invariant(identityContext, 'identity context not set');
const { deviceID: primaryDeviceID, userID } =
await identityContext.getAuthMetadata();
if (!primaryDeviceID || !userID) {
throw new Error('missing auth metadata');
}
await addDeviceToList(ed25519);
const message = createQRAuthTunnelbrokerMessage(aes256, {
type: qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS,
userID,
primaryDeviceID,
});
await tunnelbrokerContext.sendMessage({
deviceID: ed25519,
payload: JSON.stringify(message),
});
} catch (err) {
console.log('Primary device error:', err);
Alert.alert( Alert.alert(
'Scan successful', 'Adding device failed',
`QR code contains the following keys: ${JSON.stringify(keys)}`, 'Failed to update the device list',
[{ text: 'OK' }], [{ text: 'OK' }],
); );
}, []); navigation.goBack();
}
})();
},
[
tunnelbrokerContext,
addDeviceToList,
identityContext,
navigation,
],
);
const onCancelScan = React.useCallback(() => setScanned(false), []); const onCancelScan = React.useCallback(() => setScanned(false), []);
const handleBarCodeScanned = React.useCallback( const handleBarCodeScanned = React.useCallback(
(barCodeEvent: BarCodeEvent) => { (barCodeEvent: BarCodeEvent) => {
setScanned(true); setScanned(true);
Alert.alert( Alert.alert(
'Connect with this device?', 'Connect with this device?',
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines
View Options

lib/utils/entity-helpers.js

Loading...
View Options

native/avatars/thread-avatar.react.js

Loading...
View Options

native/calendar/entry.react.js

Loading...
View Options

native/chat/settings/delete-thread.react.js

Loading...
View Options

native/chat/settings/thread-settings-avatar.react.js

Loading...
View Options

native/chat/settings/thread-settings-delete-thread.react.js

Loading...
View Options

native/chat/settings/thread-settings-name.react.js

Loading...
View Options

native/chat/settings/thread-settings.react.js

Loading...
View Options

native/components/thread-list-thread.react.js

Loading...
View Options

native/markdown/markdown-chat-mention.react.js

Loading...
View Options

web/calendar/entry.react.js

Loading...
View Options

web/markdown/markdown-chat-mention.react.js

Loading...
View Options

web/modals/history/history-entry.react.js

Loading...