[web/native] display `userID` & `deviceID` in devtools
ClosedPublic
Actions

Authored by kamil on Apr 8 2024, 5:51 AM.

Details

Reviewers

bartek
marcin
tomek

Commits

rCOMM0e7881604a04: [web/native] display `userID` & `deviceID` in devtools

Summary

This is for testing purposes - helps debug things or send messages between two different clients.

Visible only for staff.

Test Plan

Web:

Native:

Diff Detail

Repository

rCOMM Comm

Branch

publish-session-resetting

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

kamil created this revision.Apr 8 2024, 5:51 AM

kamil held this revision as a draft.

Herald added a subscriber: ashoat. · View Herald TranscriptApr 8 2024, 5:51 AM

kamil edited the summary of this revision. (Show Details)Apr 8 2024, 5:59 AM

kamil edited the test plan for this revision. (Show Details)

Harbormaster failed remote builds in B28040: Diff 38889!Apr 8 2024, 6:03 AM

fix type

kamil added a child revision: D11574: [web/native] improve rendering Tunnelbroker messages.Apr 8 2024, 6:07 AM

Harbormaster completed remote builds in B28042: Diff 38891.Apr 8 2024, 6:19 AM

kamil published this revision for review.Apr 9 2024, 6:00 AM

marcin accepted this revision.Apr 10 2024, 1:20 AM

This revision is now accepted and ready to land.Apr 10 2024, 1:20 AM

Closed by commit rCOMM0e7881604a04: [web/native] display `userID` & `deviceID` in devtools (authored by kamil). · Explain WhyApr 10 2024, 6:05 AM

This revision was automatically updated to reflect the committed changes.

kamil added a commit: rCOMM0e7881604a04: [web/native] display `userID` & `deviceID` in devtools.

Revision Contents
Changeset List

Path

Size

native/

profile/

tunnelbroker-menu.react.js

27 lines

web/

settings/

account-settings.react.js

39 lines

Diff 38891

View Options

