Page MenuHomePhabricator
Differential D13728

[lib] Mark missing users when fetching device lists
ClosedPublic
Actions

Authored by inka on Oct 16 2024, 8:33 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 2, 4:09 PM
Unknown Object (File)
Wed, Apr 2, 1:31 PM
Unknown Object (File)
Tue, Apr 1, 9:47 PM
Unknown Object (File)
Tue, Apr 1, 9:02 PM
Unknown Object (File)
Tue, Apr 1, 4:27 PM
Unknown Object (File)
Feb 28 2025, 6:06 AM
Unknown Object (File)
Feb 28 2025, 5:46 AM
Unknown Object (File)
Jan 31 2025, 7:47 PM
View All 78 Files
Subscribers
ashoat

Details

Reviewers
tomek
kamil
Commits
rCOMMe03089ba3f24: [lib] Mark missing users when fetching device lists
Summary

issue: ENG-9631

Test Plan

Tested that when a user is missing a device list the accountMissingStatus is set. Checked that lastChecked is updated with next requests but missingSince stays the same.

checked that if non-empty a device list is returned by identity, accountMissingStatus is removed.

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
lib/
shared/
dm-ops/
20 lines
11 lines

Diff 45255

View Options

lib/shared/dm-ops/dm-op-utils.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import _groupBy from 'lodash/fp/groupBy.js'; import _groupBy from 'lodash/fp/groupBy.js';
import * as React from 'react'; import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import { type ProcessDMOperationUtilities } from './dm-op-spec.js'; import { type ProcessDMOperationUtilities } from './dm-op-spec.js';
import { dmOpSpecs } from './dm-op-specs.js'; import { dmOpSpecs } from './dm-op-specs.js';
import { useProcessAndSendDMOperation } from './process-dm-ops.js'; import { useProcessAndSendDMOperation } from './process-dm-ops.js';
import { setMissingDeviceListsActionType } from '../../actions/aux-user-actions.js';
import { useFindUserIdentities } from '../../actions/find-user-identities-actions.js'; import { useFindUserIdentities } from '../../actions/find-user-identities-actions.js';
import { useLoggedInUserInfo } from '../../hooks/account-hooks.js'; import { useLoggedInUserInfo } from '../../hooks/account-hooks.js';
import { useGetLatestMessageEdit } from '../../hooks/latest-message-edit.js'; import { useGetLatestMessageEdit } from '../../hooks/latest-message-edit.js';
import { useGetAndUpdateDeviceListsForUsers } from '../../hooks/peer-list-hooks.js'; import { useGetAndUpdateDeviceListsForUsers } from '../../hooks/peer-list-hooks.js';
import { mergeUpdatesWithMessageInfos } from '../../reducers/message-reducer.js'; import { mergeUpdatesWithMessageInfos } from '../../reducers/message-reducer.js';
import { getAllPeerUserIDAndDeviceIDs } from '../../selectors/user-selectors.js'; import { getAllPeerUserIDAndDeviceIDs } from '../../selectors/user-selectors.js';
import { type P2PMessageRecipient } from '../../tunnelbroker/peer-to-peer-context.js'; import { type P2PMessageRecipient } from '../../tunnelbroker/peer-to-peer-context.js';
import type { import type {
Show All 20 Lines
import type { RawThreadInfos } from '../../types/thread-types.js'; import type { RawThreadInfos } from '../../types/thread-types.js';
import { import {
type DMOperationP2PMessage, type DMOperationP2PMessage,
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
} from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import { updateTypes } from '../../types/update-types-enum.js'; import { updateTypes } from '../../types/update-types-enum.js';
import type { ClientUpdateInfo } from '../../types/update-types.js'; import type { ClientUpdateInfo } from '../../types/update-types.js';
import { getContentSigningKey } from '../../utils/crypto-utils.js'; import { getContentSigningKey } from '../../utils/crypto-utils.js';
import { useSelector } from '../../utils/redux-utils.js'; import { useSelector, useDispatch } from '../../utils/redux-utils.js';
import { messageSpecs } from '../messages/message-specs.js'; import { messageSpecs } from '../messages/message-specs.js';
import { userHasDeviceList } from '../thread-utils.js'; import { userHasDeviceList } from '../thread-utils.js';
function generateMessagesToPeers( function generateMessagesToPeers(
message: DMOperation, message: DMOperation,
peers: $ReadOnlyArray<{ peers: $ReadOnlyArray<{
+userID: string, +userID: string,
+deviceID: string, +deviceID: string,
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
function useCreateMessagesToPeersFromDMOp(): ( function useCreateMessagesToPeersFromDMOp(): (
operation: DMOperation, operation: DMOperation,
recipients: OutboundDMOperationSpecificationRecipients, recipients: OutboundDMOperationSpecificationRecipients,
) => Promise<$ReadOnlyArray<OutboundP2PMessage>> { ) => Promise<$ReadOnlyArray<OutboundP2PMessage>> {
const allPeerUserIDAndDeviceIDs = useSelector(getAllPeerUserIDAndDeviceIDs); const allPeerUserIDAndDeviceIDs = useSelector(getAllPeerUserIDAndDeviceIDs);
const utilities = useSendDMOperationUtils(); const utilities = useSendDMOperationUtils();
const auxUserInfos = useSelector(state => state.auxUserStore.auxUserInfos); const auxUserInfos = useSelector(state => state.auxUserStore.auxUserInfos);
const getAndUpdateDeviceListsForUsers = useGetAndUpdateDeviceListsForUsers(); const getAndUpdateDeviceListsForUsers = useGetAndUpdateDeviceListsForUsers();
const dispatch = useDispatch();
const getUsersWithoutDeviceList = React.useCallback( const getUsersWithoutDeviceList = React.useCallback(
(userIDs: $ReadOnlyArray<string>) => { (userIDs: $ReadOnlyArray<string>) => {
const missingDeviceListsUserIDs: Array<string> = []; const missingDeviceListsUserIDs: Array<string> = [];
for (const userID of userIDs) { for (const userID of userIDs) {
const supportsThickThreads = userHasDeviceList(userID, auxUserInfos); const supportsThickThreads = userHasDeviceList(userID, auxUserInfos);
if (!supportsThickThreads) { if (!supportsThickThreads) {
missingDeviceListsUserIDs.push(userID); missingDeviceListsUserIDs.push(userID);
Show All 13 Lines ): Promise<$ReadOnlyArray<P2PMessageRecipient>> => {
return []; return [];
} }
const deviceLists = await getAndUpdateDeviceListsForUsers( const deviceLists = await getAndUpdateDeviceListsForUsers(
missingDeviceListsUserIDs, missingDeviceListsUserIDs,
true, true,
); );
const missingUsers: $ReadOnlyArray<string> =
missingDeviceListsUserIDs.filter(id => !deviceLists[id]);
if (missingUsers.length > 0) {
dispatch({
type: setMissingDeviceListsActionType,
payload: {
usersMissingFromIdentity: {
userIDs: missingUsers,
time: Date.now(),
},
},
});
}
const updatedPeers: Array<P2PMessageRecipient> = []; const updatedPeers: Array<P2PMessageRecipient> = [];
for (const userID of missingDeviceListsUserIDs) { for (const userID of missingDeviceListsUserIDs) {
if (deviceLists[userID] && deviceLists[userID].devices.length > 0) { if (deviceLists[userID] && deviceLists[userID].devices.length > 0) {
updatedPeers.push( updatedPeers.push(
...deviceLists[userID].devices.map(deviceID => ({ ...deviceLists[userID].devices.map(deviceID => ({
deviceID, deviceID,
userID, userID,
})), })),
); );
} }
} }
return updatedPeers; return updatedPeers;
}, },
[getAndUpdateDeviceListsForUsers, getUsersWithoutDeviceList], [dispatch, getAndUpdateDeviceListsForUsers, getUsersWithoutDeviceList],
); );
return React.useCallback( return React.useCallback(
async ( async (
operation: DMOperation, operation: DMOperation,
recipients: OutboundDMOperationSpecificationRecipients, recipients: OutboundDMOperationSpecificationRecipients,
): Promise<$ReadOnlyArray<OutboundP2PMessage>> => { ): Promise<$ReadOnlyArray<OutboundP2PMessage>> => {
const { viewerID, threadInfos } = utilities; const { viewerID, threadInfos } = utilities;
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines
View Options

lib/shared/thread-utils.js

Show All 36 Linesimport {
threadInfosSelectorForThreadType, threadInfosSelectorForThreadType,
onScreenThreadInfos, onScreenThreadInfos,
} from '../selectors/thread-selectors.js'; } from '../selectors/thread-selectors.js';
import { import {
getRelativeMemberInfos, getRelativeMemberInfos,
usersWithPersonalThreadSelector, usersWithPersonalThreadSelector,
} from '../selectors/user-selectors.js'; } from '../selectors/user-selectors.js';
import type { AuxUserInfos } from '../types/aux-user-types.js'; import type { AuxUserInfos } from '../types/aux-user-types.js';
import type { RawDeviceList } from '../types/identity-service-types.js';
import type { import type {
RelativeMemberInfo, RelativeMemberInfo,
RawThreadInfo, RawThreadInfo,
MemberInfoWithPermissions, MemberInfoWithPermissions,
RoleInfo, RoleInfo,
ThreadInfo, ThreadInfo,
MinimallyEncodedThickMemberInfo, MinimallyEncodedThickMemberInfo,
ThinRawThreadInfo, ThinRawThreadInfo,
▲ Show 20 Lines • Show All 1,766 Lines • ▼ Show 20 Lines return {
}, },
}; };
} }
function userHasDeviceList( function userHasDeviceList(
userID: string, userID: string,
auxUserInfos: AuxUserInfos, auxUserInfos: AuxUserInfos,
): boolean { ): boolean {
return ( return deviceListIsNonEmpty(auxUserInfos[userID]?.deviceList);
!!auxUserInfos[userID]?.deviceList && }
auxUserInfos[userID].deviceList.devices.length > 0
); function deviceListIsNonEmpty(deviceList?: RawDeviceList): boolean {
return !!deviceList && deviceList.devices.length > 0;
} }
export { export {
threadHasPermission, threadHasPermission,
useCommunityRootMembersToRole, useCommunityRootMembersToRole,
useThreadHasPermission, useThreadHasPermission,
viewerIsMember, viewerIsMember,
threadInChatList, threadInChatList,
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesexport {
useOldestPrivateThreadInfo, useOldestPrivateThreadInfo,
useUserProfileThreadInfo, useUserProfileThreadInfo,
assertAllThreadInfosAreLegacy, assertAllThreadInfosAreLegacy,
useOnScreenEntryEditableThreadInfos, useOnScreenEntryEditableThreadInfos,
extractMentionedMembers, extractMentionedMembers,
isMemberActive, isMemberActive,
createThreadTimestamps, createThreadTimestamps,
userHasDeviceList, userHasDeviceList,
deviceListIsNonEmpty,
}; };