Page MenuHomePhabricator
Differential D14445

[native] hide community directory prompt on dev
AcceptedPublic
Actions

Authored by varun on Sun, Mar 16, 3:03 PM.
Tags
None
Referenced Files
F4950914: D14445.diff
Thu, Mar 20, 10:52 AM
Unknown Object (File)
Wed, Mar 19, 9:18 PM
Subscribers
tomek

Details

Reviewers
ashoat
Summary

we don't want to annoy devs with this prompt when they log in

Depends on D14444

Test Plan

didn't really test this. change is pretty straightforward

Diff Detail

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

Revision Contents
Changeset List

PathSize
native/
components/
2 lines

Diff 47410

View Options

native/components/display-community-directory-prompt.react.js

// @flow // @flow
import _mapValues from 'lodash/fp/mapValues.js'; import _mapValues from 'lodash/fp/mapValues.js';
import type { DMOperationStoreOperation } from '../ops/dm-operations-store-ops.js';
import { import {
clearQueuedEntryDMOpsActionType, clearQueuedEntryDMOpsActionType,
clearQueuedMembershipDMOpsActionType, clearQueuedMembershipDMOpsActionType,
clearQueuedMessageDMOpsActionType, clearQueuedMessageDMOpsActionType,
clearQueuedThreadDMOpsActionType, clearQueuedThreadDMOpsActionType,
type OperationsQueue, type OperationsQueue,
pruneDMOpsQueueActionType, pruneDMOpsQueueActionType,
type QueuedDMOperations, type QueuedDMOperations,
queueDMOpsActionType, queueDMOpsActionType,
} from '../types/dm-ops.js'; } from '../types/dm-ops.js';
import type { BaseAction } from '../types/redux-types.js'; import type { BaseAction } from '../types/redux-types.js';
function reduceDMOperationsQueue( function reduceDMOperationsQueue(
store: QueuedDMOperations, store: QueuedDMOperations,
action: BaseAction, action: BaseAction,
): QueuedDMOperations { ): {
+store: QueuedDMOperations,
+operations: $ReadOnlyArray<DMOperationStoreOperation>,
} {
if (action.type === queueDMOpsActionType) { if (action.type === queueDMOpsActionType) {
const { condition, operation, timestamp } = action.payload; const { condition, operation, timestamp } = action.payload;
if (condition.type === 'thread') { if (condition.type === 'thread') {
return { return {
store: {
...store, ...store,
threadQueue: { threadQueue: {
...store.threadQueue, ...store.threadQueue,
[condition.threadID]: [ [condition.threadID]: [
...(store.threadQueue[condition.threadID] ?? []), ...(store.threadQueue[condition.threadID] ?? []),
{ operation, timestamp }, { operation, timestamp },
], ],
}, },
},
operations: [],
}; };
} }
if (condition.type === 'entry') { if (condition.type === 'entry') {
return { return {
store: {
...store, ...store,
entryQueue: { entryQueue: {
...store.entryQueue, ...store.entryQueue,
[condition.entryID]: [ [condition.entryID]: [
...(store.entryQueue[condition.entryID] ?? []), ...(store.entryQueue[condition.entryID] ?? []),
{ operation, timestamp }, { operation, timestamp },
], ],
}, },
},
operations: [],
}; };
} }
if (condition.type === 'message') { if (condition.type === 'message') {
return { return {
store: {
...store, ...store,
messageQueue: { messageQueue: {
...store.messageQueue, ...store.messageQueue,
[condition.messageID]: [ [condition.messageID]: [
...(store.messageQueue[condition.messageID] ?? []), ...(store.messageQueue[condition.messageID] ?? []),
{ operation, timestamp }, { operation, timestamp },
], ],
}, },
},
operations: [],
}; };
} }
return { return {
store: {
...store, ...store,
membershipQueue: { membershipQueue: {
...store.membershipQueue, ...store.membershipQueue,
[condition.threadID]: { [condition.threadID]: {
...(store.membershipQueue[condition.threadID] ?? {}), ...(store.membershipQueue[condition.threadID] ?? {}),
[condition.userID]: [ [condition.userID]: [
...(store.membershipQueue[condition.threadID]?.[condition.userID] ?? ...(store.membershipQueue[condition.threadID]?.[
[]), condition.userID
] ?? []),
{ operation, timestamp }, { operation, timestamp },
], ],
}, },
}, },
},
operations: [],
}; };
} else if (action.type === pruneDMOpsQueueActionType) { } else if (action.type === pruneDMOpsQueueActionType) {
const filterOperations = (queue: OperationsQueue) => const filterOperations = (queue: OperationsQueue) =>
queue.filter(op => op.timestamp >= action.payload.pruneMaxTimestamp); queue.filter(op => op.timestamp >= action.payload.pruneMaxTimestamp);
return { return {
store: {
...store, ...store,
threadQueue: _mapValues(operations => filterOperations(operations))( threadQueue: _mapValues(operations => filterOperations(operations))(
store.threadQueue, store.threadQueue,
), ),
messageQueue: _mapValues(operations => filterOperations(operations))( messageQueue: _mapValues(operations => filterOperations(operations))(
store.messageQueue, store.messageQueue,
), ),
entryQueue: _mapValues(operations => filterOperations(operations))( entryQueue: _mapValues(operations => filterOperations(operations))(
store.entryQueue, store.entryQueue,
), ),
membershipQueue: _mapValues(threadMembershipQueue => membershipQueue: _mapValues(threadMembershipQueue =>
_mapValues(operations => filterOperations(operations))( _mapValues(operations => filterOperations(operations))(
threadMembershipQueue, threadMembershipQueue,
), ),
)(store.membershipQueue), )(store.membershipQueue),
},
operations: [],
}; };
} else if (action.type === clearQueuedThreadDMOpsActionType) { } else if (action.type === clearQueuedThreadDMOpsActionType) {
const { [action.payload.threadID]: removed, ...threadQueue } = const { [action.payload.threadID]: removed, ...threadQueue } =
store.threadQueue; store.threadQueue;
return { return {
store: {
...store, ...store,
threadQueue, threadQueue,
},
operations: [],
}; };
} else if (action.type === clearQueuedMessageDMOpsActionType) { } else if (action.type === clearQueuedMessageDMOpsActionType) {
const { [action.payload.messageID]: removed, ...messageQueue } = const { [action.payload.messageID]: removed, ...messageQueue } =
store.messageQueue; store.messageQueue;
return { return {
store: {
...store, ...store,
messageQueue, messageQueue,
},
operations: [],
}; };
} else if (action.type === clearQueuedEntryDMOpsActionType) { } else if (action.type === clearQueuedEntryDMOpsActionType) {
const { [action.payload.entryID]: removed, ...entryQueue } = const { [action.payload.entryID]: removed, ...entryQueue } =
store.entryQueue; store.entryQueue;
return { return {
store: {
...store, ...store,
entryQueue, entryQueue,
},
operations: [],
}; };
} else if (action.type === clearQueuedMembershipDMOpsActionType) { } else if (action.type === clearQueuedMembershipDMOpsActionType) {
const threadQueue = store.membershipQueue[action.payload.threadID]; const threadQueue = store.membershipQueue[action.payload.threadID];
if (!threadQueue) { if (!threadQueue) {
return store; return { store, operations: [] };
} }
const { [action.payload.userID]: removed, ...queue } = threadQueue; const { [action.payload.userID]: removed, ...queue } = threadQueue;
if (Object.keys(queue).length === 0) { if (Object.keys(queue).length === 0) {
const { [action.payload.threadID]: removedThread, ...membershipQueue } = const { [action.payload.threadID]: removedThread, ...membershipQueue } =
store.membershipQueue; store.membershipQueue;
return { return {
store: {
...store, ...store,
membershipQueue, membershipQueue,
},
operations: [],
}; };
} }
return { return {
store: {
...store, ...store,
membershipQueue: { membershipQueue: {
...store.membershipQueue, ...store.membershipQueue,
[action.payload.userID]: queue, [action.payload.userID]: queue,
}, },
},
operations: [],
}; };
} }
return store; return { store, operations: [] };
} }
export { reduceDMOperationsQueue }; export { reduceDMOperationsQueue };