native/profile/tunnelbroker-menu.react.js

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines	processDMOperation: async (
dmOperation: DMJoinThreadOperation,		dmOperation: DMJoinThreadOperation,
viewerID: string,		viewerID: string,
utilities: ProcessDMOperationUtilities,		utilities: ProcessDMOperationUtilities,
) => {		) => {
const { joinerID, time, messageID, existingThreadDetails } = dmOperation;		const { joinerID, time, messageID, existingThreadDetails } = dmOperation;

const currentThreadInfo =		const currentThreadInfo =
utilities.threadInfos[existingThreadDetails.threadID];		utilities.threadInfos[existingThreadDetails.threadID];
		if (currentThreadInfo && !currentThreadInfo.thick) {
		return {
		rawMessageInfos: [],
		updateInfos: [],
		};
		}

const messageData = createMessageDataFromDMOperation(dmOperation);		const messageData = createMessageDataFromDMOperation(dmOperation);
const joinThreadMessageInfos = [		const joinThreadMessageInfos = [
rawMessageInfoFromMessageData(messageData, messageID),		rawMessageInfoFromMessageData(messageData, messageID),
];		];

if (userIsMember(currentThreadInfo, joinerID)) {		const memberTimestamps = { ...currentThreadInfo?.timestamps?.members };
		if (!memberTimestamps[joinerID]) {
		memberTimestamps[joinerID] = {
		isMember: time,
		subscription: existingThreadDetails.creationTime,
		};
		}

		if (memberTimestamps[joinerID].isMember > time) {
		inkaUnsubmitted Not Done Inline Actions Same as in the previous diff we should probably handle timestamp collision inka: Same as in the previous diff we should probably handle timestamp collision
		tomekAuthorUnsubmitted Done Inline Actions https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution tomek: https://linear.app/comm/issue/ENG-9159/thick-threads-timestamps-conflict-resolution
return {		return {
rawMessageInfos: joinThreadMessageInfos,		rawMessageInfos: joinThreadMessageInfos,
updateInfos: [],		updateInfos: [],
};		};
}		}

		memberTimestamps[joinerID] = {
		...memberTimestamps[joinerID],
		isMember: time,
		};

const updateInfos: Array<ClientUpdateInfo> = [];		const updateInfos: Array<ClientUpdateInfo> = [];
const rawMessageInfos: Array<RawMessageInfo> = [];		const rawMessageInfos: Array<RawMessageInfo> = [];
if (viewerID === joinerID) {
		if (userIsMember(currentThreadInfo, joinerID)) {
		rawMessageInfos.push(...joinThreadMessageInfos);
		updateInfos.push({
		type: updateTypes.UPDATE_THREAD,
		id: uuid.v4(),
		time,
		threadInfo: {
		...currentThreadInfo,
		timestamps: {
		...currentThreadInfo.timestamps,
		members: memberTimestamps,
		},
		},
		});
		} else if (viewerID === joinerID) {
const newThreadInfo = createThickRawThreadInfo(		const newThreadInfo = createThickRawThreadInfo(
{		{
...existingThreadDetails,		...existingThreadDetails,
allMemberIDsWithSubscriptions: [		allMemberIDsWithSubscriptions: [
...existingThreadDetails.allMemberIDsWithSubscriptions,		...existingThreadDetails.allMemberIDsWithSubscriptions,
{ id: joinerID, subscription: joinThreadSubscription },		{ id: joinerID, subscription: joinThreadSubscription },
],		],
},		},
viewerID,		viewerID,
);		);
updateInfos.push({		updateInfos.push({
type: updateTypes.JOIN_THREAD,		type: updateTypes.JOIN_THREAD,
id: uuid.v4(),		id: uuid.v4(),
time,		time,
threadInfo: newThreadInfo,		threadInfo: {
		...newThreadInfo,
		timestamps: {
		...newThreadInfo.timestamps,
		members: memberTimestamps,
		},
		},
rawMessageInfos: joinThreadMessageInfos,		rawMessageInfos: joinThreadMessageInfos,
truncationStatus: messageTruncationStatus.EXHAUSTIVE,		truncationStatus: messageTruncationStatus.EXHAUSTIVE,
rawEntryInfos: [],		rawEntryInfos: [],
});		});
} else {		} else {
invariant(currentThreadInfo.thick, 'Thread should be thick');

rawMessageInfos.push(...joinThreadMessageInfos);		rawMessageInfos.push(...joinThreadMessageInfos);
const defaultRoleID = values(currentThreadInfo.roles).find(role =>		const defaultRoleID = values(currentThreadInfo.roles).find(role =>
roleIsDefaultRole(role),		roleIsDefaultRole(role),
)?.id;		)?.id;
invariant(defaultRoleID, 'Default role ID must exist');		invariant(defaultRoleID, 'Default role ID must exist');
const { membershipPermissions } = createRoleAndPermissionForThickThreads(		const { membershipPermissions } = createRoleAndPermissionForThickThreads(
currentThreadInfo.type,		currentThreadInfo.type,
currentThreadInfo.id,		currentThreadInfo.id,
defaultRoleID,		defaultRoleID,
);		);

const member = minimallyEncodeMemberInfo<ThickMemberInfo>({		const member = minimallyEncodeMemberInfo<ThickMemberInfo>({
id: joinerID,		id: joinerID,
role: defaultRoleID,		role: defaultRoleID,
permissions: membershipPermissions,		permissions: membershipPermissions,
isSender: joinerID === viewerID,		isSender: joinerID === viewerID,
subscription: joinThreadSubscription,		subscription: joinThreadSubscription,
});		});
const updatedThreadInfo = {		const updatedThreadInfo = {
...currentThreadInfo,		...currentThreadInfo,
members: [...currentThreadInfo.members, member],		members: [...currentThreadInfo.members, member],
		timestamps: {
		...currentThreadInfo.timestamps,
		members: memberTimestamps,
		},
};		};
updateInfos.push({		updateInfos.push({
type: updateTypes.UPDATE_THREAD,		type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),		id: uuid.v4(),
time,		time,
threadInfo: updatedThreadInfo,		threadInfo: updatedThreadInfo,
});		});
}		}
return {		return {
rawMessageInfos,		rawMessageInfos,
updateInfos,		updateInfos,
};		};
},		},
canBeProcessed(		canBeProcessed(
dmOperation: DMJoinThreadOperation,		dmOperation: DMJoinThreadOperation,
viewerID: string,		viewerID: string,
utilities: ProcessDMOperationUtilities,		utilities: ProcessDMOperationUtilities,
) {		) {
if (utilities.threadInfos[dmOperation.existingThreadDetails.threadID]) {		if (
		utilities.threadInfos[dmOperation.existingThreadDetails.threadID] \|\|
		dmOperation.joinerID === viewerID
		) {
return { isProcessingPossible: true };		return { isProcessingPossible: true };
}		}
return {		return {
isProcessingPossible: false,		isProcessingPossible: false,
reason: {		reason: {
type: 'missing_thread',		type: 'missing_thread',
threadID: dmOperation.existingThreadDetails.threadID,		threadID: dmOperation.existingThreadDetails.threadID,
},		},
};		};
},		},
supportsAutoRetry: true,		supportsAutoRetry: true,
});		});

export { joinThreadSpec };		export { joinThreadSpec };