Page MenuHomePhabricator
Differential D13549

[web] Update thick threads avatar logic for web
ClosedPublic
Actions

Authored by ashoat on Sep 30 2024, 10:09 PM.
Tags
None
Referenced Files
F5803943: D13549.diff
Tue, Apr 15, 10:32 PM
Unknown Object (File)
Sun, Apr 6, 8:58 AM
Unknown Object (File)
Tue, Mar 25, 10:48 AM
Unknown Object (File)
Mar 6 2025, 6:39 PM
Unknown Object (File)
Feb 18 2025, 2:29 AM
Unknown Object (File)
Feb 18 2025, 2:29 AM
Unknown Object (File)
Feb 18 2025, 2:29 AM
Unknown Object (File)
Feb 18 2025, 2:28 AM
View All 46 Files
Subscribers
None

Details

Reviewers
tomek
kamil
inka
Commits
rCOMMfe2ee67a2e28: [web] Update thick threads avatar logic for web
Summary

Looks like web was missed in D13462.

Depends on D13548

Test Plan

Confirm that user's own avatar appears for pending PRIVATE thread

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
web/
avatars/
9 lines

Diff 44730

View Options

web/avatars/thread-avatar.react.js

Show All 34 Linesimport {
newThreadActionTypes, newThreadActionTypes,
} from '../actions/thread-actions.js'; } from '../actions/thread-actions.js';
import { import {
keyserverAuthActionTypes, keyserverAuthActionTypes,
deleteKeyserverAccountActionTypes, deleteKeyserverAccountActionTypes,
legacyLogInActionTypes, legacyLogInActionTypes,
} from '../actions/user-actions.js'; } from '../actions/user-actions.js';
import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js'; import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js';
import type { EntryStoreOperation } from '../ops/entries-store-ops.js';
import { entryID } from '../shared/entry-utils.js'; import { entryID } from '../shared/entry-utils.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js'; import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { threadInFilterList } from '../shared/thread-utils.js'; import { threadInFilterList } from '../shared/thread-utils.js';
import { updateSpecs } from '../shared/updates/update-specs.js'; import { updateSpecs } from '../shared/updates/update-specs.js';
import type { RawEntryInfo, EntryStore } from '../types/entry-types.js'; import type { RawEntryInfo, EntryStore } from '../types/entry-types.js';
import type { BaseAction } from '../types/redux-types.js'; import type { BaseAction } from '../types/redux-types.js';
import { type ClientEntryInconsistencyReportCreationRequest } from '../types/report-types.js'; import { type ClientEntryInconsistencyReportCreationRequest } from '../types/report-types.js';
import { import {
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines) {
const entryInfos = someEntryUpdated ? mergedEntryInfos : currentEntryInfos; const entryInfos = someEntryUpdated ? mergedEntryInfos : currentEntryInfos;
return [entryInfos, daysToEntries]; return [entryInfos, daysToEntries];
} }
function reduceEntryInfos( function reduceEntryInfos(
entryStore: EntryStore, entryStore: EntryStore,
action: BaseAction, action: BaseAction,
newThreadInfos: RawThreadInfos, newThreadInfos: RawThreadInfos,
): [EntryStore, $ReadOnlyArray<ClientEntryInconsistencyReportCreationRequest>] { ): {
+entryStore: EntryStore,
+entryStoreOperations: $ReadOnlyArray<EntryStoreOperation>,
+reportCreationRequests: $ReadOnlyArray<ClientEntryInconsistencyReportCreationRequest>,
} {
const { entryInfos, daysToEntries, lastUserInteractionCalendar } = entryStore; const { entryInfos, daysToEntries, lastUserInteractionCalendar } = entryStore;
if ( if (
action.type === deleteKeyserverAccountActionTypes.success || action.type === deleteKeyserverAccountActionTypes.success ||
action.type === deleteThreadActionTypes.success || action.type === deleteThreadActionTypes.success ||
action.type === leaveThreadActionTypes.success action.type === leaveThreadActionTypes.success
) { ) {
const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos); const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
const newEntryInfos = _pickBy( const newEntryInfos = _pickBy(
(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID], (entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
)(entryInfos); )(entryInfos);
if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) { if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
return [ return {
{ entryStore: {
entryInfos, entryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} }
const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos( const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
daysToEntries, daysToEntries,
newEntryInfos, newEntryInfos,
); );
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries, daysToEntries: newDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === setNewSessionActionType) { } else if (action.type === setNewSessionActionType) {
const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos); const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
const newEntryInfos = _pickBy( const newEntryInfos = _pickBy(
(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID], (entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
)(entryInfos); )(entryInfos);
const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos( const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
daysToEntries, daysToEntries,
newEntryInfos, newEntryInfos,
); );
let newLastUserInteractionCalendar = lastUserInteractionCalendar; let newLastUserInteractionCalendar = lastUserInteractionCalendar;
if ( if (
action.payload.sessionChange.cookieInvalidated && action.payload.sessionChange.cookieInvalidated &&
action.payload.keyserverID === authoritativeKeyserverID() && action.payload.keyserverID === authoritativeKeyserverID() &&
relyingOnAuthoritativeKeyserver relyingOnAuthoritativeKeyserver
) { ) {
newLastUserInteractionCalendar = 0; newLastUserInteractionCalendar = 0;
} }
if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) { if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
return [ return {
{ entryStore: {
entryInfos, entryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar: newLastUserInteractionCalendar, lastUserInteractionCalendar: newLastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} }
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries, daysToEntries: newDaysToEntries,
lastUserInteractionCalendar: newLastUserInteractionCalendar, lastUserInteractionCalendar: newLastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === fetchEntriesActionTypes.success) { } else if (action.type === fetchEntriesActionTypes.success) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
action.payload.rawEntryInfos, action.payload.rawEntryInfos,
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if ( } else if (
action.type === updateCalendarQueryActionTypes.started && action.type === updateCalendarQueryActionTypes.started &&
action.payload && action.payload &&
action.payload.calendarQuery action.payload.calendarQuery
) { ) {
return [ return {
{ entryStore: {
entryInfos, entryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === updateCalendarQueryActionTypes.success) { } else if (action.type === updateCalendarQueryActionTypes.success) {
const newLastUserInteractionCalendar = action.payload.calendarQuery const newLastUserInteractionCalendar = action.payload.calendarQuery
? Date.now() ? Date.now()
: lastUserInteractionCalendar; : lastUserInteractionCalendar;
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
action.payload.rawEntryInfos, action.payload.rawEntryInfos,
newThreadInfos, newThreadInfos,
); );
const deletionMarkedEntryInfos = markDeletedEntries( const deletionMarkedEntryInfos = markDeletedEntries(
updatedEntryInfos, updatedEntryInfos,
action.payload.deletedEntryIDs, action.payload.deletedEntryIDs,
); );
return [ return {
{ entryStore: {
entryInfos: deletionMarkedEntryInfos, entryInfos: deletionMarkedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: newLastUserInteractionCalendar, lastUserInteractionCalendar: newLastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === createLocalEntryActionType) { } else if (action.type === createLocalEntryActionType) {
const entryInfo = action.payload; const entryInfo = action.payload;
const localID = entryInfo.localID; const localID = entryInfo.localID;
invariant(localID, 'localID should be set in CREATE_LOCAL_ENTRY'); invariant(localID, 'localID should be set in CREATE_LOCAL_ENTRY');
const newEntryInfos = { const newEntryInfos = {
...entryInfos, ...entryInfos,
[(localID: string)]: entryInfo, [(localID: string)]: entryInfo,
}; };
const dayString = dateString( const dayString = dateString(
entryInfo.year, entryInfo.year,
entryInfo.month, entryInfo.month,
entryInfo.day, entryInfo.day,
); );
const newDaysToEntries = { const newDaysToEntries = {
...daysToEntries, ...daysToEntries,
[dayString]: _union([localID])(daysToEntries[dayString]), [dayString]: _union([localID])(daysToEntries[dayString]),
}; };
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries, daysToEntries: newDaysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === createEntryActionTypes.success) { } else if (action.type === createEntryActionTypes.success) {
const localID = action.payload.localID; const localID = action.payload.localID;
const serverID = action.payload.entryID; const serverID = action.payload.entryID;
// If an entry with this serverID already got into the store somehow // If an entry with this serverID already got into the store somehow
// (likely through an unrelated request), we need to dedup them. // (likely through an unrelated request), we need to dedup them.
let rekeyedEntryInfos; let rekeyedEntryInfos;
if (entryInfos[serverID]) { if (entryInfos[serverID]) {
// It's fair to assume the serverID entry is newer than the localID // It's fair to assume the serverID entry is newer than the localID
// entry, and this probably won't happen often, so for now we can just // entry, and this probably won't happen often, so for now we can just
// keep the serverID entry. // keep the serverID entry.
rekeyedEntryInfos = _omitBy( rekeyedEntryInfos = _omitBy(
(candidate: RawEntryInfo) => (candidate: RawEntryInfo) =>
!candidate.id && candidate.localID === localID, !candidate.id && candidate.localID === localID,
)(entryInfos); )(entryInfos);
} else if (entryInfos[localID]) { } else if (entryInfos[localID]) {
rekeyedEntryInfos = _mapKeys((oldKey: string) => rekeyedEntryInfos = _mapKeys((oldKey: string) =>
entryInfos[oldKey].localID === localID ? serverID : oldKey, entryInfos[oldKey].localID === localID ? serverID : oldKey,
)(entryInfos); )(entryInfos);
} else { } else {
// This happens if the entry is deauthorized before it's saved // This happens if the entry is deauthorized before it's saved
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
rekeyedEntryInfos, rekeyedEntryInfos,
null, null,
mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates), mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
newThreadInfos, newThreadInfos,
); );
return {
return [ entryStore: {
{
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === saveEntryActionTypes.success) { } else if (action.type === saveEntryActionTypes.success) {
const serverID = action.payload.entryID; const serverID = action.payload.entryID;
if ( if (
!entryInfos[serverID] || !entryInfos[serverID] ||
!threadInFilterList(newThreadInfos[entryInfos[serverID].threadID]) !threadInFilterList(newThreadInfos[entryInfos[serverID].threadID])
) { ) {
// This happens if the entry is deauthorized before it's saved // This happens if the entry is deauthorized before it's saved
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates), mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === concurrentModificationResetActionType) { } else if (action.type === concurrentModificationResetActionType) {
const { payload } = action; const { payload } = action;
if ( if (
!entryInfos[payload.id] || !entryInfos[payload.id] ||
!threadInFilterList(newThreadInfos[entryInfos[payload.id].threadID]) !threadInFilterList(newThreadInfos[entryInfos[payload.id].threadID])
) { ) {
// This happens if the entry is deauthorized before it's restored // This happens if the entry is deauthorized before it's restored
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const newEntryInfos = { const newEntryInfos = {
...entryInfos, ...entryInfos,
[payload.id]: { [payload.id]: {
...entryInfos[payload.id], ...entryInfos[payload.id],
text: payload.dbText, text: payload.dbText,
}, },
}; };
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === deleteEntryActionTypes.started) { } else if (action.type === deleteEntryActionTypes.started) {
const payload = action.payload; const payload = action.payload;
const id = const id =
payload.serverID && entryInfos[payload.serverID] payload.serverID && entryInfos[payload.serverID]
? payload.serverID ? payload.serverID
: payload.localID; : payload.localID;
invariant(id, 'either serverID or localID should be set'); invariant(id, 'either serverID or localID should be set');
const newEntryInfos = { const newEntryInfos = {
...entryInfos, ...entryInfos,
[(id: string)]: { [(id: string)]: {
...entryInfos[id], ...entryInfos[id],
deleted: true, deleted: true,
}, },
}; };
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === deleteEntryActionTypes.success) { } else if (action.type === deleteEntryActionTypes.success) {
const { payload } = action; const { payload } = action;
if (payload) { if (payload) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos([], payload.updatesResult.viewerUpdates), mergeUpdateEntryInfos([], payload.updatesResult.viewerUpdates),
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} }
} else if (action.type === fetchRevisionsForEntryActionTypes.success) { } else if (action.type === fetchRevisionsForEntryActionTypes.success) {
const id = action.payload.entryID; const id = action.payload.entryID;
if ( if (
!entryInfos[id] || !entryInfos[id] ||
!threadInFilterList(newThreadInfos[entryInfos[id].threadID]) !threadInFilterList(newThreadInfos[entryInfos[id].threadID])
) { ) {
// This happens if the entry is deauthorized before it's restored // This happens if the entry is deauthorized before it's restored
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
// Make sure the entry is in sync with its latest revision // Make sure the entry is in sync with its latest revision
const newEntryInfos = { const newEntryInfos = {
...entryInfos, ...entryInfos,
[id]: { [id]: {
...entryInfos[id], ...entryInfos[id],
text: action.payload.text, text: action.payload.text,
deleted: action.payload.deleted, deleted: action.payload.deleted,
}, },
}; };
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries, daysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === restoreEntryActionTypes.success) { } else if (action.type === restoreEntryActionTypes.success) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates), mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar: Date.now(), lastUserInteractionCalendar: Date.now(),
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if ( } else if (
action.type === legacyLogInActionTypes.success || action.type === legacyLogInActionTypes.success ||
action.type === legacySiweAuthActionTypes.success || action.type === legacySiweAuthActionTypes.success ||
action.type === keyserverAuthActionTypes.success action.type === keyserverAuthActionTypes.success
) { ) {
const { calendarResult } = action.payload; const { calendarResult } = action.payload;
if (calendarResult) { if (calendarResult) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
calendarResult.rawEntryInfos, calendarResult.rawEntryInfos,
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} }
} else if (action.type === incrementalStateSyncActionType) { } else if (action.type === incrementalStateSyncActionType) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos( mergeUpdateEntryInfos(
action.payload.deltaEntryInfos, action.payload.deltaEntryInfos,
action.payload.updatesResult.newUpdates, action.payload.updatesResult.newUpdates,
), ),
newThreadInfos, newThreadInfos,
); );
const deletionMarkedEntryInfos = markDeletedEntries( const deletionMarkedEntryInfos = markDeletedEntries(
updatedEntryInfos, updatedEntryInfos,
action.payload.deletedEntryIDs, action.payload.deletedEntryIDs,
); );
return [ return {
{ entryStore: {
entryInfos: deletionMarkedEntryInfos, entryInfos: deletionMarkedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if ( } else if (
action.type === processUpdatesActionType || action.type === processUpdatesActionType ||
action.type === joinThreadActionTypes.success || action.type === joinThreadActionTypes.success ||
action.type === newThreadActionTypes.success action.type === newThreadActionTypes.success
) { ) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
mergeUpdateEntryInfos([], action.payload.updatesResult.newUpdates), mergeUpdateEntryInfos([], action.payload.updatesResult.newUpdates),
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === fullStateSyncActionType) { } else if (action.type === fullStateSyncActionType) {
const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos( const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
entryInfos, entryInfos,
daysToEntries, daysToEntries,
action.payload.rawEntryInfos, action.payload.rawEntryInfos,
newThreadInfos, newThreadInfos,
); );
return [ return {
{ entryStore: {
entryInfos: updatedEntryInfos, entryInfos: updatedEntryInfos,
daysToEntries: updatedDaysToEntries, daysToEntries: updatedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if ( } else if (
action.type === changeThreadSettingsActionTypes.success || action.type === changeThreadSettingsActionTypes.success ||
action.type === removeUsersFromThreadActionTypes.success || action.type === removeUsersFromThreadActionTypes.success ||
action.type === changeThreadMemberRolesActionTypes.success action.type === changeThreadMemberRolesActionTypes.success
) { ) {
const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos); const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
const newEntryInfos = _pickBy( const newEntryInfos = _pickBy(
(entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID], (entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
)(entryInfos); )(entryInfos);
if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) { if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos( const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
daysToEntries, daysToEntries,
newEntryInfos, newEntryInfos,
); );
return [ return {
{ entryStore: {
entryInfos: newEntryInfos, entryInfos: newEntryInfos,
daysToEntries: newDaysToEntries, daysToEntries: newDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
[], entryStoreOperations: [],
]; reportCreationRequests: [],
};
} else if (action.type === processServerRequestsActionType) { } else if (action.type === processServerRequestsActionType) {
const checkStateRequest = action.payload.serverRequests.find( const checkStateRequest = action.payload.serverRequests.find(
candidate => candidate.type === serverRequestTypes.CHECK_STATE, candidate => candidate.type === serverRequestTypes.CHECK_STATE,
); );
if (!checkStateRequest || !checkStateRequest.stateChanges) { if (!checkStateRequest || !checkStateRequest.stateChanges) {
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const { rawEntryInfos, deleteEntryIDs } = checkStateRequest.stateChanges; const { rawEntryInfos, deleteEntryIDs } = checkStateRequest.stateChanges;
if (!rawEntryInfos && !deleteEntryIDs) { if (!rawEntryInfos && !deleteEntryIDs) {
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
const updatedEntryInfos: { [string]: RawEntryInfo } = { ...entryInfos }; const updatedEntryInfos: { [string]: RawEntryInfo } = { ...entryInfos };
if (deleteEntryIDs) { if (deleteEntryIDs) {
for (const deleteEntryID of deleteEntryIDs) { for (const deleteEntryID of deleteEntryIDs) {
delete updatedEntryInfos[deleteEntryID]; delete updatedEntryInfos[deleteEntryID];
} }
} }
Show All 15 Lines ) {
} }
const newInconsistencies = stateSyncSpecs.entries.findStoreInconsistencies( const newInconsistencies = stateSyncSpecs.entries.findStoreInconsistencies(
action, action,
entryInfos, entryInfos,
mergedEntryInfos, mergedEntryInfos,
); );
return [ return {
{ entryStore: {
entryInfos: mergedEntryInfos, entryInfos: mergedEntryInfos,
daysToEntries: mergedDaysToEntries, daysToEntries: mergedDaysToEntries,
lastUserInteractionCalendar, lastUserInteractionCalendar,
}, },
newInconsistencies, entryStoreOperations: [],
]; reportCreationRequests: newInconsistencies,
};
} }
return [entryStore, []]; return {
entryStore,
entryStoreOperations: [],
reportCreationRequests: [],
};
} }
function mergeUpdateEntryInfos( function mergeUpdateEntryInfos(
entryInfos: $ReadOnlyArray<RawEntryInfo>, entryInfos: $ReadOnlyArray<RawEntryInfo>,
newUpdates: $ReadOnlyArray<ClientUpdateInfo>, newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
): RawEntryInfo[] { ): RawEntryInfo[] {
const entryIDs = new Set( const entryIDs = new Set(
entryInfos.map(entryInfo => entryInfo.id).filter(Boolean), entryInfos.map(entryInfo => entryInfo.id).filter(Boolean),
Show All 34 Lines