Page MenuHomePhabricator
Differential D14051

[native] Rename the QR sign-in navigator
ClosedPublic
Actions

Authored by tomek on Nov 26 2024, 8:13 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Mar 5, 3:06 AM
Unknown Object (File)
Wed, Mar 5, 3:06 AM
Unknown Object (File)
Wed, Mar 5, 3:06 AM
Unknown Object (File)
Wed, Mar 5, 3:06 AM
Unknown Object (File)
Wed, Mar 5, 3:06 AM
Unknown Object (File)
Mar 2 2025, 2:01 AM
Unknown Object (File)
Feb 6 2025, 8:43 PM
Unknown Object (File)
Feb 6 2025, 8:43 PM
View All 68 Files
Subscribers
ashoat

Details

Reviewers
kamil
angelika
bartek
Commits
rCOMM39eccd8276bd: [native] Rename the QR sign-in navigator
Summary

This navigator will also handle the restore flow so it has to be renamed.

Depends on D13905

Test Plan

Flow. Tested in combination with the rest of the stack.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
native/
account/
4 lines
navigation/
8 lines
10 lines
qr-code/
4 lines
sign-in-navigator.react.js
qr-code-sign-in-navigator.react.js
25 lines

Diff 46182

View Options

native/account/logged-out-modal.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 };
View Options

native/navigation/root-navigator.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 };
View Options

native/navigation/route-names.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 };
View Options

native/qr-code/qr-code-screen.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 };
View Options

native/qr-code/qr-code-sign-in-navigator.react.js

Loading...
View Options

native/qr-code/sign-in-navigator.react.js

Loading...