Page MenuHomePhabricator
Files F3509429

No OneTemporary
Actions

View Options

diff --git a/lib/actions/entry-actions.js b/lib/actions/entry-actions.js
index 342afdd7b..dfdc6f522 100644
--- a/lib/actions/entry-actions.js
+++ b/lib/actions/entry-actions.js
@@ -1,189 +1,186 @@
// @flow
import type {
RawEntryInfo,
CalendarQuery,
SaveEntryInfo,
SaveEntryResponse,
CreateEntryInfo,
CreateEntryPayload,
DeleteEntryInfo,
DeleteEntryResponse,
RestoreEntryInfo,
RestoreEntryResponse,
FetchEntryInfosResult,
CalendarQueryUpdateResult,
} from '../types/entry-types';
import type { FetchJSON } from '../utils/fetch-json';
import type { HistoryRevisionInfo } from '../types/history-types';
import { dateFromString } from '../utils/date-utils';
-import { values } from '../utils/objects';
const fetchEntriesActionTypes = Object.freeze({
started: 'FETCH_ENTRIES_STARTED',
success: 'FETCH_ENTRIES_SUCCESS',
failed: 'FETCH_ENTRIES_FAILED',
});
async function fetchEntries(
fetchJSON: FetchJSON,
calendarQuery: CalendarQuery,
): Promise<FetchEntryInfosResult> {
const response = await fetchJSON('fetch_entries', calendarQuery);
return {
rawEntryInfos: response.rawEntryInfos,
- userInfos: values(response.userInfos),
};
}
const updateCalendarQueryActionTypes = Object.freeze({
started: 'UPDATE_CALENDAR_QUERY_STARTED',
success: 'UPDATE_CALENDAR_QUERY_SUCCESS',
failed: 'UPDATE_CALENDAR_QUERY_FAILED',
});
async function updateCalendarQuery(
fetchJSON: FetchJSON,
calendarQuery: CalendarQuery,
reduxAlreadyUpdated: boolean = false,
): Promise<CalendarQueryUpdateResult> {
const response = await fetchJSON('update_calendar_query', calendarQuery);
- const { rawEntryInfos, deletedEntryIDs, userInfos } = response;
+ const { rawEntryInfos, deletedEntryIDs } = response;
return {
rawEntryInfos,
deletedEntryIDs,
- userInfos,
calendarQuery,
calendarQueryAlreadyUpdated: reduxAlreadyUpdated,
};
}
const createLocalEntryActionType = 'CREATE_LOCAL_ENTRY';
function createLocalEntry(
threadID: string,
localID: number,
dateString: string,
creatorID: string,
): RawEntryInfo {
const date = dateFromString(dateString);
const newEntryInfo: RawEntryInfo = {
localID: `local${localID}`,
threadID,
text: '',
year: date.getFullYear(),
month: date.getMonth() + 1,
day: date.getDate(),
creationTime: Date.now(),
creatorID,
deleted: false,
};
return newEntryInfo;
}
const createEntryActionTypes = Object.freeze({
started: 'CREATE_ENTRY_STARTED',
success: 'CREATE_ENTRY_SUCCESS',
failed: 'CREATE_ENTRY_FAILED',
});
async function createEntry(
fetchJSON: FetchJSON,
request: CreateEntryInfo,
): Promise<CreateEntryPayload> {
const result = await fetchJSON('create_entry', request);
return {
entryID: result.entryID,
newMessageInfos: result.newMessageInfos,
threadID: request.threadID,
localID: request.localID,
updatesResult: result.updatesResult,
};
}
const saveEntryActionTypes = Object.freeze({
started: 'SAVE_ENTRY_STARTED',
success: 'SAVE_ENTRY_SUCCESS',
failed: 'SAVE_ENTRY_FAILED',
});
const concurrentModificationResetActionType = 'CONCURRENT_MODIFICATION_RESET';
async function saveEntry(
fetchJSON: FetchJSON,
request: SaveEntryInfo,
): Promise<SaveEntryResponse> {
const result = await fetchJSON('update_entry', request);
return {
entryID: result.entryID,
newMessageInfos: result.newMessageInfos,
updatesResult: result.updatesResult,
};
}
const deleteEntryActionTypes = Object.freeze({
started: 'DELETE_ENTRY_STARTED',
success: 'DELETE_ENTRY_SUCCESS',
failed: 'DELETE_ENTRY_FAILED',
});
async function deleteEntry(
fetchJSON: FetchJSON,
info: DeleteEntryInfo,
): Promise<DeleteEntryResponse> {
const response = await fetchJSON('delete_entry', {
...info,
timestamp: Date.now(),
});
return {
newMessageInfos: response.newMessageInfos,
threadID: response.threadID,
updatesResult: response.updatesResult,
};
}
const fetchRevisionsForEntryActionTypes = Object.freeze({
started: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
success: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
failed: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
});
async function fetchRevisionsForEntry(
fetchJSON: FetchJSON,
entryID: string,
): Promise<$ReadOnlyArray<HistoryRevisionInfo>> {
const response = await fetchJSON('fetch_entry_revisions', { id: entryID });
return response.result;
}
const restoreEntryActionTypes = Object.freeze({
started: 'RESTORE_ENTRY_STARTED',
success: 'RESTORE_ENTRY_SUCCESS',
failed: 'RESTORE_ENTRY_FAILED',
});
async function restoreEntry(
fetchJSON: FetchJSON,
info: RestoreEntryInfo,
): Promise<RestoreEntryResponse> {
const response = await fetchJSON('restore_entry', {
...info,
timestamp: Date.now(),
});
return {
newMessageInfos: response.newMessageInfos,
updatesResult: response.updatesResult,
};
}
export {
fetchEntriesActionTypes,
fetchEntries,
updateCalendarQueryActionTypes,
updateCalendarQuery,
createLocalEntryActionType,
createLocalEntry,
createEntryActionTypes,
createEntry,
saveEntryActionTypes,
concurrentModificationResetActionType,
saveEntry,
deleteEntryActionTypes,
deleteEntry,
fetchRevisionsForEntryActionTypes,
fetchRevisionsForEntry,
restoreEntryActionTypes,
restoreEntry,
};
diff --git a/lib/actions/message-actions.js b/lib/actions/message-actions.js
index b899e9fd1..d5f57e78e 100644
--- a/lib/actions/message-actions.js
+++ b/lib/actions/message-actions.js
@@ -1,119 +1,115 @@
// @flow
import type { FetchJSON } from '../utils/fetch-json';
import type {
FetchMessageInfosPayload,
SendMessageResult,
} from '../types/message-types';
-import { values } from '../utils/objects';
-
const fetchMessagesBeforeCursorActionTypes = Object.freeze({
started: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
success: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
failed: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
});
async function fetchMessagesBeforeCursor(
fetchJSON: FetchJSON,
threadID: string,
beforeMessageID: string,
): Promise<FetchMessageInfosPayload> {
const response = await fetchJSON('fetch_messages', {
cursors: {
[threadID]: beforeMessageID,
},
});
return {
threadID,
rawMessageInfos: response.rawMessageInfos,
truncationStatus: response.truncationStatuses[threadID],
- userInfos: values(response.userInfos),
};
}
const fetchMostRecentMessagesActionTypes = Object.freeze({
started: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
success: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
failed: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
});
async function fetchMostRecentMessages(
fetchJSON: FetchJSON,
threadID: string,
): Promise<FetchMessageInfosPayload> {
const response = await fetchJSON('fetch_messages', {
cursors: {
[threadID]: null,
},
});
return {
threadID,
rawMessageInfos: response.rawMessageInfos,
truncationStatus: response.truncationStatuses[threadID],
- userInfos: values(response.userInfos),
};
}
const sendTextMessageActionTypes = Object.freeze({
started: 'SEND_TEXT_MESSAGE_STARTED',
success: 'SEND_TEXT_MESSAGE_SUCCESS',
failed: 'SEND_TEXT_MESSAGE_FAILED',
});
async function sendTextMessage(
fetchJSON: FetchJSON,
threadID: string,
localID: string,
text: string,
): Promise<SendMessageResult> {
const response = await fetchJSON('create_text_message', {
threadID,
localID,
text,
});
return {
id: response.newMessageInfo.id,
time: response.newMessageInfo.time,
};
}
const createLocalMessageActionType = 'CREATE_LOCAL_MESSAGE';
const sendMultimediaMessageActionTypes = Object.freeze({
started: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
success: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
failed: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
});
async function sendMultimediaMessage(
fetchJSON: FetchJSON,
threadID: string,
localID: string,
mediaIDs: $ReadOnlyArray<string>,
): Promise<SendMessageResult> {
const response = await fetchJSON('create_multimedia_message', {
threadID,
localID,
mediaIDs,
});
return {
id: response.newMessageInfo.id,
time: response.newMessageInfo.time,
};
}
const saveMessagesActionType = 'SAVE_MESSAGES';
const processMessagesActionType = 'PROCESS_MESSAGES';
const messageStorePruneActionType = 'MESSAGE_STORE_PRUNE';
export {
fetchMessagesBeforeCursorActionTypes,
fetchMessagesBeforeCursor,
fetchMostRecentMessagesActionTypes,
fetchMostRecentMessages,
sendTextMessageActionTypes,
sendTextMessage,
createLocalMessageActionType,
sendMultimediaMessageActionTypes,
sendMultimediaMessage,
saveMessagesActionType,
processMessagesActionType,
messageStorePruneActionType,
};
diff --git a/lib/actions/thread-actions.js b/lib/actions/thread-actions.js
index 76bc4e31e..50c068281 100644
--- a/lib/actions/thread-actions.js
+++ b/lib/actions/thread-actions.js
@@ -1,173 +1,172 @@
// @flow
import type {
ChangeThreadSettingsPayload,
LeaveThreadPayload,
UpdateThreadRequest,
NewThreadRequest,
NewThreadResult,
ClientThreadJoinRequest,
ThreadJoinPayload,
} from '../types/thread-types';
import type { FetchJSON } from '../utils/fetch-json';
import invariant from 'invariant';
import { values } from '../utils/objects';
const deleteThreadActionTypes = Object.freeze({
started: 'DELETE_THREAD_STARTED',
success: 'DELETE_THREAD_SUCCESS',
failed: 'DELETE_THREAD_FAILED',
});
async function deleteThread(
fetchJSON: FetchJSON,
threadID: string,
currentAccountPassword: string,
): Promise<LeaveThreadPayload> {
const response = await fetchJSON('delete_thread', {
threadID,
accountPassword: currentAccountPassword,
});
return {
updatesResult: response.updatesResult,
};
}
const changeThreadSettingsActionTypes = Object.freeze({
started: 'CHANGE_THREAD_SETTINGS_STARTED',
success: 'CHANGE_THREAD_SETTINGS_SUCCESS',
failed: 'CHANGE_THREAD_SETTINGS_FAILED',
});
async function changeThreadSettings(
fetchJSON: FetchJSON,
request: UpdateThreadRequest,
): Promise<ChangeThreadSettingsPayload> {
const response = await fetchJSON('update_thread', request);
invariant(
Object.keys(request.changes).length > 0,
'No changes provided to changeThreadSettings!',
);
return {
threadID: request.threadID,
updatesResult: response.updatesResult,
newMessageInfos: response.newMessageInfos,
};
}
const removeUsersFromThreadActionTypes = Object.freeze({
started: 'REMOVE_USERS_FROM_THREAD_STARTED',
success: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
failed: 'REMOVE_USERS_FROM_THREAD_FAILED',
});
async function removeUsersFromThread(
fetchJSON: FetchJSON,
threadID: string,
memberIDs: string[],
): Promise<ChangeThreadSettingsPayload> {
const response = await fetchJSON('remove_members', {
threadID,
memberIDs,
});
return {
threadID,
updatesResult: response.updatesResult,
newMessageInfos: response.newMessageInfos,
};
}
const changeThreadMemberRolesActionTypes = Object.freeze({
started: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
success: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
failed: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
});
async function changeThreadMemberRoles(
fetchJSON: FetchJSON,
threadID: string,
memberIDs: string[],
newRole: string,
): Promise<ChangeThreadSettingsPayload> {
const response = await fetchJSON('update_role', {
threadID,
memberIDs,
role: newRole,
});
return {
threadID,
updatesResult: response.updatesResult,
newMessageInfos: response.newMessageInfos,
};
}
const newThreadActionTypes = Object.freeze({
started: 'NEW_THREAD_STARTED',
success: 'NEW_THREAD_SUCCESS',
failed: 'NEW_THREAD_FAILED',
});
async function newThread(
fetchJSON: FetchJSON,
request: NewThreadRequest,
): Promise<NewThreadResult> {
const response = await fetchJSON('create_thread', request);
return {
newThreadID: response.newThreadID,
updatesResult: response.updatesResult,
newMessageInfos: response.newMessageInfos,
};
}
const joinThreadActionTypes = Object.freeze({
started: 'JOIN_THREAD_STARTED',
success: 'JOIN_THREAD_SUCCESS',
failed: 'JOIN_THREAD_FAILED',
});
async function joinThread(
fetchJSON: FetchJSON,
request: ClientThreadJoinRequest,
): Promise<ThreadJoinPayload> {
const response = await fetchJSON('join_thread', request);
const userInfos = values(response.userInfos);
return {
updatesResult: response.updatesResult,
rawMessageInfos: response.rawMessageInfos,
truncationStatuses: response.truncationStatuses,
userInfos,
calendarResult: {
calendarQuery: request.calendarQuery,
rawEntryInfos: response.rawEntryInfos,
- userInfos,
},
};
}
const leaveThreadActionTypes = Object.freeze({
started: 'LEAVE_THREAD_STARTED',
success: 'LEAVE_THREAD_SUCCESS',
failed: 'LEAVE_THREAD_FAILED',
});
async function leaveThread(
fetchJSON: FetchJSON,
threadID: string,
): Promise<LeaveThreadPayload> {
const response = await fetchJSON('leave_thread', { threadID });
return {
updatesResult: response.updatesResult,
};
}
export {
deleteThreadActionTypes,
deleteThread,
changeThreadSettingsActionTypes,
changeThreadSettings,
removeUsersFromThreadActionTypes,
removeUsersFromThread,
changeThreadMemberRolesActionTypes,
changeThreadMemberRoles,
newThreadActionTypes,
newThread,
joinThreadActionTypes,
joinThread,
leaveThreadActionTypes,
leaveThread,
};
diff --git a/lib/actions/user-actions.js b/lib/actions/user-actions.js
index bedf6ff43..c43f34881 100644
--- a/lib/actions/user-actions.js
+++ b/lib/actions/user-actions.js
@@ -1,322 +1,320 @@
// @flow
import type { FetchJSON } from '../utils/fetch-json';
import type { HandleVerificationCodeResult } from '../types/verify-types';
import type { UserInfo, AccountUpdate } from '../types/user-types';
import type {
ChangeUserSettingsResult,
LogOutResult,
LogInInfo,
LogInResult,
RegisterResult,
UpdatePasswordInfo,
RegisterInfo,
AccessRequest,
} from '../types/account-types';
import type {
SubscriptionUpdateRequest,
SubscriptionUpdateResult,
} from '../types/subscription-types';
import type { UserSearchResult } from '../types/search-types';
import type { PreRequestUserState } from '../types/session-types';
import threadWatcher from '../shared/thread-watcher';
import { getConfig } from '../utils/config';
import sleep from '../utils/sleep';
const logOutActionTypes = Object.freeze({
started: 'LOG_OUT_STARTED',
success: 'LOG_OUT_SUCCESS',
failed: 'LOG_OUT_FAILED',
});
async function logOut(
fetchJSON: FetchJSON,
preRequestUserState: PreRequestUserState,
): Promise<LogOutResult> {
let response = null;
try {
response = await Promise.race([
fetchJSON('log_out', {}),
(async () => {
await sleep(500);
throw new Error('log_out took more than 500ms');
})(),
]);
} catch {}
const currentUserInfo = response ? response.currentUserInfo : null;
return { currentUserInfo, preRequestUserState };
}
const deleteAccountActionTypes = Object.freeze({
started: 'DELETE_ACCOUNT_STARTED',
success: 'DELETE_ACCOUNT_SUCCESS',
failed: 'DELETE_ACCOUNT_FAILED',
});
async function deleteAccount(
fetchJSON: FetchJSON,
password: string,
preRequestUserState: PreRequestUserState,
): Promise<LogOutResult> {
let response = null;
try {
response = await Promise.race([
fetchJSON('delete_account', { password }),
(async () => {
await sleep(500);
throw new Error('delete_account took more than 500ms');
})(),
]);
} catch {}
const currentUserInfo = response ? response.currentUserInfo : null;
return { currentUserInfo, preRequestUserState };
}
const registerActionTypes = Object.freeze({
started: 'REGISTER_STARTED',
success: 'REGISTER_SUCCESS',
failed: 'REGISTER_FAILED',
});
async function register(
fetchJSON: FetchJSON,
registerInfo: RegisterInfo,
): Promise<RegisterResult> {
const response = await fetchJSON('create_account', {
...registerInfo,
platformDetails: getConfig().platformDetails,
});
return {
currentUserInfo: {
id: response.id,
username: registerInfo.username,
email: registerInfo.email,
emailVerified: false,
},
rawMessageInfos: response.rawMessageInfos,
threadInfos: response.cookieChange.threadInfos,
userInfos: response.cookieChange.userInfos,
calendarQuery: registerInfo.calendarQuery,
};
}
function mergeUserInfos(...userInfoArrays: UserInfo[][]): UserInfo[] {
const merged = {};
for (let userInfoArray of userInfoArrays) {
for (let userInfo of userInfoArray) {
merged[userInfo.id] = userInfo;
}
}
const flattened = [];
for (let id in merged) {
flattened.push(merged[id]);
}
return flattened;
}
const cookieInvalidationResolutionAttempt =
'COOKIE_INVALIDATION_RESOLUTION_ATTEMPT';
const appStartNativeCredentialsAutoLogIn =
'APP_START_NATIVE_CREDENTIALS_AUTO_LOG_IN';
const appStartReduxLoggedInButInvalidCookie =
'APP_START_REDUX_LOGGED_IN_BUT_INVALID_COOKIE';
const socketAuthErrorResolutionAttempt = 'SOCKET_AUTH_ERROR_RESOLUTION_ATTEMPT';
const logInActionTypes = Object.freeze({
started: 'LOG_IN_STARTED',
success: 'LOG_IN_SUCCESS',
failed: 'LOG_IN_FAILED',
});
async function logIn(
fetchJSON: FetchJSON,
logInInfo: LogInInfo,
): Promise<LogInResult> {
const watchedIDs = threadWatcher.getWatchedIDs();
const response = await fetchJSON('log_in', {
...logInInfo,
watchedIDs,
platformDetails: getConfig().platformDetails,
});
const userInfos = mergeUserInfos(
response.userInfos,
response.cookieChange.userInfos,
);
return {
threadInfos: response.cookieChange.threadInfos,
currentUserInfo: response.currentUserInfo,
calendarResult: {
calendarQuery: logInInfo.calendarQuery,
rawEntryInfos: response.rawEntryInfos,
- userInfos,
},
messagesResult: {
messageInfos: response.rawMessageInfos,
truncationStatus: response.truncationStatuses,
watchedIDsAtRequestTime: watchedIDs,
currentAsOf: response.serverTime,
},
userInfos,
updatesCurrentAsOf: response.serverTime,
};
}
const resetPasswordActionTypes = Object.freeze({
started: 'RESET_PASSWORD_STARTED',
success: 'RESET_PASSWORD_SUCCESS',
failed: 'RESET_PASSWORD_FAILED',
});
async function resetPassword(
fetchJSON: FetchJSON,
updatePasswordInfo: UpdatePasswordInfo,
): Promise<LogInResult> {
const watchedIDs = threadWatcher.getWatchedIDs();
const response = await fetchJSON('update_password', {
...updatePasswordInfo,
watchedIDs,
platformDetails: getConfig().platformDetails,
});
const userInfos = mergeUserInfos(
response.userInfos,
response.cookieChange.userInfos,
);
return {
threadInfos: response.cookieChange.threadInfos,
currentUserInfo: response.currentUserInfo,
calendarResult: {
calendarQuery: updatePasswordInfo.calendarQuery,
rawEntryInfos: response.rawEntryInfos,
- userInfos,
},
messagesResult: {
messageInfos: response.rawMessageInfos,
truncationStatus: response.truncationStatuses,
watchedIDsAtRequestTime: watchedIDs,
currentAsOf: response.serverTime,
},
userInfos,
updatesCurrentAsOf: response.serverTime,
};
}
const forgotPasswordActionTypes = Object.freeze({
started: 'FORGOT_PASSWORD_STARTED',
success: 'FORGOT_PASSWORD_SUCCESS',
failed: 'FORGOT_PASSWORD_FAILED',
});
async function forgotPassword(
fetchJSON: FetchJSON,
usernameOrEmail: string,
): Promise<void> {
await fetchJSON('send_password_reset_email', { usernameOrEmail });
}
const changeUserSettingsActionTypes = Object.freeze({
started: 'CHANGE_USER_SETTINGS_STARTED',
success: 'CHANGE_USER_SETTINGS_SUCCESS',
failed: 'CHANGE_USER_SETTINGS_FAILED',
});
async function changeUserSettings(
fetchJSON: FetchJSON,
accountUpdate: AccountUpdate,
): Promise<ChangeUserSettingsResult> {
await fetchJSON('update_account', accountUpdate);
return { email: accountUpdate.updatedFields.email };
}
const resendVerificationEmailActionTypes = Object.freeze({
started: 'RESEND_VERIFICATION_EMAIL_STARTED',
success: 'RESEND_VERIFICATION_EMAIL_SUCCESS',
failed: 'RESEND_VERIFICATION_EMAIL_FAILED',
});
async function resendVerificationEmail(fetchJSON: FetchJSON): Promise<void> {
await fetchJSON('send_verification_email', {});
}
const handleVerificationCodeActionTypes = Object.freeze({
started: 'HANDLE_VERIFICATION_CODE_STARTED',
success: 'HANDLE_VERIFICATION_CODE_SUCCESS',
failed: 'HANDLE_VERIFICATION_CODE_FAILED',
});
async function handleVerificationCode(
fetchJSON: FetchJSON,
code: string,
): Promise<HandleVerificationCodeResult> {
const result = await fetchJSON('verify_code', { code });
const { verifyField, resetPasswordUsername } = result;
return { verifyField, resetPasswordUsername };
}
const searchUsersActionTypes = Object.freeze({
started: 'SEARCH_USERS_STARTED',
success: 'SEARCH_USERS_SUCCESS',
failed: 'SEARCH_USERS_FAILED',
});
async function searchUsers(
fetchJSON: FetchJSON,
usernamePrefix: string,
): Promise<UserSearchResult> {
const response = await fetchJSON('search_users', { prefix: usernamePrefix });
return {
userInfos: response.userInfos,
};
}
const updateSubscriptionActionTypes = Object.freeze({
started: 'UPDATE_SUBSCRIPTION_STARTED',
success: 'UPDATE_SUBSCRIPTION_SUCCESS',
failed: 'UPDATE_SUBSCRIPTION_FAILED',
});
async function updateSubscription(
fetchJSON: FetchJSON,
subscriptionUpdate: SubscriptionUpdateRequest,
): Promise<SubscriptionUpdateResult> {
const response = await fetchJSON(
'update_user_subscription',
subscriptionUpdate,
);
return {
threadID: subscriptionUpdate.threadID,
subscription: response.threadSubscription,
};
}
const requestAccessActionTypes = Object.freeze({
started: 'REQUEST_ACCESS_STARTED',
success: 'REQUEST_ACCESS_SUCCESS',
failed: 'REQUEST_ACCESS_FAILED',
});
async function requestAccess(
fetchJSON: FetchJSON,
accessRequest: AccessRequest,
): Promise<void> {
await fetchJSON('request_access', accessRequest);
}
export {
logOutActionTypes,
logOut,
deleteAccountActionTypes,
deleteAccount,
registerActionTypes,
register,
cookieInvalidationResolutionAttempt,
appStartNativeCredentialsAutoLogIn,
appStartReduxLoggedInButInvalidCookie,
socketAuthErrorResolutionAttempt,
logInActionTypes,
logIn,
resetPasswordActionTypes,
resetPassword,
forgotPasswordActionTypes,
forgotPassword,
changeUserSettingsActionTypes,
changeUserSettings,
resendVerificationEmailActionTypes,
resendVerificationEmail,
handleVerificationCodeActionTypes,
handleVerificationCode,
searchUsersActionTypes,
searchUsers,
updateSubscriptionActionTypes,
updateSubscription,
requestAccessActionTypes,
requestAccess,
};
diff --git a/lib/reducers/user-reducer.js b/lib/reducers/user-reducer.js
index 9b396ad9f..7b7565cd4 100644
--- a/lib/reducers/user-reducer.js
+++ b/lib/reducers/user-reducer.js
@@ -1,278 +1,264 @@
// @flow
import type { BaseAction } from '../types/redux-types';
import type { CurrentUserInfo, UserStore, UserInfo } from '../types/user-types';
import { updateTypes, processUpdatesActionType } from '../types/update-types';
import {
serverRequestTypes,
processServerRequestsActionType,
} from '../types/request-types';
import {
fullStateSyncActionType,
incrementalStateSyncActionType,
} from '../types/socket-types';
import {
type UserInconsistencyReportCreationRequest,
reportTypes,
} from '../types/report-types';
import invariant from 'invariant';
import _keyBy from 'lodash/fp/keyBy';
import _isEqual from 'lodash/fp/isEqual';
import { setNewSessionActionType } from '../utils/action-utils';
import {
- fetchEntriesActionTypes,
- updateCalendarQueryActionTypes,
createEntryActionTypes,
saveEntryActionTypes,
deleteEntryActionTypes,
restoreEntryActionTypes,
} from '../actions/entry-actions';
import {
logOutActionTypes,
deleteAccountActionTypes,
logInActionTypes,
registerActionTypes,
resetPasswordActionTypes,
changeUserSettingsActionTypes,
- searchUsersActionTypes,
} from '../actions/user-actions';
import { joinThreadActionTypes } from '../actions/thread-actions';
-import {
- fetchMessagesBeforeCursorActionTypes,
- fetchMostRecentMessagesActionTypes,
-} from '../actions/message-actions';
import { getConfig } from '../utils/config';
import { actionLogger } from '../utils/action-logger';
import { sanitizeAction } from '../utils/sanitization';
function reduceCurrentUserInfo(
state: ?CurrentUserInfo,
action: BaseAction,
): ?CurrentUserInfo {
if (
action.type === logInActionTypes.success ||
action.type === resetPasswordActionTypes.success ||
action.type === registerActionTypes.success ||
action.type === logOutActionTypes.success ||
action.type === deleteAccountActionTypes.success
) {
if (!_isEqual(action.payload.currentUserInfo)(state)) {
return action.payload.currentUserInfo;
}
} else if (
action.type === setNewSessionActionType &&
action.payload.sessionChange.currentUserInfo
) {
const { sessionChange } = action.payload;
if (!_isEqual(sessionChange.currentUserInfo)(state)) {
return sessionChange.currentUserInfo;
}
} else if (action.type === fullStateSyncActionType) {
const { currentUserInfo } = action.payload;
if (!_isEqual(currentUserInfo)(state)) {
return currentUserInfo;
}
} else if (
action.type === incrementalStateSyncActionType ||
action.type === processUpdatesActionType
) {
for (let update of action.payload.updatesResult.newUpdates) {
if (
update.type === updateTypes.UPDATE_CURRENT_USER &&
!_isEqual(update.currentUserInfo)(state)
) {
return update.currentUserInfo;
}
}
} else if (action.type === changeUserSettingsActionTypes.success) {
invariant(
state && !state.anonymous,
"can't change settings if not logged in",
);
const email = action.payload.email;
if (!email) {
return state;
}
return {
id: state.id,
username: state.username,
email: email,
emailVerified: false,
};
} else if (action.type === processServerRequestsActionType) {
const checkStateRequest = action.payload.serverRequests.find(
candidate => candidate.type === serverRequestTypes.CHECK_STATE,
);
if (
checkStateRequest &&
checkStateRequest.stateChanges &&
checkStateRequest.stateChanges.currentUserInfo &&
!_isEqual(checkStateRequest.stateChanges.currentUserInfo)(state)
) {
return checkStateRequest.stateChanges.currentUserInfo;
}
}
return state;
}
function findInconsistencies(
action: BaseAction,
beforeStateCheck: { [id: string]: UserInfo },
afterStateCheck: { [id: string]: UserInfo },
): UserInconsistencyReportCreationRequest[] {
if (_isEqual(beforeStateCheck)(afterStateCheck)) {
return [];
}
return [
{
type: reportTypes.USER_INCONSISTENCY,
platformDetails: getConfig().platformDetails,
action: sanitizeAction(action),
beforeStateCheck,
afterStateCheck,
lastActions: actionLogger.interestingActionSummaries,
time: Date.now(),
},
];
}
function reduceUserInfos(state: UserStore, action: BaseAction): UserStore {
- if (
- action.type === joinThreadActionTypes.success ||
- action.type === fetchMessagesBeforeCursorActionTypes.success ||
- action.type === fetchMostRecentMessagesActionTypes.success ||
- action.type === fetchEntriesActionTypes.success ||
- action.type === updateCalendarQueryActionTypes.success ||
- action.type === searchUsersActionTypes.success
- ) {
+ if (action.type === joinThreadActionTypes.success) {
const newUserInfos = _keyBy(userInfo => userInfo.id)(
action.payload.userInfos,
);
// $FlowFixMe should be fixed in flow-bin@0.115 / react-native@0.63
const updated = { ...state.userInfos, ...newUserInfos };
if (!_isEqual(state.userInfos)(updated)) {
return {
userInfos: updated,
inconsistencyReports: state.inconsistencyReports,
};
}
} else if (
action.type === logOutActionTypes.success ||
action.type === deleteAccountActionTypes.success ||
(action.type === setNewSessionActionType &&
action.payload.sessionChange.cookieInvalidated)
) {
if (Object.keys(state.userInfos).length === 0) {
return state;
}
return {
userInfos: {},
inconsistencyReports: state.inconsistencyReports,
};
} else if (
action.type === logInActionTypes.success ||
action.type === registerActionTypes.success ||
action.type === resetPasswordActionTypes.success ||
action.type === fullStateSyncActionType
) {
const newUserInfos = _keyBy(userInfo => userInfo.id)(
action.payload.userInfos,
);
if (!_isEqual(state.userInfos)(newUserInfos)) {
return {
userInfos: newUserInfos,
inconsistencyReports: state.inconsistencyReports,
};
}
} else if (
action.type === incrementalStateSyncActionType ||
action.type === processUpdatesActionType
) {
const newUserInfos = _keyBy(userInfo => userInfo.id)(
action.payload.userInfos,
);
// $FlowFixMe should be fixed in flow-bin@0.115 / react-native@0.63
const updated = { ...state.userInfos, ...newUserInfos };
for (let update of action.payload.updatesResult.newUpdates) {
if (update.type === updateTypes.DELETE_ACCOUNT) {
delete updated[update.deletedUserID];
}
}
if (!_isEqual(state.userInfos)(updated)) {
return {
userInfos: updated,
inconsistencyReports: state.inconsistencyReports,
};
}
} else if (
action.type === createEntryActionTypes.success ||
action.type === saveEntryActionTypes.success ||
action.type === restoreEntryActionTypes.success
) {
const newUserInfos = _keyBy(userInfo => userInfo.id)(
action.payload.updatesResult.userInfos,
);
// $FlowFixMe should be fixed in flow-bin@0.115 / react-native@0.63
const updated = { ...state.userInfos, ...newUserInfos };
if (!_isEqual(state.userInfos)(updated)) {
return {
userInfos: updated,
inconsistencyReports: state.inconsistencyReports,
};
}
} else if (action.type === deleteEntryActionTypes.success && action.payload) {
const { updatesResult } = action.payload;
const newUserInfos = _keyBy(userInfo => userInfo.id)(
updatesResult.userInfos,
);
// $FlowFixMe should be fixed in flow-bin@0.115 / react-native@0.63
const updated = { ...state.userInfos, ...newUserInfos };
if (!_isEqual(state.userInfos)(updated)) {
return {
userInfos: updated,
inconsistencyReports: state.inconsistencyReports,
};
}
} else if (action.type === processServerRequestsActionType) {
const checkStateRequest = action.payload.serverRequests.find(
candidate => candidate.type === serverRequestTypes.CHECK_STATE,
);
if (!checkStateRequest || !checkStateRequest.stateChanges) {
return state;
}
const { userInfos, deleteUserInfoIDs } = checkStateRequest.stateChanges;
if (!userInfos && !deleteUserInfoIDs) {
return state;
}
const newUserInfos = { ...state.userInfos };
if (userInfos) {
for (const userInfo of userInfos) {
newUserInfos[userInfo.id] = userInfo;
}
}
if (deleteUserInfoIDs) {
for (const deleteUserInfoID of deleteUserInfoIDs) {
delete newUserInfos[deleteUserInfoID];
}
}
const newInconsistencies = findInconsistencies(
action,
state.userInfos,
newUserInfos,
);
return {
userInfos: newUserInfos,
inconsistencyReports: [
...state.inconsistencyReports,
...newInconsistencies,
],
};
}
return state;
}
export { reduceCurrentUserInfo, reduceUserInfos };
diff --git a/lib/selectors/user-selectors.js b/lib/selectors/user-selectors.js
index 92072cdb8..e5f79beb0 100644
--- a/lib/selectors/user-selectors.js
+++ b/lib/selectors/user-selectors.js
@@ -1,178 +1,179 @@
// @flow
import type { BaseAppState } from '../types/redux-types';
import type {
UserInfo,
RelativeUserInfo,
AccountUserInfo,
} from '../types/user-types';
import {
type RawThreadInfo,
type MemberInfo,
type RelativeMemberInfo,
threadPermissions,
} from '../types/thread-types';
import { createSelector } from 'reselect';
import _memoize from 'lodash/memoize';
import _keys from 'lodash/keys';
import SearchIndex from '../shared/search-index';
import { threadActualMembers } from '../shared/thread-utils';
// Used for specific message payloads that include an array of user IDs, ie.
// array of initial users, array of added users
function userIDsToRelativeUserInfos(
userIDs: string[],
viewerID: ?string,
userInfos: { [id: string]: UserInfo },
): RelativeUserInfo[] {
const relativeUserInfos = [];
for (let userID of userIDs) {
const username = userInfos[userID] ? userInfos[userID].username : null;
if (userID === viewerID) {
relativeUserInfos.unshift({
id: userID,
username,
isViewer: true,
});
} else {
relativeUserInfos.push({
id: userID,
username,
isViewer: false,
});
}
}
return relativeUserInfos;
}
// Includes current user at the start
const baseRelativeMemberInfoSelectorForMembersOfThread = (threadID: string) =>
createSelector(
(state: BaseAppState<*>) => state.threadStore.threadInfos[threadID],
(state: BaseAppState<*>) =>
state.currentUserInfo && state.currentUserInfo.id,
(state: BaseAppState<*>) => state.userStore.userInfos,
(
threadInfo: ?RawThreadInfo,
currentUserID: ?string,
userInfos: { [id: string]: UserInfo },
): RelativeMemberInfo[] => {
const relativeMemberInfos = [];
if (!threadInfo) {
return relativeMemberInfos;
}
const memberInfos = threadInfo.members;
for (let memberInfo of memberInfos) {
const username = userInfos[memberInfo.id]
? userInfos[memberInfo.id].username
: null;
const canChangeRoles =
memberInfo.permissions[threadPermissions.CHANGE_ROLE] &&
memberInfo.permissions[threadPermissions.CHANGE_ROLE].value;
if (
memberInfo.id === currentUserID &&
(memberInfo.role || canChangeRoles)
) {
relativeMemberInfos.unshift({
id: memberInfo.id,
role: memberInfo.role,
permissions: memberInfo.permissions,
username,
isViewer: true,
});
} else if (memberInfo.id !== currentUserID) {
relativeMemberInfos.push({
id: memberInfo.id,
role: memberInfo.role,
permissions: memberInfo.permissions,
username,
isViewer: false,
});
}
}
return relativeMemberInfos;
},
);
const relativeMemberInfoSelectorForMembersOfThread: (
threadID: string,
) => (state: BaseAppState<*>) => RelativeMemberInfo[] = _memoize(
baseRelativeMemberInfoSelectorForMembersOfThread,
);
// If threadID is null, then all users except the logged-in user are returned
const baseUserInfoSelectorForOtherMembersOfThread = (threadID: ?string) =>
createSelector(
(state: BaseAppState<*>) => state.userStore.userInfos,
(state: BaseAppState<*>) =>
state.currentUserInfo && state.currentUserInfo.id,
(state: BaseAppState<*>) =>
threadID && state.threadStore.threadInfos[threadID]
? state.threadStore.threadInfos[threadID].members
: null,
(
userInfos: { [id: string]: UserInfo },
currentUserID: ?string,
members: ?$ReadOnlyArray<MemberInfo>,
): { [id: string]: AccountUserInfo } => {
const others = {};
const memberUserIDs = members
? threadActualMembers(members)
: _keys(userInfos);
for (let memberID of memberUserIDs) {
if (
memberID !== currentUserID &&
userInfos[memberID] &&
userInfos[memberID].username
) {
others[memberID] = userInfos[memberID];
}
}
return others;
},
);
const userInfoSelectorForOtherMembersOfThread: (
threadID: ?string,
) => (state: BaseAppState<*>) => { [id: string]: AccountUserInfo } = _memoize(
baseUserInfoSelectorForOtherMembersOfThread,
);
function searchIndexFromUserInfos(userInfos: {
[id: string]: AccountUserInfo,
}) {
const searchIndex = new SearchIndex();
for (const id in userInfos) {
searchIndex.addEntry(id, userInfos[id].username);
}
return searchIndex;
}
const baseUserSearchIndexForOtherMembersOfThread = (threadID: ?string) =>
createSelector(
userInfoSelectorForOtherMembersOfThread(threadID),
searchIndexFromUserInfos,
);
const userSearchIndexForOtherMembersOfThread: (
threadID: ?string,
) => (state: BaseAppState<*>) => SearchIndex = _memoize(
baseUserSearchIndexForOtherMembersOfThread,
);
const isLoggedIn = (state: BaseAppState<*>) =>
!!(
state.currentUserInfo &&
!state.currentUserInfo.anonymous &&
state.dataLoaded
);
export {
userIDsToRelativeUserInfos,
relativeMemberInfoSelectorForMembersOfThread,
userInfoSelectorForOtherMembersOfThread,
+ searchIndexFromUserInfos,
userSearchIndexForOtherMembersOfThread,
isLoggedIn,
};
diff --git a/lib/types/entry-types.js b/lib/types/entry-types.js
index 5986aa1ec..c826a1b80 100644
--- a/lib/types/entry-types.js
+++ b/lib/types/entry-types.js
@@ -1,235 +1,231 @@
// @flow
import type { RawMessageInfo } from './message-types';
-import type { UserInfo, AccountUserInfo } from './user-types';
+import type { AccountUserInfo } from './user-types';
import {
type CalendarFilter,
calendarFilterPropType,
defaultCalendarFilters,
} from './filter-types';
import type { CreateUpdatesResponse } from './update-types';
import type { Platform } from './device-types';
import type { ClientEntryInconsistencyReportCreationRequest } from './report-types';
import PropTypes from 'prop-types';
import {
fifteenDaysEarlier,
fifteenDaysLater,
thisMonthDates,
} from '../utils/date-utils';
export type RawEntryInfo = {|
id?: string, // null if local copy without ID yet
localID?: string, // for optimistic creations
threadID: string,
text: string,
year: number,
month: number, // 1-indexed
day: number, // 1-indexed
creationTime: number, // millisecond timestamp
creatorID: string,
deleted: boolean,
|};
export const rawEntryInfoPropType = PropTypes.shape({
id: PropTypes.string,
localID: PropTypes.string,
threadID: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
year: PropTypes.number.isRequired,
month: PropTypes.number.isRequired,
day: PropTypes.number.isRequired,
creationTime: PropTypes.number.isRequired,
creatorID: PropTypes.string.isRequired,
deleted: PropTypes.bool.isRequired,
});
export type EntryInfo = {|
id?: string, // null if local copy without ID yet
localID?: string, // for optimistic creations
threadID: string,
text: string,
year: number,
month: number, // 1-indexed
day: number, // 1-indexed
creationTime: number, // millisecond timestamp
creator: ?string,
deleted: boolean,
|};
export const entryInfoPropType = PropTypes.shape({
id: PropTypes.string,
localID: PropTypes.string,
threadID: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
year: PropTypes.number.isRequired,
month: PropTypes.number.isRequired,
day: PropTypes.number.isRequired,
creationTime: PropTypes.number.isRequired,
creator: PropTypes.string,
deleted: PropTypes.bool.isRequired,
});
export type EntryStore = {|
entryInfos: { [id: string]: RawEntryInfo },
daysToEntries: { [day: string]: string[] },
lastUserInteractionCalendar: number,
inconsistencyReports: $ReadOnlyArray<ClientEntryInconsistencyReportCreationRequest>,
|};
export type CalendarQuery = {|
startDate: string,
endDate: string,
filters: $ReadOnlyArray<CalendarFilter>,
|};
export const defaultCalendarQuery = (
platform: ?Platform,
timeZone?: ?string,
) => {
if (platform === 'web') {
return {
...thisMonthDates(timeZone),
filters: defaultCalendarFilters,
};
} else {
return {
startDate: fifteenDaysEarlier(timeZone).valueOf(),
endDate: fifteenDaysLater(timeZone).valueOf(),
filters: defaultCalendarFilters,
};
}
};
export const calendarQueryPropType = PropTypes.shape({
startDate: PropTypes.string.isRequired,
endDate: PropTypes.string.isRequired,
filters: PropTypes.arrayOf(calendarFilterPropType).isRequired,
});
export type SaveEntryInfo = {|
entryID: string,
text: string,
prevText: string,
timestamp: number,
calendarQuery: CalendarQuery,
|};
export type SaveEntryRequest = {|
entryID: string,
text: string,
prevText: string,
timestamp: number,
calendarQuery?: CalendarQuery,
|};
export type SaveEntryResponse = {|
entryID: string,
newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
updatesResult: CreateUpdatesResponse,
|};
export type SaveEntryPayload = {|
...SaveEntryResponse,
threadID: string,
|};
export type CreateEntryInfo = {|
text: string,
timestamp: number,
date: string,
threadID: string,
localID: string,
calendarQuery: CalendarQuery,
|};
export type CreateEntryRequest = {|
text: string,
timestamp: number,
date: string,
threadID: string,
localID?: string,
calendarQuery?: CalendarQuery,
|};
export type CreateEntryPayload = {|
...SaveEntryPayload,
localID: string,
|};
export type DeleteEntryInfo = {|
entryID: string,
prevText: string,
calendarQuery: CalendarQuery,
|};
export type DeleteEntryRequest = {|
entryID: string,
prevText: string,
timestamp: number,
calendarQuery?: CalendarQuery,
|};
export type RestoreEntryInfo = {|
entryID: string,
calendarQuery: CalendarQuery,
|};
export type RestoreEntryRequest = {|
entryID: string,
timestamp: number,
calendarQuery?: CalendarQuery,
|};
export type DeleteEntryResponse = {|
newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
threadID: string,
updatesResult: CreateUpdatesResponse,
|};
export type RestoreEntryResponse = {|
newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
updatesResult: CreateUpdatesResponse,
|};
export type RestoreEntryPayload = {|
...RestoreEntryResponse,
threadID: string,
|};
export type FetchEntryInfosResponse = {|
rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
userInfos: { [id: string]: AccountUserInfo },
|};
export type FetchEntryInfosResult = {|
rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
- userInfos: $ReadOnlyArray<AccountUserInfo>,
|};
export type DeltaEntryInfosResponse = {|
rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
deletedEntryIDs: $ReadOnlyArray<string>,
- userInfos: { [id: string]: AccountUserInfo },
|};
export type DeltaEntryInfosResult = {|
rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
deletedEntryIDs: $ReadOnlyArray<string>,
userInfos: $ReadOnlyArray<AccountUserInfo>,
|};
export type CalendarResult = {|
rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
calendarQuery: CalendarQuery,
- userInfos: $ReadOnlyArray<UserInfo>,
|};
export type CalendarQueryUpdateStartingPayload = {|
calendarQuery?: CalendarQuery,
|};
export type CalendarQueryUpdateResult = {|
rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
deletedEntryIDs: $ReadOnlyArray<string>,
- userInfos: $ReadOnlyArray<AccountUserInfo>,
calendarQuery: CalendarQuery,
calendarQueryAlreadyUpdated: boolean,
|};
diff --git a/lib/types/message-types.js b/lib/types/message-types.js
index 7e46bc65d..a1d812558 100644
--- a/lib/types/message-types.js
+++ b/lib/types/message-types.js
@@ -1,786 +1,784 @@
// @flow
import {
type ThreadInfo,
threadInfoPropType,
type ThreadType,
threadTypePropType,
} from './thread-types';
import {
type RelativeUserInfo,
relativeUserInfoPropType,
- type UserInfo,
type UserInfos,
} from './user-types';
import { type Media, type Image, mediaPropType } from './media-types';
import invariant from 'invariant';
import PropTypes from 'prop-types';
export const messageTypes = Object.freeze({
TEXT: 0,
CREATE_THREAD: 1,
ADD_MEMBERS: 2,
CREATE_SUB_THREAD: 3,
CHANGE_SETTINGS: 4,
REMOVE_MEMBERS: 5,
CHANGE_ROLE: 6,
LEAVE_THREAD: 7,
JOIN_THREAD: 8,
CREATE_ENTRY: 9,
EDIT_ENTRY: 10,
DELETE_ENTRY: 11,
RESTORE_ENTRY: 12,
// When the server has a message to deliver that the client can't properly
// render because the client is too old, the server will send this message
// type instead. Consequently, there is no MessageData for UNSUPPORTED - just
// a RawMessageInfo and a MessageInfo. Note that native/persist.js handles
// converting these MessageInfos when the client is upgraded.
UNSUPPORTED: 13,
IMAGES: 14,
MULTIMEDIA: 15,
});
export type MessageType = $Values<typeof messageTypes>;
export function assertMessageType(ourMessageType: number): MessageType {
invariant(
ourMessageType === 0 ||
ourMessageType === 1 ||
ourMessageType === 2 ||
ourMessageType === 3 ||
ourMessageType === 4 ||
ourMessageType === 5 ||
ourMessageType === 6 ||
ourMessageType === 7 ||
ourMessageType === 8 ||
ourMessageType === 9 ||
ourMessageType === 10 ||
ourMessageType === 11 ||
ourMessageType === 12 ||
ourMessageType === 13 ||
ourMessageType === 14 ||
ourMessageType === 15,
'number is not MessageType enum',
);
return ourMessageType;
}
const composableMessageTypes = new Set([
messageTypes.TEXT,
messageTypes.IMAGES,
messageTypes.MULTIMEDIA,
]);
export function isComposableMessageType(ourMessageType: MessageType): boolean {
return composableMessageTypes.has(ourMessageType);
}
export function assertComposableMessageType(
ourMessageType: MessageType,
): MessageType {
invariant(
isComposableMessageType(ourMessageType),
'MessageType is not composed',
);
return ourMessageType;
}
export function messageDataLocalID(messageData: MessageData) {
if (
messageData.type !== messageTypes.TEXT &&
messageData.type !== messageTypes.IMAGES &&
messageData.type !== messageTypes.MULTIMEDIA
) {
return null;
}
return messageData.localID;
}
const mediaMessageTypes = new Set([
messageTypes.IMAGES,
messageTypes.MULTIMEDIA,
]);
export function isMediaMessageType(ourMessageType: MessageType): boolean {
return mediaMessageTypes.has(ourMessageType);
}
export function assetMediaMessageType(
ourMessageType: MessageType,
): MessageType {
invariant(isMediaMessageType(ourMessageType), 'MessageType is not media');
return ourMessageType;
}
// *MessageData = passed to createMessages function to insert into database
// Raw*MessageInfo = used by server, and contained in client's local store
// *MessageInfo = used by client in UI code
export type TextMessageData = {|
type: 0,
localID?: string, // for optimistic creations. included by new clients
threadID: string,
creatorID: string,
time: number,
text: string,
|};
type CreateThreadMessageData = {|
type: 1,
threadID: string,
creatorID: string,
time: number,
initialThreadState: {|
type: ThreadType,
name: ?string,
parentThreadID: ?string,
color: string,
memberIDs: string[],
|},
|};
type AddMembersMessageData = {|
type: 2,
threadID: string,
creatorID: string,
time: number,
addedUserIDs: string[],
|};
type CreateSubthreadMessageData = {|
type: 3,
threadID: string,
creatorID: string,
time: number,
childThreadID: string,
|};
type ChangeSettingsMessageData = {|
type: 4,
threadID: string,
creatorID: string,
time: number,
field: string,
value: string | number,
|};
type RemoveMembersMessageData = {|
type: 5,
threadID: string,
creatorID: string,
time: number,
removedUserIDs: string[],
|};
type ChangeRoleMessageData = {|
type: 6,
threadID: string,
creatorID: string,
time: number,
userIDs: string[],
newRole: string,
|};
type LeaveThreadMessageData = {|
type: 7,
threadID: string,
creatorID: string,
time: number,
|};
type JoinThreadMessageData = {|
type: 8,
threadID: string,
creatorID: string,
time: number,
|};
type CreateEntryMessageData = {|
type: 9,
threadID: string,
creatorID: string,
time: number,
entryID: string,
date: string,
text: string,
|};
type EditEntryMessageData = {|
type: 10,
threadID: string,
creatorID: string,
time: number,
entryID: string,
date: string,
text: string,
|};
type DeleteEntryMessageData = {|
type: 11,
threadID: string,
creatorID: string,
time: number,
entryID: string,
date: string,
text: string,
|};
type RestoreEntryMessageData = {|
type: 12,
threadID: string,
creatorID: string,
time: number,
entryID: string,
date: string,
text: string,
|};
export type ImagesMessageData = {|
type: 14,
localID?: string, // for optimistic creations. included by new clients
threadID: string,
creatorID: string,
time: number,
media: $ReadOnlyArray<Image>,
|};
export type MediaMessageData = {|
type: 15,
localID?: string, // for optimistic creations. included by new clients
threadID: string,
creatorID: string,
time: number,
media: $ReadOnlyArray<Media>,
|};
export type MessageData =
| TextMessageData
| CreateThreadMessageData
| AddMembersMessageData
| CreateSubthreadMessageData
| ChangeSettingsMessageData
| RemoveMembersMessageData
| ChangeRoleMessageData
| LeaveThreadMessageData
| JoinThreadMessageData
| CreateEntryMessageData
| EditEntryMessageData
| DeleteEntryMessageData
| RestoreEntryMessageData
| ImagesMessageData
| MediaMessageData;
export type MultimediaMessageData = ImagesMessageData | MediaMessageData;
export type RawTextMessageInfo = {|
...TextMessageData,
id?: string, // null if local copy without ID yet
|};
export type RawImagesMessageInfo = {|
...ImagesMessageData,
id?: string, // null if local copy without ID yet
|};
export type RawMediaMessageInfo = {|
...MediaMessageData,
id?: string, // null if local copy without ID yet
|};
export type RawMultimediaMessageInfo =
| RawImagesMessageInfo
| RawMediaMessageInfo;
export type RawComposableMessageInfo =
| RawTextMessageInfo
| RawMultimediaMessageInfo;
type RawRobotextMessageInfo =
| {|
...CreateThreadMessageData,
id: string,
|}
| {|
...AddMembersMessageData,
id: string,
|}
| {|
...CreateSubthreadMessageData,
id: string,
|}
| {|
...ChangeSettingsMessageData,
id: string,
|}
| {|
...RemoveMembersMessageData,
id: string,
|}
| {|
...ChangeRoleMessageData,
id: string,
|}
| {|
...LeaveThreadMessageData,
id: string,
|}
| {|
...JoinThreadMessageData,
id: string,
|}
| {|
...CreateEntryMessageData,
id: string,
|}
| {|
...EditEntryMessageData,
id: string,
|}
| {|
...DeleteEntryMessageData,
id: string,
|}
| {|
...RestoreEntryMessageData,
id: string,
|}
| {|
type: 13,
id: string,
threadID: string,
creatorID: string,
time: number,
robotext: string,
unsupportedMessageInfo: Object,
|};
export type RawMessageInfo = RawComposableMessageInfo | RawRobotextMessageInfo;
export type LocallyComposedMessageInfo = {
localID: string,
threadID: string,
...
};
export type TextMessageInfo = {|
type: 0,
id?: string, // null if local copy without ID yet
localID?: string, // for optimistic creations
threadID: string,
creator: RelativeUserInfo,
time: number, // millisecond timestamp
text: string,
|};
export type ImagesMessageInfo = {|
type: 14,
id?: string, // null if local copy without ID yet
localID?: string, // for optimistic creations
threadID: string,
creator: RelativeUserInfo,
time: number, // millisecond timestamp
media: $ReadOnlyArray<Image>,
|};
export type MediaMessageInfo = {|
type: 15,
id?: string, // null if local copy without ID yet
localID?: string, // for optimistic creations
threadID: string,
creator: RelativeUserInfo,
time: number, // millisecond timestamp
media: $ReadOnlyArray<Media>,
|};
export type MultimediaMessageInfo = ImagesMessageInfo | MediaMessageInfo;
export type ComposableMessageInfo = TextMessageInfo | MultimediaMessageInfo;
export type RobotextMessageInfo =
| {|
type: 1,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
initialThreadState: {|
type: ThreadType,
name: ?string,
parentThreadInfo: ?ThreadInfo,
color: string,
otherMembers: RelativeUserInfo[],
|},
|}
| {|
type: 2,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
addedMembers: RelativeUserInfo[],
|}
| {|
type: 3,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
childThreadInfo: ThreadInfo,
|}
| {|
type: 4,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
field: string,
value: string | number,
|}
| {|
type: 5,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
removedMembers: RelativeUserInfo[],
|}
| {|
type: 6,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
members: RelativeUserInfo[],
newRole: string,
|}
| {|
type: 7,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
|}
| {|
type: 8,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
|}
| {|
type: 9,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
entryID: string,
date: string,
text: string,
|}
| {|
type: 10,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
entryID: string,
date: string,
text: string,
|}
| {|
type: 11,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
entryID: string,
date: string,
text: string,
|}
| {|
type: 12,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
entryID: string,
date: string,
text: string,
|}
| {|
type: 13,
id: string,
threadID: string,
creator: RelativeUserInfo,
time: number,
robotext: string,
unsupportedMessageInfo: Object,
|};
export type PreviewableMessageInfo =
| RobotextMessageInfo
| MultimediaMessageInfo;
export type MessageInfo = ComposableMessageInfo | RobotextMessageInfo;
export const messageInfoPropType = PropTypes.oneOfType([
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.TEXT]).isRequired,
id: PropTypes.string,
localID: PropTypes.string,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
text: PropTypes.string.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.CREATE_THREAD]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
initialThreadState: PropTypes.shape({
type: threadTypePropType.isRequired,
name: PropTypes.string,
parentThreadInfo: threadInfoPropType,
color: PropTypes.string.isRequired,
otherMembers: PropTypes.arrayOf(relativeUserInfoPropType).isRequired,
}).isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.ADD_MEMBERS]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
addedMembers: PropTypes.arrayOf(relativeUserInfoPropType).isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.CREATE_SUB_THREAD]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
childThreadInfo: threadInfoPropType.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.CHANGE_SETTINGS]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
field: PropTypes.string.isRequired,
value: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.REMOVE_MEMBERS]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
removedMembers: PropTypes.arrayOf(relativeUserInfoPropType).isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.CHANGE_ROLE]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
members: PropTypes.arrayOf(relativeUserInfoPropType).isRequired,
newRole: PropTypes.string.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.LEAVE_THREAD]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.JOIN_THREAD]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.CREATE_ENTRY]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
entryID: PropTypes.string.isRequired,
date: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.EDIT_ENTRY]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
entryID: PropTypes.string.isRequired,
date: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.DELETE_ENTRY]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
entryID: PropTypes.string.isRequired,
date: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.RESTORE_ENTRY]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
entryID: PropTypes.string.isRequired,
date: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.UNSUPPORTED]).isRequired,
id: PropTypes.string.isRequired,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
robotext: PropTypes.string.isRequired,
unsupportedMessageInfo: PropTypes.object.isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.IMAGES]).isRequired,
id: PropTypes.string,
localID: PropTypes.string,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
media: PropTypes.arrayOf(mediaPropType).isRequired,
}),
PropTypes.shape({
type: PropTypes.oneOf([messageTypes.MULTIMEDIA]).isRequired,
id: PropTypes.string,
localID: PropTypes.string,
threadID: PropTypes.string.isRequired,
creator: relativeUserInfoPropType.isRequired,
time: PropTypes.number.isRequired,
media: PropTypes.arrayOf(mediaPropType).isRequired,
}),
]);
export type ThreadMessageInfo = {|
messageIDs: string[],
startReached: boolean,
lastNavigatedTo: number, // millisecond timestamp
lastPruned: number, // millisecond timestamp
|};
// Tracks client-local information about a message that hasn't been assigned an
// ID by the server yet. As soon as the client gets an ack from the server for
// this message, it will clear the LocalMessageInfo.
export type LocalMessageInfo = {|
sendFailed?: boolean,
|};
export const localMessageInfoPropType = PropTypes.shape({
sendFailed: PropTypes.bool,
});
export type MessageStore = {|
messages: { [id: string]: RawMessageInfo },
threads: { [threadID: string]: ThreadMessageInfo },
local: { [id: string]: LocalMessageInfo },
currentAsOf: number,
|};
export const messageTruncationStatus = Object.freeze({
// EXHAUSTIVE means we've reached the start of the thread. Either the result
// set includes the very first message for that thread, or there is nothing
// behind the cursor you queried for. Given that the client only ever issues
// ranged queries whose range, when unioned with what is in state, represent
// the set of all messages for a given thread, we can guarantee that getting
// EXHAUSTIVE means the start has been reached.
EXHAUSTIVE: 'exhaustive',
// TRUNCATED is rare, and means that the server can't guarantee that the
// result set for a given thread is contiguous with what the client has in its
// state. If the client can't verify the contiguousness itself, it needs to
// replace its Redux store's contents with what it is in this payload.
// 1) getMessageInfosSince: Result set for thread is equal to max, and the
// truncation status isn't EXHAUSTIVE (ie. doesn't include the very first
// message).
// 2) getMessageInfos: ThreadSelectionCriteria does not specify cursors, the
// result set for thread is equal to max, and the truncation status isn't
// EXHAUSTIVE. If cursors are specified, we never return truncated, since
// the cursor given us guarantees the contiguousness of the result set.
// Note that in the reducer, we can guarantee contiguousness if there is any
// intersection between messageIDs in the result set and the set currently in
// the Redux store.
TRUNCATED: 'truncated',
// UNCHANGED means the result set is guaranteed to be contiguous with what the
// client has in its state, but is not EXHAUSTIVE. Basically, it's anything
// that isn't either EXHAUSTIVE or TRUNCATED.
UNCHANGED: 'unchanged',
});
export type MessageTruncationStatus = $Values<typeof messageTruncationStatus>;
export function assertMessageTruncationStatus(
ourMessageTruncationStatus: string,
): MessageTruncationStatus {
invariant(
ourMessageTruncationStatus === 'truncated' ||
ourMessageTruncationStatus === 'unchanged' ||
ourMessageTruncationStatus === 'exhaustive',
'string is not ourMessageTruncationStatus enum',
);
return ourMessageTruncationStatus;
}
export type MessageTruncationStatuses = {
[threadID: string]: MessageTruncationStatus,
};
export type ThreadCursors = { [threadID: string]: ?string };
export type ThreadSelectionCriteria = {|
threadCursors?: ?ThreadCursors,
joinedThreads?: ?boolean,
|};
export type FetchMessageInfosRequest = {|
cursors: ThreadCursors,
numberPerThread?: ?number,
|};
export type FetchMessageInfosResult = {|
rawMessageInfos: RawMessageInfo[],
truncationStatuses: MessageTruncationStatuses,
userInfos: UserInfos,
|};
export type FetchMessageInfosPayload = {|
threadID: string,
rawMessageInfos: RawMessageInfo[],
truncationStatus: MessageTruncationStatus,
- userInfos: UserInfo[],
|};
export type MessagesResponse = {|
rawMessageInfos: RawMessageInfo[],
truncationStatuses: MessageTruncationStatuses,
currentAsOf: number,
|};
export const defaultNumberPerThread = 20;
export type SendMessageResponse = {|
newMessageInfo: RawMessageInfo,
|};
export type SendMessageResult = {|
id: string,
time: number,
|};
export type SendMessagePayload = {|
localID: string,
serverID: string,
threadID: string,
time: number,
|};
export type SendTextMessageRequest = {|
threadID: string,
localID?: string,
text: string,
|};
export type SendMultimediaMessageRequest = {|
threadID: string,
localID: string,
mediaIDs: $ReadOnlyArray<string>,
|};
// Used for the message info included in log-in type actions
export type GenericMessagesResult = {|
messageInfos: RawMessageInfo[],
truncationStatus: MessageTruncationStatuses,
watchedIDsAtRequestTime: $ReadOnlyArray<string>,
currentAsOf: number,
|};
export type SaveMessagesPayload = {|
rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
updatesCurrentAsOf: number,
|};
export type NewMessagesPayload = {|
messagesResult: MessagesResponse,
|};
export type MessageStorePrunePayload = {|
threadIDs: $ReadOnlyArray<string>,
|};
diff --git a/native/chat/compose-thread.react.js b/native/chat/compose-thread.react.js
index 2cee528fa..431f6e43a 100644
--- a/native/chat/compose-thread.react.js
+++ b/native/chat/compose-thread.react.js
@@ -1,531 +1,513 @@
// @flow
import type { AppState } from '../redux/redux-setup';
import type { LoadingStatus } from 'lib/types/loading-types';
import { loadingStatusPropType } from 'lib/types/loading-types';
import {
type ThreadInfo,
threadInfoPropType,
type ThreadType,
threadTypes,
threadTypePropType,
type NewThreadRequest,
type NewThreadResult,
} from 'lib/types/thread-types';
import {
type AccountUserInfo,
accountUserInfoPropType,
} from 'lib/types/user-types';
import type { DispatchActionPromise } from 'lib/utils/action-utils';
-import type { UserSearchResult } from 'lib/types/search-types';
import type { ChatNavigationProp } from './chat.react';
import type { NavigationRoute } from '../navigation/route-names';
import * as React from 'react';
import PropTypes from 'prop-types';
import { View, Text, Alert } from 'react-native';
import invariant from 'invariant';
import _flow from 'lodash/fp/flow';
import _filter from 'lodash/fp/filter';
import _sortBy from 'lodash/fp/sortBy';
import { createSelector } from 'reselect';
import { connect } from 'lib/utils/redux-utils';
import { newThreadActionTypes, newThread } from 'lib/actions/thread-actions';
-import { searchUsersActionTypes, searchUsers } from 'lib/actions/user-actions';
import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
import {
userInfoSelectorForOtherMembersOfThread,
userSearchIndexForOtherMembersOfThread,
} from 'lib/selectors/user-selectors';
import SearchIndex from 'lib/shared/search-index';
import { threadInFilterList, userIsMember } from 'lib/shared/thread-utils';
import { getUserSearchResults } from 'lib/shared/search-utils';
-import { registerFetchKey } from 'lib/reducers/loading-reducer';
import { threadInfoSelector } from 'lib/selectors/thread-selectors';
import TagInput from '../components/tag-input.react';
import UserList from '../components/user-list.react';
import ThreadList from '../components/thread-list.react';
import LinkButton from '../components/link-button.react';
import { MessageListRouteName } from '../navigation/route-names';
import ThreadVisibility from '../components/thread-visibility.react';
import {
type Colors,
colorsPropType,
colorsSelector,
styleSelector,
} from '../themes/colors';
const tagInputProps = {
placeholder: 'username',
autoFocus: true,
returnKeyType: 'go',
};
export type ComposeThreadParams = {|
threadType?: ThreadType,
parentThreadInfo?: ThreadInfo,
|};
type Props = {|
navigation: ChatNavigationProp<'ComposeThread'>,
route: NavigationRoute<'ComposeThread'>,
// Redux state
parentThreadInfo: ?ThreadInfo,
loadingStatus: LoadingStatus,
otherUserInfos: { [id: string]: AccountUserInfo },
userSearchIndex: SearchIndex,
threadInfos: { [id: string]: ThreadInfo },
colors: Colors,
styles: typeof styles,
// Redux dispatch functions
dispatchActionPromise: DispatchActionPromise,
// async functions that hit server APIs
newThread: (request: NewThreadRequest) => Promise<NewThreadResult>,
- searchUsers: (usernamePrefix: string) => Promise<UserSearchResult>,
|};
type State = {|
usernameInputText: string,
userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
|};
type PropsAndState = {| ...Props, ...State |};
class ComposeThread extends React.PureComponent<Props, State> {
static propTypes = {
navigation: PropTypes.shape({
setParams: PropTypes.func.isRequired,
setOptions: PropTypes.func.isRequired,
navigate: PropTypes.func.isRequired,
pushNewThread: PropTypes.func.isRequired,
}).isRequired,
route: PropTypes.shape({
key: PropTypes.string.isRequired,
params: PropTypes.shape({
threadType: threadTypePropType,
parentThreadInfo: threadInfoPropType,
}).isRequired,
}).isRequired,
parentThreadInfo: threadInfoPropType,
loadingStatus: loadingStatusPropType.isRequired,
otherUserInfos: PropTypes.objectOf(accountUserInfoPropType).isRequired,
userSearchIndex: PropTypes.instanceOf(SearchIndex).isRequired,
threadInfos: PropTypes.objectOf(threadInfoPropType).isRequired,
colors: colorsPropType.isRequired,
styles: PropTypes.objectOf(PropTypes.object).isRequired,
dispatchActionPromise: PropTypes.func.isRequired,
newThread: PropTypes.func.isRequired,
- searchUsers: PropTypes.func.isRequired,
};
state = {
usernameInputText: '',
userInfoInputArray: [],
};
tagInput: ?TagInput<AccountUserInfo>;
createThreadPressed = false;
waitingOnThreadID: ?string;
constructor(props: Props) {
super(props);
this.setLinkButton(true);
}
setLinkButton(enabled: boolean) {
this.props.navigation.setOptions({
headerRight: () => (
<LinkButton
text="Create"
onPress={this.onPressCreateThread}
disabled={!enabled}
/>
),
});
}
- componentDidMount() {
- this.searchUsers('');
- }
-
componentDidUpdate(prevProps: Props) {
const oldReduxParentThreadInfo = prevProps.parentThreadInfo;
const newReduxParentThreadInfo = this.props.parentThreadInfo;
if (
newReduxParentThreadInfo &&
newReduxParentThreadInfo !== oldReduxParentThreadInfo
) {
this.props.navigation.setParams({
parentThreadInfo: newReduxParentThreadInfo,
});
}
if (
this.waitingOnThreadID &&
this.props.threadInfos[this.waitingOnThreadID] &&
!prevProps.threadInfos[this.waitingOnThreadID]
) {
const threadInfo = this.props.threadInfos[this.waitingOnThreadID];
this.props.navigation.pushNewThread(threadInfo);
}
}
static getParentThreadInfo(props: {
route: NavigationRoute<'ComposeThread'>,
}): ?ThreadInfo {
return props.route.params.parentThreadInfo;
}
userSearchResultsSelector = createSelector(
(propsAndState: PropsAndState) => propsAndState.usernameInputText,
(propsAndState: PropsAndState) => propsAndState.otherUserInfos,
(propsAndState: PropsAndState) => propsAndState.userSearchIndex,
(propsAndState: PropsAndState) => propsAndState.userInfoInputArray,
(propsAndState: PropsAndState) =>
ComposeThread.getParentThreadInfo(propsAndState),
(
text: string,
userInfos: { [id: string]: AccountUserInfo },
searchIndex: SearchIndex,
userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
parentThreadInfo: ?ThreadInfo,
) =>
getUserSearchResults(
text,
userInfos,
searchIndex,
userInfoInputArray.map(userInfo => userInfo.id),
parentThreadInfo,
),
);
get userSearchResults() {
return this.userSearchResultsSelector({ ...this.props, ...this.state });
}
existingThreadsSelector = createSelector(
(propsAndState: PropsAndState) =>
ComposeThread.getParentThreadInfo(propsAndState),
(propsAndState: PropsAndState) => propsAndState.threadInfos,
(propsAndState: PropsAndState) => propsAndState.userInfoInputArray,
(
parentThreadInfo: ?ThreadInfo,
threadInfos: { [id: string]: ThreadInfo },
userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
) => {
const userIDs = userInfoInputArray.map(userInfo => userInfo.id);
if (userIDs.length === 0) {
return [];
}
return _flow(
_filter(
(threadInfo: ThreadInfo) =>
threadInFilterList(threadInfo) &&
(!parentThreadInfo ||
threadInfo.parentThreadID === parentThreadInfo.id) &&
userIDs.every(userID => userIsMember(threadInfo, userID)),
),
_sortBy(
([
'members.length',
(threadInfo: ThreadInfo) => (threadInfo.name ? 1 : 0),
]: $ReadOnlyArray<string | ((threadInfo: ThreadInfo) => mixed)>),
),
)(threadInfos);
},
);
get existingThreads() {
return this.existingThreadsSelector({ ...this.props, ...this.state });
}
render() {
let existingThreadsSection = null;
const { existingThreads, userSearchResults } = this;
if (existingThreads.length > 0) {
existingThreadsSection = (
<View style={this.props.styles.existingThreads}>
<View style={this.props.styles.existingThreadsRow}>
<Text style={this.props.styles.existingThreadsLabel}>
Existing threads
</Text>
</View>
<View style={this.props.styles.existingThreadList}>
<ThreadList
threadInfos={existingThreads}
onSelect={this.onSelectExistingThread}
itemTextStyle={this.props.styles.listItem}
/>
</View>
</View>
);
}
let parentThreadRow = null;
const parentThreadInfo = ComposeThread.getParentThreadInfo(this.props);
if (parentThreadInfo) {
const threadType = this.props.route.params.threadType;
invariant(
threadType !== undefined && threadType !== null,
`no threadType provided for ${parentThreadInfo.id}`,
);
const threadVisibilityColor = this.props.colors.modalForegroundLabel;
parentThreadRow = (
<View style={this.props.styles.parentThreadRow}>
<ThreadVisibility
threadType={threadType}
color={threadVisibilityColor}
/>
<Text style={this.props.styles.parentThreadLabel}>within</Text>
<Text style={this.props.styles.parentThreadName}>
{parentThreadInfo.uiName}
</Text>
</View>
);
}
const inputProps = {
...tagInputProps,
onSubmitEditing: this.onPressCreateThread,
};
return (
<View style={this.props.styles.container}>
{parentThreadRow}
<View style={this.props.styles.userSelectionRow}>
<Text style={this.props.styles.tagInputLabel}>To: </Text>
<View style={this.props.styles.tagInputContainer}>
<TagInput
value={this.state.userInfoInputArray}
onChange={this.onChangeTagInput}
text={this.state.usernameInputText}
onChangeText={this.setUsernameInputText}
labelExtractor={this.tagDataLabelExtractor}
inputProps={inputProps}
innerRef={this.tagInputRef}
/>
</View>
</View>
<View style={this.props.styles.userList}>
<UserList
userInfos={userSearchResults}
onSelect={this.onUserSelect}
itemTextStyle={this.props.styles.listItem}
/>
</View>
{existingThreadsSection}
</View>
);
}
tagInputRef = (tagInput: ?TagInput<AccountUserInfo>) => {
this.tagInput = tagInput;
};
onChangeTagInput = (userInfoInputArray: $ReadOnlyArray<AccountUserInfo>) => {
this.setState({ userInfoInputArray });
};
tagDataLabelExtractor = (userInfo: AccountUserInfo) => userInfo.username;
setUsernameInputText = (text: string) => {
- this.searchUsers(text);
this.setState({ usernameInputText: text });
};
- searchUsers(usernamePrefix: string) {
- this.props.dispatchActionPromise(
- searchUsersActionTypes,
- this.props.searchUsers(usernamePrefix),
- );
- }
-
onUserSelect = (userID: string) => {
for (let existingUserInfo of this.state.userInfoInputArray) {
if (userID === existingUserInfo.id) {
return;
}
}
const userInfoInputArray = [
...this.state.userInfoInputArray,
this.props.otherUserInfos[userID],
];
this.setState({
userInfoInputArray,
usernameInputText: '',
});
};
onPressCreateThread = () => {
if (this.createThreadPressed) {
return;
}
if (this.state.userInfoInputArray.length === 0) {
Alert.alert(
'Chatting to yourself?',
'Are you sure you want to create a thread containing only yourself?',
[
{ text: 'Cancel', style: 'cancel' },
{ text: 'Confirm', onPress: this.dispatchNewChatThreadAction },
],
);
} else {
this.dispatchNewChatThreadAction();
}
};
dispatchNewChatThreadAction = async () => {
this.createThreadPressed = true;
this.props.dispatchActionPromise(
newThreadActionTypes,
this.newChatThreadAction(),
);
};
async newChatThreadAction() {
this.setLinkButton(false);
try {
const threadTypeParam = this.props.route.params.threadType;
const threadType = threadTypeParam
? threadTypeParam
: threadTypes.CHAT_SECRET;
const initialMemberIDs = this.state.userInfoInputArray.map(
(userInfo: AccountUserInfo) => userInfo.id,
);
const parentThreadInfo = ComposeThread.getParentThreadInfo(this.props);
const result = await this.props.newThread({
type: threadType,
parentThreadID: parentThreadInfo ? parentThreadInfo.id : null,
initialMemberIDs,
color: parentThreadInfo ? parentThreadInfo.color : null,
});
this.waitingOnThreadID = result.newThreadID;
return result;
} catch (e) {
this.createThreadPressed = false;
this.setLinkButton(true);
Alert.alert(
'Unknown error',
'Uhh... try again?',
[{ text: 'OK', onPress: this.onUnknownErrorAlertAcknowledged }],
{ cancelable: false },
);
throw e;
}
}
onErrorAcknowledged = () => {
invariant(this.tagInput, 'tagInput should be set');
this.tagInput.focus();
};
onUnknownErrorAlertAcknowledged = () => {
this.setState({ usernameInputText: '' }, this.onErrorAcknowledged);
};
onSelectExistingThread = (threadID: string) => {
const threadInfo = this.props.threadInfos[threadID];
this.props.navigation.navigate({
name: MessageListRouteName,
params: { threadInfo },
key: `${MessageListRouteName}${threadInfo.id}`,
});
};
}
const styles = {
container: {
flex: 1,
},
existingThreadList: {
backgroundColor: 'modalBackground',
flex: 1,
paddingRight: 12,
},
existingThreads: {
flex: 1,
},
existingThreadsLabel: {
color: 'modalForegroundSecondaryLabel',
fontSize: 16,
paddingLeft: 12,
textAlign: 'center',
},
existingThreadsRow: {
backgroundColor: 'modalForeground',
borderBottomWidth: 1,
borderColor: 'modalForegroundBorder',
borderTopWidth: 1,
paddingVertical: 6,
},
listItem: {
color: 'modalForegroundLabel',
},
parentThreadLabel: {
color: 'modalSubtextLabel',
fontSize: 16,
paddingLeft: 6,
},
parentThreadName: {
color: 'modalForegroundLabel',
fontSize: 16,
paddingLeft: 6,
},
parentThreadRow: {
alignItems: 'center',
backgroundColor: 'modalSubtext',
flexDirection: 'row',
paddingLeft: 12,
paddingVertical: 6,
},
tagInputContainer: {
flex: 1,
marginLeft: 8,
paddingRight: 12,
},
tagInputLabel: {
color: 'modalForegroundSecondaryLabel',
fontSize: 16,
paddingLeft: 12,
},
userList: {
backgroundColor: 'modalBackground',
flex: 1,
paddingLeft: 35,
paddingRight: 12,
},
userSelectionRow: {
alignItems: 'center',
backgroundColor: 'modalForeground',
borderBottomWidth: 1,
borderColor: 'modalForegroundBorder',
flexDirection: 'row',
paddingVertical: 6,
},
};
const stylesSelector = styleSelector(styles);
const loadingStatusSelector = createLoadingStatusSelector(newThreadActionTypes);
-registerFetchKey(searchUsersActionTypes);
export default connect(
(
state: AppState,
ownProps: {
route: NavigationRoute<'ComposeThread'>,
},
) => {
let reduxParentThreadInfo = null;
const parentThreadInfo = ownProps.route.params.parentThreadInfo;
if (parentThreadInfo) {
reduxParentThreadInfo = threadInfoSelector(state)[parentThreadInfo.id];
}
return {
parentThreadInfo: reduxParentThreadInfo,
loadingStatus: loadingStatusSelector(state),
otherUserInfos: userInfoSelectorForOtherMembersOfThread((null: ?string))(
state,
),
userSearchIndex: userSearchIndexForOtherMembersOfThread(null)(state),
threadInfos: threadInfoSelector(state),
colors: colorsSelector(state),
styles: stylesSelector(state),
viewerID: state.currentUserInfo && state.currentUserInfo.id,
};
},
- { newThread, searchUsers },
+ { newThread },
)(ComposeThread);
diff --git a/native/chat/settings/add-users-modal.react.js b/native/chat/settings/add-users-modal.react.js
index 8329cf1ce..1f911c699 100644
--- a/native/chat/settings/add-users-modal.react.js
+++ b/native/chat/settings/add-users-modal.react.js
@@ -1,371 +1,353 @@
// @flow
import type { AppState } from '../../redux/redux-setup';
import {
type ThreadInfo,
threadInfoPropType,
type ChangeThreadSettingsPayload,
type UpdateThreadRequest,
} from 'lib/types/thread-types';
import {
type AccountUserInfo,
accountUserInfoPropType,
} from 'lib/types/user-types';
import type { DispatchActionPromise } from 'lib/utils/action-utils';
-import type { UserSearchResult } from 'lib/types/search-types';
import type { LoadingStatus } from 'lib/types/loading-types';
import { loadingStatusPropType } from 'lib/types/loading-types';
import type { RootNavigationProp } from '../../navigation/root-navigator.react';
import type { NavigationRoute } from '../../navigation/route-names';
import * as React from 'react';
import { View, Text, ActivityIndicator, Alert } from 'react-native';
import PropTypes from 'prop-types';
import invariant from 'invariant';
import { createSelector } from 'reselect';
import {
userInfoSelectorForOtherMembersOfThread,
userSearchIndexForOtherMembersOfThread,
} from 'lib/selectors/user-selectors';
import SearchIndex from 'lib/shared/search-index';
import { getUserSearchResults } from 'lib/shared/search-utils';
import { connect } from 'lib/utils/redux-utils';
import {
changeThreadSettingsActionTypes,
changeThreadSettings,
} from 'lib/actions/thread-actions';
-import { searchUsersActionTypes, searchUsers } from 'lib/actions/user-actions';
import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
-import { registerFetchKey } from 'lib/reducers/loading-reducer';
import { threadActualMembers } from 'lib/shared/thread-utils';
import { threadInfoSelector } from 'lib/selectors/thread-selectors';
import UserList from '../../components/user-list.react';
import TagInput from '../../components/tag-input.react';
import Button from '../../components/button.react';
import Modal from '../../components/modal.react';
import { styleSelector } from '../../themes/colors';
const tagInputProps = {
placeholder: 'Select users to add',
autoFocus: true,
returnKeyType: 'go',
};
export type AddUsersModalParams = {|
presentedFrom: string,
threadInfo: ThreadInfo,
|};
type Props = {|
navigation: RootNavigationProp<'AddUsersModal'>,
route: NavigationRoute<'AddUsersModal'>,
// Redux state
parentThreadInfo: ?ThreadInfo,
otherUserInfos: { [id: string]: AccountUserInfo },
userSearchIndex: SearchIndex,
changeThreadSettingsLoadingStatus: LoadingStatus,
styles: typeof styles,
// Redux dispatch functions
dispatchActionPromise: DispatchActionPromise,
// async functions that hit server APIs
changeThreadSettings: (
request: UpdateThreadRequest,
) => Promise<ChangeThreadSettingsPayload>,
- searchUsers: (usernamePrefix: string) => Promise<UserSearchResult>,
|};
type State = {|
usernameInputText: string,
userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
|};
type PropsAndState = {| ...Props, ...State |};
class AddUsersModal extends React.PureComponent<Props, State> {
static propTypes = {
navigation: PropTypes.shape({
goBackOnce: PropTypes.func.isRequired,
}).isRequired,
route: PropTypes.shape({
params: PropTypes.shape({
threadInfo: threadInfoPropType.isRequired,
}).isRequired,
}).isRequired,
parentThreadInfo: threadInfoPropType,
otherUserInfos: PropTypes.objectOf(accountUserInfoPropType).isRequired,
userSearchIndex: PropTypes.instanceOf(SearchIndex).isRequired,
changeThreadSettingsLoadingStatus: loadingStatusPropType.isRequired,
styles: PropTypes.objectOf(PropTypes.object).isRequired,
dispatchActionPromise: PropTypes.func.isRequired,
changeThreadSettings: PropTypes.func.isRequired,
- searchUsers: PropTypes.func.isRequired,
};
state = {
usernameInputText: '',
userInfoInputArray: [],
};
tagInput: ?TagInput<AccountUserInfo> = null;
- componentDidMount() {
- this.searchUsers('');
- }
-
- searchUsers(usernamePrefix: string) {
- this.props.dispatchActionPromise(
- searchUsersActionTypes,
- this.props.searchUsers(usernamePrefix),
- );
- }
-
userSearchResultsSelector = createSelector(
(propsAndState: PropsAndState) => propsAndState.usernameInputText,
(propsAndState: PropsAndState) => propsAndState.otherUserInfos,
(propsAndState: PropsAndState) => propsAndState.userSearchIndex,
(propsAndState: PropsAndState) => propsAndState.userInfoInputArray,
(propsAndState: PropsAndState) => propsAndState.route.params.threadInfo,
(propsAndState: PropsAndState) => propsAndState.parentThreadInfo,
(
text: string,
userInfos: { [id: string]: AccountUserInfo },
searchIndex: SearchIndex,
userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
threadInfo: ThreadInfo,
parentThreadInfo: ?ThreadInfo,
) => {
const excludeUserIDs = userInfoInputArray
.map(userInfo => userInfo.id)
.concat(threadActualMembers(threadInfo.members));
return getUserSearchResults(
text,
userInfos,
searchIndex,
excludeUserIDs,
parentThreadInfo,
);
},
);
get userSearchResults() {
return this.userSearchResultsSelector({ ...this.props, ...this.state });
}
render() {
let addButton = null;
const inputLength = this.state.userInfoInputArray.length;
if (inputLength > 0) {
let activityIndicator = null;
if (this.props.changeThreadSettingsLoadingStatus === 'loading') {
activityIndicator = (
<View style={this.props.styles.activityIndicator}>
<ActivityIndicator color="white" />
</View>
);
}
const addButtonText = `Add (${inputLength})`;
addButton = (
<Button
onPress={this.onPressAdd}
style={this.props.styles.addButton}
disabled={this.props.changeThreadSettingsLoadingStatus === 'loading'}
>
{activityIndicator}
<Text style={this.props.styles.addText}>{addButtonText}</Text>
</Button>
);
}
let cancelButton;
if (this.props.changeThreadSettingsLoadingStatus !== 'loading') {
cancelButton = (
<Button onPress={this.close} style={this.props.styles.cancelButton}>
<Text style={this.props.styles.cancelText}>Cancel</Text>
</Button>
);
} else {
cancelButton = <View />;
}
const inputProps = {
...tagInputProps,
onSubmitEditing: this.onPressAdd,
};
return (
<Modal navigation={this.props.navigation}>
<TagInput
value={this.state.userInfoInputArray}
onChange={this.onChangeTagInput}
text={this.state.usernameInputText}
onChangeText={this.setUsernameInputText}
labelExtractor={this.tagDataLabelExtractor}
defaultInputWidth={160}
maxHeight={36}
inputProps={inputProps}
innerRef={this.tagInputRef}
/>
<UserList
userInfos={this.userSearchResults}
onSelect={this.onUserSelect}
/>
<View style={this.props.styles.buttons}>
{cancelButton}
{addButton}
</View>
</Modal>
);
}
close = () => {
this.props.navigation.goBackOnce();
};
tagInputRef = (tagInput: ?TagInput<AccountUserInfo>) => {
this.tagInput = tagInput;
};
onChangeTagInput = (userInfoInputArray: $ReadOnlyArray<AccountUserInfo>) => {
if (this.props.changeThreadSettingsLoadingStatus === 'loading') {
return;
}
this.setState({ userInfoInputArray });
};
tagDataLabelExtractor = (userInfo: AccountUserInfo) => userInfo.username;
setUsernameInputText = (text: string) => {
if (this.props.changeThreadSettingsLoadingStatus === 'loading') {
return;
}
- this.searchUsers(text);
this.setState({ usernameInputText: text });
};
onUserSelect = (userID: string) => {
if (this.props.changeThreadSettingsLoadingStatus === 'loading') {
return;
}
for (let existingUserInfo of this.state.userInfoInputArray) {
if (userID === existingUserInfo.id) {
return;
}
}
const userInfoInputArray = [
...this.state.userInfoInputArray,
this.props.otherUserInfos[userID],
];
this.setState({
userInfoInputArray,
usernameInputText: '',
});
};
onPressAdd = () => {
if (this.state.userInfoInputArray.length === 0) {
return;
}
this.props.dispatchActionPromise(
changeThreadSettingsActionTypes,
this.addUsersToThread(),
);
};
async addUsersToThread() {
try {
const newMemberIDs = this.state.userInfoInputArray.map(
userInfo => userInfo.id,
);
const result = await this.props.changeThreadSettings({
threadID: this.props.route.params.threadInfo.id,
changes: { newMemberIDs },
});
this.close();
return result;
} catch (e) {
Alert.alert(
'Unknown error',
'Uhh... try again?',
[{ text: 'OK', onPress: this.onUnknownErrorAlertAcknowledged }],
{ cancelable: false },
);
throw e;
}
}
onErrorAcknowledged = () => {
invariant(this.tagInput, 'nameInput should be set');
this.tagInput.focus();
};
onUnknownErrorAlertAcknowledged = () => {
this.setState(
{
userInfoInputArray: [],
usernameInputText: '',
},
this.onErrorAcknowledged,
);
};
}
const styles = {
activityIndicator: {
paddingRight: 6,
},
addButton: {
backgroundColor: 'greenButton',
borderRadius: 3,
flexDirection: 'row',
paddingHorizontal: 10,
paddingVertical: 4,
},
addText: {
color: 'white',
fontSize: 18,
},
buttons: {
flexDirection: 'row',
justifyContent: 'space-between',
marginTop: 12,
},
cancelButton: {
backgroundColor: 'modalButton',
borderRadius: 3,
paddingHorizontal: 10,
paddingVertical: 4,
},
cancelText: {
color: 'modalButtonLabel',
fontSize: 18,
},
};
const stylesSelector = styleSelector(styles);
const changeThreadSettingsLoadingStatusSelector = createLoadingStatusSelector(
changeThreadSettingsActionTypes,
);
-registerFetchKey(searchUsersActionTypes);
export default connect(
(
state: AppState,
ownProps: {
route: NavigationRoute<'AddUsersModal'>,
},
) => {
let parentThreadInfo = null;
const { parentThreadID } = ownProps.route.params.threadInfo;
if (parentThreadID) {
parentThreadInfo = threadInfoSelector(state)[parentThreadID];
}
return {
parentThreadInfo,
otherUserInfos: userInfoSelectorForOtherMembersOfThread((null: ?string))(
state,
),
userSearchIndex: userSearchIndexForOtherMembersOfThread(null)(state),
changeThreadSettingsLoadingStatus: changeThreadSettingsLoadingStatusSelector(
state,
),
styles: stylesSelector(state),
};
},
- { changeThreadSettings, searchUsers },
+ { changeThreadSettings },
)(AddUsersModal);
diff --git a/native/more/add-friends-modal.react.js b/native/more/add-friends-modal.react.js
index 94e1c1f10..74865c0b1 100644
--- a/native/more/add-friends-modal.react.js
+++ b/native/more/add-friends-modal.react.js
@@ -1,233 +1,230 @@
// @flow
import type { AccountUserInfo } from 'lib/types/user-types';
import type { UserSearchResult } from 'lib/types/search-types';
import type { DispatchActionPromise } from 'lib/utils/action-utils';
import type { RootNavigationProp } from '../navigation/root-navigator.react';
import type { NavigationRoute } from '../navigation/route-names';
import type { AppState } from '../redux/redux-setup';
import * as React from 'react';
import { Text, View } from 'react-native';
import { CommonActions } from '@react-navigation/native';
import { createSelector } from 'reselect';
+import _keyBy from 'lodash/fp/keyBy';
-import {
- userInfoSelectorForOtherMembersOfThread,
- userSearchIndexForOtherMembersOfThread,
-} from 'lib/selectors/user-selectors';
+import { searchIndexFromUserInfos } from 'lib/selectors/user-selectors';
import { registerFetchKey } from 'lib/reducers/loading-reducer';
import { getUserSearchResults } from 'lib/shared/search-utils';
-import SearchIndex from 'lib/shared/search-index';
import { connect } from 'lib/utils/redux-utils';
import { searchUsersActionTypes, searchUsers } from 'lib/actions/user-actions';
import UserList from '../components/user-list.react';
import Modal from '../components/modal.react';
import Button from '../components/button.react';
import TagInput from '../components/tag-input.react';
import { styleSelector } from '../themes/colors';
const tagInputProps = {
placeholder: 'Select users to invite',
autoFocus: true,
returnKeyType: 'go',
};
type Props = {|
navigation: RootNavigationProp<'AddFriendsModal'>,
route: NavigationRoute<'AddFriendsModal'>,
// Redux state
- otherUserInfos: { [id: string]: AccountUserInfo },
- userSearchIndex: SearchIndex,
+ viewerID: ?string,
styles: typeof styles,
// Redux dispatch functions
dispatchActionPromise: DispatchActionPromise,
// async functions that hit server APIs
searchUsers: (usernamePrefix: string) => Promise<UserSearchResult>,
sendFriendRequest: (userIDs: string[]) => Promise<void>,
|};
type State = {|
usernameInputText: string,
userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
+ userInfos: { [id: string]: AccountUserInfo },
|};
type PropsAndState = {| ...Props, ...State |};
class AddFriendsModal extends React.PureComponent<Props, State> {
state = {
usernameInputText: '',
userInfoInputArray: [],
+ userInfos: {},
};
tagInput: ?TagInput<AccountUserInfo> = null;
componentDidMount() {
this.searchUsers('');
}
- searchUsers(usernamePrefix: string) {
- this.props.dispatchActionPromise(
- searchUsersActionTypes,
- this.props.searchUsers(usernamePrefix),
- );
+ async searchUsers(usernamePrefix: string) {
+ const { userInfos } = await this.props.searchUsers(usernamePrefix);
+ this.setState({ userInfos: _keyBy(userInfo => userInfo.id)(userInfos) });
}
userSearchResultsSelector = createSelector(
(propsAndState: PropsAndState) => propsAndState.usernameInputText,
- (propsAndState: PropsAndState) => propsAndState.otherUserInfos,
- (propsAndState: PropsAndState) => propsAndState.userSearchIndex,
+ (propsAndState: PropsAndState) => propsAndState.userInfos,
+ (propsAndState: PropsAndState) => propsAndState.viewerID,
(propsAndState: PropsAndState) => propsAndState.userInfoInputArray,
(
text: string,
userInfos: { [id: string]: AccountUserInfo },
- searchIndex: SearchIndex,
+ viewerID: ?string,
userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
) => {
- // TODO: exclude current and blocked friends
- const excludeUserIDs = userInfoInputArray.map(userInfo => userInfo.id);
+ const excludeUserIDs = userInfoInputArray
+ .map(userInfo => userInfo.id)
+ .concat(viewerID || []);
+ const searchIndex = searchIndexFromUserInfos(userInfos);
return getUserSearchResults(text, userInfos, searchIndex, excludeUserIDs);
},
);
get userSearchResults() {
return this.userSearchResultsSelector({ ...this.props, ...this.state });
}
render() {
let addButton = null;
const inputLength = this.state.userInfoInputArray.length;
if (inputLength > 0) {
const addButtonText = `Add (${inputLength})`;
addButton = (
<Button onPress={this.onPressAdd} style={this.props.styles.addButton}>
<Text style={this.props.styles.addText}>{addButtonText}</Text>
</Button>
);
}
const inputProps = {
...tagInputProps,
onSubmitEditing: this.onPressAdd,
};
return (
<Modal navigation={this.props.navigation}>
<TagInput
value={this.state.userInfoInputArray}
onChange={this.onChangeTagInput}
text={this.state.usernameInputText}
onChangeText={this.setUsernameInputText}
labelExtractor={this.tagDataLabelExtractor}
defaultInputWidth={160}
maxHeight={36}
inputProps={inputProps}
innerRef={this.tagInputRef}
/>
<UserList
userInfos={this.userSearchResults}
onSelect={this.onUserSelect}
/>
<View style={this.props.styles.buttons}>
<Button onPress={this.close} style={this.props.styles.cancelButton}>
<Text style={this.props.styles.cancelText}>Cancel</Text>
</Button>
{addButton}
</View>
</Modal>
);
}
tagInputRef = (tagInput: ?TagInput<AccountUserInfo>) => {
this.tagInput = tagInput;
};
tagDataLabelExtractor = (userInfo: AccountUserInfo) => userInfo.username;
setUsernameInputText = (text: string) => {
this.searchUsers(text);
this.setState({ usernameInputText: text });
};
onChangeTagInput = (userInfoInputArray: $ReadOnlyArray<AccountUserInfo>) => {
this.setState({ userInfoInputArray });
};
onUserSelect = (userID: string) => {
if (this.state.userInfoInputArray.find(o => o.id === userID)) {
return;
}
- const selectedUserInfo = this.props.otherUserInfos[userID];
+ const selectedUserInfo = this.state.userInfos[userID];
this.setState(state => ({
userInfoInputArray: state.userInfoInputArray.concat(selectedUserInfo),
usernameInputText: '',
}));
};
onPressAdd = () => {
if (this.state.userInfoInputArray.length === 0) {
return;
}
this.props.navigation.goBack();
};
goBackOnce() {
this.props.navigation.dispatch(state => ({
...CommonActions.goBack(),
target: state.key,
}));
}
close = () => {
this.goBackOnce();
};
}
const styles = {
activityIndicator: {
paddingRight: 6,
},
addButton: {
backgroundColor: 'greenButton',
borderRadius: 3,
flexDirection: 'row',
paddingHorizontal: 10,
paddingVertical: 4,
},
addText: {
color: 'white',
fontSize: 18,
},
buttons: {
flexDirection: 'row',
justifyContent: 'space-between',
marginTop: 12,
},
cancelButton: {
backgroundColor: 'modalButton',
borderRadius: 3,
paddingHorizontal: 10,
paddingVertical: 4,
},
cancelText: {
color: 'modalButtonLabel',
fontSize: 18,
},
};
const stylesSelector = styleSelector(styles);
registerFetchKey(searchUsersActionTypes);
export default connect(
(state: AppState) => {
return {
- otherUserInfos: userInfoSelectorForOtherMembersOfThread(null)(state),
- userSearchIndex: userSearchIndexForOtherMembersOfThread(null)(state),
+ viewerID: state.currentUserInfo && state.currentUserInfo.id,
styles: stylesSelector(state),
};
},
{ searchUsers },
)(AddFriendsModal);
diff --git a/server/src/creators/thread-creator.js b/server/src/creators/thread-creator.js
index e465154e3..8598f9e0a 100644
--- a/server/src/creators/thread-creator.js
+++ b/server/src/creators/thread-creator.js
@@ -1,228 +1,228 @@
// @flow
import {
type NewThreadRequest,
type NewThreadResponse,
threadTypes,
threadPermissions,
} from 'lib/types/thread-types';
import { messageTypes } from 'lib/types/message-types';
import type { Viewer } from '../session/viewer';
import invariant from 'invariant';
import { generateRandomColor } from 'lib/shared/thread-utils';
import { ServerError } from 'lib/utils/errors';
import { promiseAll } from 'lib/utils/promises';
import { hasMinCodeVersion } from 'lib/shared/version-utils';
import { dbQuery, SQL } from '../database';
import { checkThreadPermission } from '../fetchers/thread-fetchers';
import createIDs from './id-creator';
import { createInitialRolesForNewThread } from './role-creator';
import { fetchKnownUserInfos } from '../fetchers/user-fetchers';
import {
changeRole,
recalculateAllPermissions,
commitMembershipChangeset,
setJoinsToUnread,
getRelationshipRowsForUsers,
getParentThreadRelationshipRowsForNewUsers,
} from '../updaters/thread-permission-updaters';
import createMessages from './message-creator';
async function createThread(
viewer: Viewer,
request: NewThreadRequest,
createRelationships?: boolean = false,
): Promise<NewThreadResponse> {
if (!viewer.loggedIn) {
throw new ServerError('not_logged_in');
}
const threadType = request.type;
const parentThreadID = request.parentThreadID ? request.parentThreadID : null;
const initialMemberIDs =
request.initialMemberIDs && request.initialMemberIDs.length > 0
? request.initialMemberIDs
- : [];
+ : null;
if (threadType !== threadTypes.CHAT_SECRET && !parentThreadID) {
throw new ServerError('invalid_parameters');
}
const checkPromises = {};
if (parentThreadID) {
checkPromises.hasParentPermission = checkThreadPermission(
viewer,
parentThreadID,
threadPermissions.CREATE_SUBTHREADS,
);
}
if (initialMemberIDs) {
checkPromises.fetchInitialMembers = fetchKnownUserInfos(
viewer,
initialMemberIDs,
);
}
const checkResults = await promiseAll(checkPromises);
if (checkResults.hasParentPermission === false) {
throw new ServerError('invalid_credentials');
}
const viewerNeedsRelationshipsWith = [];
if (checkResults.fetchInitialMembers) {
invariant(initialMemberIDs, 'should be set');
for (const initialMemberID of initialMemberIDs) {
if (checkResults.fetchInitialMembers[initialMemberID]) {
continue;
}
if (!createRelationships) {
throw new ServerError('invalid_credentials');
}
viewerNeedsRelationshipsWith.push(initialMemberID);
}
}
const [id] = await createIDs('threads', 1);
const newRoles = await createInitialRolesForNewThread(id, threadType);
const name = request.name ? request.name : null;
const description = request.description ? request.description : null;
const color = request.color
? request.color.toLowerCase()
: generateRandomColor();
const time = Date.now();
const row = [
id,
threadType,
name,
description,
viewer.userID,
time,
color,
parentThreadID,
newRoles.default.id,
];
const query = SQL`
INSERT INTO threads(id, type, name, description, creator,
creation_time, color, parent_thread_id, default_role)
VALUES ${[row]}
`;
await dbQuery(query);
const [
creatorChangeset,
initialMembersChangeset,
recalculatePermissionsChangeset,
] = await Promise.all([
changeRole(id, [viewer.userID], newRoles.creator.id),
initialMemberIDs ? changeRole(id, initialMemberIDs, null) : undefined,
recalculateAllPermissions(id, threadType),
]);
if (!creatorChangeset) {
throw new ServerError('unknown_error');
}
const {
membershipRows: creatorMembershipRows,
relationshipRows: creatorRelationshipRows,
} = creatorChangeset;
const initialMemberAndCreatorIDs = initialMemberIDs
? [...initialMemberIDs, viewer.userID]
: [viewer.userID];
const {
membershipRows: recalculateMembershipRows,
relationshipRows: recalculateRelationshipRows,
} = recalculatePermissionsChangeset;
const membershipRows = [
...creatorMembershipRows,
...recalculateMembershipRows,
];
const relationshipRows = [
...creatorRelationshipRows,
...recalculateRelationshipRows,
];
if (initialMemberIDs) {
if (!initialMembersChangeset) {
throw new ServerError('unknown_error');
}
relationshipRows.push(
...getRelationshipRowsForUsers(
viewer.userID,
viewerNeedsRelationshipsWith,
),
);
const {
membershipRows: initialMembersMembershipRows,
relationshipRows: initialMembersRelationshipRows,
} = initialMembersChangeset;
const parentRelationshipRows = getParentThreadRelationshipRowsForNewUsers(
id,
recalculateMembershipRows,
initialMemberAndCreatorIDs,
);
membershipRows.push(...initialMembersMembershipRows);
relationshipRows.push(
...initialMembersRelationshipRows,
...parentRelationshipRows,
);
}
setJoinsToUnread(membershipRows, viewer.userID, id);
const messageDatas = [
{
type: messageTypes.CREATE_THREAD,
threadID: id,
creatorID: viewer.userID,
time,
initialThreadState: {
type: threadType,
name,
parentThreadID,
color,
memberIDs: initialMemberAndCreatorIDs,
},
},
];
if (parentThreadID) {
messageDatas.push({
type: messageTypes.CREATE_SUB_THREAD,
threadID: parentThreadID,
creatorID: viewer.userID,
time,
childThreadID: id,
});
}
const changeset = { membershipRows, relationshipRows };
const [newMessageInfos, commitResult] = await Promise.all([
createMessages(viewer, messageDatas),
commitMembershipChangeset(viewer, changeset),
]);
const { threadInfos, viewerUpdates } = commitResult;
if (hasMinCodeVersion(viewer.platformDetails, 62)) {
return {
newThreadID: id,
updatesResult: {
newUpdates: viewerUpdates,
},
newMessageInfos,
};
}
return {
newThreadInfo: threadInfos[id],
updatesResult: {
newUpdates: viewerUpdates,
},
newMessageInfos,
};
}
export default createThread;
diff --git a/server/src/fetchers/entry-fetchers.js b/server/src/fetchers/entry-fetchers.js
index 745c688ac..6ccae138f 100644
--- a/server/src/fetchers/entry-fetchers.js
+++ b/server/src/fetchers/entry-fetchers.js
@@ -1,339 +1,319 @@
// @flow
import type {
CalendarQuery,
FetchEntryInfosResponse,
DeltaEntryInfosResponse,
RawEntryInfo,
} from 'lib/types/entry-types';
import type { HistoryRevisionInfo } from 'lib/types/history-types';
import type { Viewer } from '../session/viewer';
import {
threadPermissions,
type ThreadPermission,
} from 'lib/types/thread-types';
import { calendarThreadFilterTypes } from 'lib/types/filter-types';
import invariant from 'invariant';
import { permissionLookup } from 'lib/permissions/thread-permissions';
import { ServerError } from 'lib/utils/errors';
import {
filteredThreadIDs,
filterExists,
nonExcludeDeletedCalendarFilters,
} from 'lib/selectors/calendar-filter-selectors';
-import {
- rawEntryInfoWithinCalendarQuery,
- usersInRawEntryInfos,
-} from 'lib/shared/entry-utils';
+import { rawEntryInfoWithinCalendarQuery } from 'lib/shared/entry-utils';
import {
dbQuery,
SQL,
SQLStatement,
mergeAndConditions,
mergeOrConditions,
} from '../database';
import { creationString } from '../utils/idempotent';
async function fetchEntryInfo(
viewer: Viewer,
entryID: string,
): Promise<?RawEntryInfo> {
const results = await fetchEntryInfosByID(viewer, [entryID]);
if (results.length === 0) {
return null;
}
return results[0];
}
function rawEntryInfoFromRow(row: Object): RawEntryInfo {
return {
id: row.id.toString(),
threadID: row.threadID.toString(),
text: row.text,
year: row.year,
month: row.month,
day: row.day,
creationTime: row.creationTime,
creatorID: row.creatorID.toString(),
deleted: !!row.deleted,
};
}
const visPermissionExtractString = `$.${threadPermissions.VISIBLE}.value`;
async function fetchEntryInfosByID(
viewer: Viewer,
entryIDs: $ReadOnlyArray<string>,
): Promise<RawEntryInfo[]> {
if (entryIDs.length === 0) {
return [];
}
const viewerID = viewer.id;
const query = SQL`
SELECT DAY(d.date) AS day, MONTH(d.date) AS month, YEAR(d.date) AS year,
e.id, e.text, e.creation_time AS creationTime, d.thread AS threadID,
e.deleted, e.creator AS creatorID
FROM entries e
LEFT JOIN days d ON d.id = e.day
LEFT JOIN memberships m ON m.thread = d.thread AND m.user = ${viewerID}
WHERE e.id IN (${entryIDs}) AND
JSON_EXTRACT(m.permissions, ${visPermissionExtractString}) IS TRUE
`;
const [result] = await dbQuery(query);
return result.map(rawEntryInfoFromRow);
}
function sqlConditionForCalendarQuery(
calendarQuery: CalendarQuery,
): ?SQLStatement {
const { filters, startDate, endDate } = calendarQuery;
const conditions = [];
conditions.push(SQL`d.date BETWEEN ${startDate} AND ${endDate}`);
const filterToThreadIDs = filteredThreadIDs(filters);
if (filterToThreadIDs && filterToThreadIDs.size > 0) {
conditions.push(SQL`d.thread IN (${[...filterToThreadIDs]})`);
} else if (filterToThreadIDs) {
// Filter to empty set means the result is empty
return null;
} else {
conditions.push(SQL`m.role != 0`);
}
if (filterExists(filters, calendarThreadFilterTypes.NOT_DELETED)) {
conditions.push(SQL`e.deleted = 0`);
}
return mergeAndConditions(conditions);
}
async function fetchEntryInfos(
viewer: Viewer,
calendarQueries: $ReadOnlyArray<CalendarQuery>,
): Promise<FetchEntryInfosResponse> {
const queryConditions = calendarQueries
.map(sqlConditionForCalendarQuery)
.filter(condition => condition);
if (queryConditions.length === 0) {
return { rawEntryInfos: [], userInfos: {} };
}
const queryCondition = mergeOrConditions(queryConditions);
const viewerID = viewer.id;
const query = SQL`
SELECT DAY(d.date) AS day, MONTH(d.date) AS month, YEAR(d.date) AS year,
e.id, e.text, e.creation_time AS creationTime, d.thread AS threadID,
e.deleted, e.creator AS creatorID, u.username AS creator
FROM entries e
LEFT JOIN days d ON d.id = e.day
LEFT JOIN memberships m ON m.thread = d.thread AND m.user = ${viewerID}
LEFT JOIN users u ON u.id = e.creator
WHERE JSON_EXTRACT(m.permissions, ${visPermissionExtractString}) IS TRUE AND
`;
query.append(queryCondition);
query.append(SQL`ORDER BY e.creation_time DESC`);
const [result] = await dbQuery(query);
const rawEntryInfos = [];
- const userInfos = {};
for (let row of result) {
rawEntryInfos.push(rawEntryInfoFromRow(row));
- if (row.creator) {
- const creatorID = row.creatorID.toString();
- userInfos[creatorID] = {
- id: creatorID,
- username: row.creator,
- };
- }
}
- return { rawEntryInfos, userInfos };
+ return { rawEntryInfos, userInfos: {} };
}
async function checkThreadPermissionForEntry(
viewer: Viewer,
entryID: string,
permission: ThreadPermission,
): Promise<boolean> {
const viewerID = viewer.id;
const query = SQL`
SELECT m.permissions, t.id
FROM entries e
LEFT JOIN days d ON d.id = e.day
LEFT JOIN threads t ON t.id = d.thread
LEFT JOIN memberships m ON m.thread = t.id AND m.user = ${viewerID}
WHERE e.id = ${entryID}
`;
const [result] = await dbQuery(query);
if (result.length === 0) {
return false;
}
const row = result[0];
if (row.id === null) {
return false;
}
return permissionLookup(row.permissions, permission);
}
async function fetchEntryRevisionInfo(
viewer: Viewer,
entryID: string,
): Promise<$ReadOnlyArray<HistoryRevisionInfo>> {
const hasPermission = await checkThreadPermissionForEntry(
viewer,
entryID,
threadPermissions.VISIBLE,
);
if (!hasPermission) {
throw new ServerError('invalid_credentials');
}
const query = SQL`
SELECT r.id, u.username AS author, r.text, r.last_update AS lastUpdate,
r.deleted, d.thread AS threadID, r.entry AS entryID
FROM revisions r
LEFT JOIN users u ON u.id = r.author
LEFT JOIN entries e ON e.id = r.entry
LEFT JOIN days d ON d.id = e.day
WHERE r.entry = ${entryID}
ORDER BY r.last_update DESC
`;
const [result] = await dbQuery(query);
const revisions = [];
for (let row of result) {
revisions.push({
id: row.id.toString(),
author: row.author,
text: row.text,
lastUpdate: row.lastUpdate,
deleted: !!row.deleted,
threadID: row.threadID.toString(),
entryID: row.entryID.toString(),
});
}
return revisions;
}
// calendarQueries are the "difference" queries we get from subtracting the old
// CalendarQuery from the new one. See calendarQueryDifference.
// oldCalendarQuery is the old CalendarQuery. We make sure none of the returned
// RawEntryInfos match the old CalendarQuery, so that only the difference is
// returned.
async function fetchEntriesForSession(
viewer: Viewer,
calendarQueries: $ReadOnlyArray<CalendarQuery>,
oldCalendarQuery: CalendarQuery,
): Promise<DeltaEntryInfosResponse> {
// If we're not including deleted entries, we will try and set deletedEntryIDs
// so that the client can catch possibly stale deleted entryInfos
let filterDeleted = null;
for (let calendarQuery of calendarQueries) {
const notDeletedFilterExists = filterExists(
calendarQuery.filters,
calendarThreadFilterTypes.NOT_DELETED,
);
if (filterDeleted === null) {
filterDeleted = notDeletedFilterExists;
} else {
invariant(
filterDeleted === notDeletedFilterExists,
'one of the CalendarQueries returned by calendarQueryDifference has ' +
'a NOT_DELETED filter but another does not: ' +
JSON.stringify(calendarQueries),
);
}
}
let calendarQueriesForFetch = calendarQueries;
if (filterDeleted) {
// Because in the filterDeleted case we still need the deleted RawEntryInfos
// in order to construct deletedEntryIDs, we get rid of the NOT_DELETED
// filters before passing the CalendarQueries to fetchEntryInfos. We will
// filter out the deleted RawEntryInfos in a later step.
calendarQueriesForFetch = calendarQueriesForFetch.map(calendarQuery => ({
...calendarQuery,
filters: nonExcludeDeletedCalendarFilters(calendarQuery.filters),
}));
}
- const { rawEntryInfos, userInfos } = await fetchEntryInfos(
+ const { rawEntryInfos } = await fetchEntryInfos(
viewer,
calendarQueriesForFetch,
);
const entryInfosNotInOldQuery = rawEntryInfos.filter(
rawEntryInfo =>
!rawEntryInfoWithinCalendarQuery(rawEntryInfo, oldCalendarQuery),
);
let filteredRawEntryInfos = entryInfosNotInOldQuery;
let deletedEntryIDs = [];
if (filterDeleted) {
filteredRawEntryInfos = entryInfosNotInOldQuery.filter(
rawEntryInfo => !rawEntryInfo.deleted,
);
deletedEntryIDs = entryInfosNotInOldQuery
.filter(rawEntryInfo => rawEntryInfo.deleted)
.map(rawEntryInfo => {
const { id } = rawEntryInfo;
invariant(
id !== null && id !== undefined,
'serverID should be set in fetchEntryInfos result',
);
return id;
});
}
- const userIDs = new Set(usersInRawEntryInfos(filteredRawEntryInfos));
- const filteredUserInfos = {};
- for (let userID in userInfos) {
- if (!userIDs.has(userID)) {
- continue;
- }
- filteredUserInfos[userID] = userInfos[userID];
- }
return {
rawEntryInfos: filteredRawEntryInfos,
deletedEntryIDs,
- userInfos: filteredUserInfos,
};
}
async function fetchEntryInfoForLocalID(
viewer: Viewer,
localID: ?string,
): Promise<?RawEntryInfo> {
if (!localID || !viewer.hasSessionInfo) {
return null;
}
const creation = creationString(viewer, localID);
const viewerID = viewer.id;
const query = SQL`
SELECT DAY(d.date) AS day, MONTH(d.date) AS month, YEAR(d.date) AS year,
e.id, e.text, e.creation_time AS creationTime, d.thread AS threadID,
e.deleted, e.creator AS creatorID
FROM entries e
LEFT JOIN days d ON d.id = e.day
LEFT JOIN memberships m ON m.thread = d.thread AND m.user = ${viewerID}
WHERE e.creator = ${viewerID} AND e.creation = ${creation} AND
JSON_EXTRACT(m.permissions, ${visPermissionExtractString}) IS TRUE
`;
const [result] = await dbQuery(query);
if (result.length === 0) {
return null;
}
return rawEntryInfoFromRow(result[0]);
}
export {
fetchEntryInfo,
fetchEntryInfosByID,
fetchEntryInfos,
checkThreadPermissionForEntry,
fetchEntryRevisionInfo,
fetchEntriesForSession,
fetchEntryInfoForLocalID,
};
diff --git a/server/src/fetchers/message-fetchers.js b/server/src/fetchers/message-fetchers.js
index 4a1e31c68..78a05d596 100644
--- a/server/src/fetchers/message-fetchers.js
+++ b/server/src/fetchers/message-fetchers.js
@@ -1,730 +1,729 @@
// @flow
import type { PushInfo } from '../push/send';
import type { UserInfos } from 'lib/types/user-types';
import {
type RawMessageInfo,
messageTypes,
type MessageType,
assertMessageType,
type ThreadSelectionCriteria,
type MessageTruncationStatus,
messageTruncationStatus,
type FetchMessageInfosResult,
type RawTextMessageInfo,
} from 'lib/types/message-types';
import { threadPermissions } from 'lib/types/thread-types';
import type { Viewer } from '../session/viewer';
import invariant from 'invariant';
import { notifCollapseKeyForRawMessageInfo } from 'lib/shared/notif-utils';
import {
sortMessageInfoList,
shimUnsupportedRawMessageInfos,
createMediaMessageInfo,
} from 'lib/shared/message-utils';
import { permissionLookup } from 'lib/permissions/thread-permissions';
import { ServerError } from 'lib/utils/errors';
import { dbQuery, SQL, mergeOrConditions } from '../database';
import { fetchUserInfos } from './user-fetchers';
import { creationString, localIDFromCreationString } from '../utils/idempotent';
import { mediaFromRow } from './upload-fetchers';
export type CollapsableNotifInfo = {|
collapseKey: ?string,
existingMessageInfos: RawMessageInfo[],
newMessageInfos: RawMessageInfo[],
|};
export type FetchCollapsableNotifsResult = {|
usersToCollapsableNotifInfo: { [userID: string]: CollapsableNotifInfo[] },
userInfos: UserInfos,
|};
// This function doesn't filter RawMessageInfos based on what messageTypes the
// client supports, since each user can have multiple clients. The caller must
// handle this filtering.
async function fetchCollapsableNotifs(
pushInfo: PushInfo,
): Promise<FetchCollapsableNotifsResult> {
// First, we need to fetch any notifications that should be collapsed
const usersToCollapseKeysToInfo = {};
const usersToCollapsableNotifInfo = {};
for (let userID in pushInfo) {
usersToCollapseKeysToInfo[userID] = {};
usersToCollapsableNotifInfo[userID] = [];
for (let rawMessageInfo of pushInfo[userID].messageInfos) {
const collapseKey = notifCollapseKeyForRawMessageInfo(rawMessageInfo);
if (!collapseKey) {
const collapsableNotifInfo = {
collapseKey,
existingMessageInfos: [],
newMessageInfos: [rawMessageInfo],
};
usersToCollapsableNotifInfo[userID].push(collapsableNotifInfo);
continue;
}
if (!usersToCollapseKeysToInfo[userID][collapseKey]) {
usersToCollapseKeysToInfo[userID][collapseKey] = {
collapseKey,
existingMessageInfos: [],
newMessageInfos: [],
};
}
usersToCollapseKeysToInfo[userID][collapseKey].newMessageInfos.push(
rawMessageInfo,
);
}
}
const sqlTuples = [];
for (let userID in usersToCollapseKeysToInfo) {
const collapseKeysToInfo = usersToCollapseKeysToInfo[userID];
for (let collapseKey in collapseKeysToInfo) {
sqlTuples.push(
SQL`(n.user = ${userID} AND n.collapse_key = ${collapseKey})`,
);
}
}
if (sqlTuples.length === 0) {
return { usersToCollapsableNotifInfo, userInfos: {} };
}
const visPermissionExtractString = `$.${threadPermissions.VISIBLE}.value`;
const collapseQuery = SQL`
SELECT m.id, m.thread AS threadID, m.content, m.time, m.type,
u.username AS creator, m.user AS creatorID,
stm.permissions AS subthread_permissions, n.user, n.collapse_key,
up.id AS uploadID, up.type AS uploadType, up.secret AS uploadSecret,
up.extra AS uploadExtra
FROM notifications n
LEFT JOIN messages m ON m.id = n.message
LEFT JOIN uploads up
ON m.type IN (${[messageTypes.IMAGES, messageTypes.MULTIMEDIA]})
AND JSON_CONTAINS(m.content, CAST(up.id as JSON), '$')
LEFT JOIN memberships mm ON mm.thread = m.thread AND mm.user = n.user
LEFT JOIN memberships stm
ON m.type = ${messageTypes.CREATE_SUB_THREAD}
AND stm.thread = m.content AND stm.user = n.user
LEFT JOIN users u ON u.id = m.user
WHERE n.rescinded = 0 AND
JSON_EXTRACT(mm.permissions, ${visPermissionExtractString}) IS TRUE AND
`;
collapseQuery.append(mergeOrConditions(sqlTuples));
collapseQuery.append(SQL`ORDER BY m.time DESC`);
const [collapseResult] = await dbQuery(collapseQuery);
const { userInfos, messages } = parseMessageSQLResult(collapseResult);
for (let message of messages) {
const { rawMessageInfo, rows } = message;
const [row] = rows;
const info = usersToCollapseKeysToInfo[row.user][row.collapse_key];
info.existingMessageInfos.push(rawMessageInfo);
}
for (let userID in usersToCollapseKeysToInfo) {
const collapseKeysToInfo = usersToCollapseKeysToInfo[userID];
for (let collapseKey in collapseKeysToInfo) {
const info = collapseKeysToInfo[collapseKey];
usersToCollapsableNotifInfo[userID].push({
collapseKey: info.collapseKey,
existingMessageInfos: sortMessageInfoList(info.existingMessageInfos),
newMessageInfos: sortMessageInfoList(info.newMessageInfos),
});
}
}
return { usersToCollapsableNotifInfo, userInfos };
}
type MessageSQLResult = {|
messages: $ReadOnlyArray<{|
rawMessageInfo: RawMessageInfo,
rows: $ReadOnlyArray<Object>,
|}>,
userInfos: UserInfos,
|};
function parseMessageSQLResult(
rows: $ReadOnlyArray<Object>,
viewer?: Viewer,
): MessageSQLResult {
const userInfos = {},
rowsByID = new Map();
for (let row of rows) {
const creatorID = row.creatorID.toString();
userInfos[creatorID] = {
id: creatorID,
username: row.creator,
};
const id = row.id.toString();
const currentRowsForID = rowsByID.get(id);
if (currentRowsForID) {
currentRowsForID.push(row);
} else {
rowsByID.set(id, [row]);
}
}
const messages = [];
for (let messageRows of rowsByID.values()) {
const rawMessageInfo = rawMessageInfoFromRows(messageRows, viewer);
if (rawMessageInfo) {
messages.push({ rawMessageInfo, rows: messageRows });
}
}
return { messages, userInfos };
}
function assertSingleRow(rows: $ReadOnlyArray<Object>): Object {
if (rows.length === 0) {
throw new Error('expected single row, but none present!');
} else if (rows.length !== 1) {
const messageIDs = rows.map(row => row.id.toString());
console.log(
`expected single row, but there are multiple! ${messageIDs.join(', ')}`,
);
}
return rows[0];
}
function mostRecentRowType(rows: $ReadOnlyArray<Object>): MessageType {
if (rows.length === 0) {
throw new Error('expected row, but none present!');
}
return assertMessageType(rows[0].type);
}
function rawMessageInfoFromRows(
rows: $ReadOnlyArray<Object>,
viewer?: ?Viewer,
): ?RawMessageInfo {
const type = mostRecentRowType(rows);
if (type === messageTypes.TEXT) {
const row = assertSingleRow(rows);
const rawTextMessageInfo: RawTextMessageInfo = {
type: messageTypes.TEXT,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
text: row.content,
};
const localID = localIDFromCreationString(viewer, row.creation);
if (localID) {
rawTextMessageInfo.localID = localID;
}
return rawTextMessageInfo;
} else if (type === messageTypes.CREATE_THREAD) {
const row = assertSingleRow(rows);
const dbInitialThreadState = JSON.parse(row.content);
// For legacy clients before the rename
const initialThreadState = {
...dbInitialThreadState,
visibilityRules: dbInitialThreadState.type,
};
return {
type: messageTypes.CREATE_THREAD,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
initialThreadState,
};
} else if (type === messageTypes.ADD_MEMBERS) {
const row = assertSingleRow(rows);
return {
type: messageTypes.ADD_MEMBERS,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
addedUserIDs: JSON.parse(row.content),
};
} else if (type === messageTypes.CREATE_SUB_THREAD) {
const row = assertSingleRow(rows);
const subthreadPermissions = row.subthread_permissions;
if (!permissionLookup(subthreadPermissions, threadPermissions.KNOW_OF)) {
return null;
}
return {
type: messageTypes.CREATE_SUB_THREAD,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
childThreadID: row.content,
};
} else if (type === messageTypes.CHANGE_SETTINGS) {
const row = assertSingleRow(rows);
const content = JSON.parse(row.content);
const field = Object.keys(content)[0];
return {
type: messageTypes.CHANGE_SETTINGS,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
field,
value: content[field],
};
} else if (type === messageTypes.REMOVE_MEMBERS) {
const row = assertSingleRow(rows);
return {
type: messageTypes.REMOVE_MEMBERS,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
removedUserIDs: JSON.parse(row.content),
};
} else if (type === messageTypes.CHANGE_ROLE) {
const row = assertSingleRow(rows);
const content = JSON.parse(row.content);
return {
type: messageTypes.CHANGE_ROLE,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
userIDs: content.userIDs,
newRole: content.newRole,
};
} else if (type === messageTypes.LEAVE_THREAD) {
const row = assertSingleRow(rows);
return {
type: messageTypes.LEAVE_THREAD,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
};
} else if (type === messageTypes.JOIN_THREAD) {
const row = assertSingleRow(rows);
return {
type: messageTypes.JOIN_THREAD,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
};
} else if (type === messageTypes.CREATE_ENTRY) {
const row = assertSingleRow(rows);
const content = JSON.parse(row.content);
return {
type: messageTypes.CREATE_ENTRY,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
entryID: content.entryID,
date: content.date,
text: content.text,
};
} else if (type === messageTypes.EDIT_ENTRY) {
const row = assertSingleRow(rows);
const content = JSON.parse(row.content);
return {
type: messageTypes.EDIT_ENTRY,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
entryID: content.entryID,
date: content.date,
text: content.text,
};
} else if (type === messageTypes.DELETE_ENTRY) {
const row = assertSingleRow(rows);
const content = JSON.parse(row.content);
return {
type: messageTypes.DELETE_ENTRY,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
entryID: content.entryID,
date: content.date,
text: content.text,
};
} else if (type === messageTypes.RESTORE_ENTRY) {
const row = assertSingleRow(rows);
const content = JSON.parse(row.content);
return {
type: messageTypes.RESTORE_ENTRY,
id: row.id.toString(),
threadID: row.threadID.toString(),
time: row.time,
creatorID: row.creatorID.toString(),
entryID: content.entryID,
date: content.date,
text: content.text,
};
} else if (type === messageTypes.IMAGES || type === messageTypes.MULTIMEDIA) {
const media = rows.filter(row => row.uploadID).map(mediaFromRow);
const [row] = rows;
return createMediaMessageInfo({
threadID: row.threadID.toString(),
creatorID: row.creatorID.toString(),
media,
id: row.id.toString(),
localID: localIDFromCreationString(viewer, row.creation),
time: row.time,
});
} else {
invariant(false, `unrecognized messageType ${type}`);
}
}
const visibleExtractString = `$.${threadPermissions.VISIBLE}.value`;
async function fetchMessageInfos(
viewer: Viewer,
criteria: ThreadSelectionCriteria,
numberPerThread: number,
): Promise<FetchMessageInfosResult> {
const threadSelectionClause = threadSelectionCriteriaToSQLClause(criteria);
const truncationStatuses = {};
const viewerID = viewer.id;
const query = SQL`
SELECT * FROM (
SELECT x.id, x.content, x.time, x.type, x.user AS creatorID,
x.creation, u.username AS creator, x.subthread_permissions,
x.uploadID, x.uploadType, x.uploadSecret, x.uploadExtra,
@num := if(
@thread = x.thread,
if(@message = x.id, @num, @num + 1),
1
) AS number,
@message := x.id AS messageID,
@thread := x.thread AS threadID
FROM (SELECT @num := 0, @thread := '', @message := '') init
JOIN (
SELECT m.id, m.thread, m.user, m.content, m.time, m.type,
m.creation, stm.permissions AS subthread_permissions,
up.id AS uploadID, up.type AS uploadType, up.secret AS uploadSecret,
up.extra AS uploadExtra
FROM messages m
LEFT JOIN uploads up
ON m.type IN (${[messageTypes.IMAGES, messageTypes.MULTIMEDIA]})
AND JSON_CONTAINS(m.content, CAST(up.id as JSON), '$')
LEFT JOIN memberships mm
ON mm.thread = m.thread AND mm.user = ${viewerID}
LEFT JOIN memberships stm ON m.type = ${messageTypes.CREATE_SUB_THREAD}
AND stm.thread = m.content AND stm.user = ${viewerID}
WHERE JSON_EXTRACT(mm.permissions, ${visibleExtractString}) IS TRUE AND
`;
query.append(threadSelectionClause);
query.append(SQL`
ORDER BY m.thread, m.time DESC
) x
LEFT JOIN users u ON u.id = x.user
) y
WHERE y.number <= ${numberPerThread}
`);
const [result] = await dbQuery(query);
- const { userInfos, messages } = parseMessageSQLResult(result, viewer);
+ const { messages } = parseMessageSQLResult(result, viewer);
const rawMessageInfos = [];
const threadToMessageCount = new Map();
for (let message of messages) {
const { rawMessageInfo } = message;
rawMessageInfos.push(rawMessageInfo);
const { threadID } = rawMessageInfo;
const currentCountValue = threadToMessageCount.get(threadID);
const currentCount = currentCountValue ? currentCountValue : 0;
threadToMessageCount.set(threadID, currentCount + 1);
}
for (let [threadID, messageCount] of threadToMessageCount) {
// If there are fewer messages returned than the max for a given thread,
// then our result set includes all messages in the query range for that
// thread
truncationStatuses[threadID] =
messageCount < numberPerThread
? messageTruncationStatus.EXHAUSTIVE
: messageTruncationStatus.TRUNCATED;
}
for (let rawMessageInfo of rawMessageInfos) {
if (rawMessageInfo.type === messageTypes.CREATE_THREAD) {
// If a CREATE_THREAD message for a given thread is in the result set,
// then our result set includes all messages in the query range for that
// thread
truncationStatuses[rawMessageInfo.threadID] =
messageTruncationStatus.EXHAUSTIVE;
}
}
for (let threadID in criteria.threadCursors) {
const truncationStatus = truncationStatuses[threadID];
if (truncationStatus === null || truncationStatus === undefined) {
// If nothing was returned for a thread that was explicitly queried for,
// then our result set includes all messages in the query range for that
// thread
truncationStatuses[threadID] = messageTruncationStatus.EXHAUSTIVE;
} else if (truncationStatus === messageTruncationStatus.TRUNCATED) {
// If a cursor was specified for a given thread, then the result is
// guaranteed to be contiguous with what the client has, and as such the
// result should never be TRUNCATED
truncationStatuses[threadID] = messageTruncationStatus.UNCHANGED;
}
}
- const allUserInfos = await fetchAllUsers(rawMessageInfos, userInfos);
const shimmedRawMessageInfos = shimUnsupportedRawMessageInfos(
rawMessageInfos,
viewer.platformDetails,
);
return {
rawMessageInfos: shimmedRawMessageInfos,
truncationStatuses,
- userInfos: allUserInfos,
+ userInfos: {},
};
}
function threadSelectionCriteriaToSQLClause(criteria: ThreadSelectionCriteria) {
const conditions = [];
if (criteria.joinedThreads === true) {
conditions.push(SQL`mm.role != 0`);
}
if (criteria.threadCursors) {
for (let threadID in criteria.threadCursors) {
const cursor = criteria.threadCursors[threadID];
if (cursor) {
conditions.push(SQL`(m.thread = ${threadID} AND m.id < ${cursor})`);
} else {
conditions.push(SQL`m.thread = ${threadID}`);
}
}
}
if (conditions.length === 0) {
throw new ServerError('internal_error');
}
return mergeOrConditions(conditions);
}
function threadSelectionCriteriaToInitialTruncationStatuses(
criteria: ThreadSelectionCriteria,
defaultTruncationStatus: MessageTruncationStatus,
) {
const truncationStatuses = {};
if (criteria.threadCursors) {
for (let threadID in criteria.threadCursors) {
truncationStatuses[threadID] = defaultTruncationStatus;
}
}
return truncationStatuses;
}
async function fetchAllUsers(
rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
userInfos: UserInfos,
): Promise<UserInfos> {
const allAddedUserIDs = [];
for (let rawMessageInfo of rawMessageInfos) {
let newUsers = [];
if (rawMessageInfo.type === messageTypes.ADD_MEMBERS) {
newUsers = rawMessageInfo.addedUserIDs;
} else if (rawMessageInfo.type === messageTypes.CREATE_THREAD) {
newUsers = rawMessageInfo.initialThreadState.memberIDs;
}
for (let userID of newUsers) {
if (!userInfos[userID]) {
allAddedUserIDs.push(userID);
}
}
}
if (allAddedUserIDs.length === 0) {
return userInfos;
}
const newUserInfos = await fetchUserInfos(allAddedUserIDs);
// $FlowFixMe should be fixed in flow-bin@0.115 / react-native@0.63
return {
...userInfos,
...newUserInfos,
};
}
async function fetchMessageInfosSince(
viewer: Viewer,
criteria: ThreadSelectionCriteria,
currentAsOf: number,
maxNumberPerThread: number,
): Promise<FetchMessageInfosResult> {
const threadSelectionClause = threadSelectionCriteriaToSQLClause(criteria);
const truncationStatuses = threadSelectionCriteriaToInitialTruncationStatuses(
criteria,
messageTruncationStatus.UNCHANGED,
);
const viewerID = viewer.id;
const query = SQL`
SELECT m.id, m.thread AS threadID, m.content, m.time, m.type,
m.creation, u.username AS creator, m.user AS creatorID,
stm.permissions AS subthread_permissions,
up.id AS uploadID, up.type AS uploadType, up.secret AS uploadSecret,
up.extra AS uploadExtra
FROM messages m
LEFT JOIN uploads up
ON m.type IN (${[messageTypes.IMAGES, messageTypes.MULTIMEDIA]})
AND JSON_CONTAINS(m.content, CAST(up.id as JSON), '$')
LEFT JOIN memberships mm ON mm.thread = m.thread AND mm.user = ${viewerID}
LEFT JOIN memberships stm ON m.type = ${messageTypes.CREATE_SUB_THREAD}
AND stm.thread = m.content AND stm.user = ${viewerID}
LEFT JOIN users u ON u.id = m.user
WHERE m.time > ${currentAsOf} AND
JSON_EXTRACT(mm.permissions, ${visibleExtractString}) IS TRUE AND
`;
query.append(threadSelectionClause);
query.append(SQL`
ORDER BY m.thread, m.time DESC
`);
const [result] = await dbQuery(query);
const { userInfos: allCreatorUserInfos, messages } = parseMessageSQLResult(
result,
viewer,
);
const rawMessageInfos = [];
const userInfos = {};
let currentThreadID = null;
let numMessagesForCurrentThreadID = 0;
for (let message of messages) {
const { rawMessageInfo } = message;
const { threadID } = rawMessageInfo;
if (threadID !== currentThreadID) {
currentThreadID = threadID;
numMessagesForCurrentThreadID = 1;
truncationStatuses[threadID] = messageTruncationStatus.UNCHANGED;
} else {
numMessagesForCurrentThreadID++;
}
if (numMessagesForCurrentThreadID <= maxNumberPerThread) {
if (rawMessageInfo.type === messageTypes.CREATE_THREAD) {
// If a CREATE_THREAD message is here, then we have all messages
truncationStatuses[threadID] = messageTruncationStatus.EXHAUSTIVE;
}
const { creatorID } = rawMessageInfo;
const userInfo = allCreatorUserInfos[creatorID];
if (userInfo) {
userInfos[creatorID] = userInfo;
}
rawMessageInfos.push(rawMessageInfo);
} else if (numMessagesForCurrentThreadID === maxNumberPerThread + 1) {
truncationStatuses[threadID] = messageTruncationStatus.TRUNCATED;
}
}
const allUserInfos = await fetchAllUsers(rawMessageInfos, userInfos);
const shimmedRawMessageInfos = shimUnsupportedRawMessageInfos(
rawMessageInfos,
viewer.platformDetails,
);
return {
rawMessageInfos: shimmedRawMessageInfos,
truncationStatuses,
userInfos: allUserInfos,
};
}
async function getMessageFetchResultFromRedisMessages(
viewer: Viewer,
rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
): Promise<FetchMessageInfosResult> {
const truncationStatuses = {};
for (let rawMessageInfo of rawMessageInfos) {
truncationStatuses[rawMessageInfo.threadID] =
messageTruncationStatus.UNCHANGED;
}
const userInfos = await fetchAllUsers(rawMessageInfos, {});
const shimmedRawMessageInfos = shimUnsupportedRawMessageInfos(
rawMessageInfos,
viewer.platformDetails,
);
return {
rawMessageInfos: shimmedRawMessageInfos,
truncationStatuses,
userInfos,
};
}
async function fetchMessageInfoForLocalID(
viewer: Viewer,
localID: ?string,
): Promise<?RawMessageInfo> {
if (!localID || !viewer.hasSessionInfo) {
return null;
}
const creation = creationString(viewer, localID);
const viewerID = viewer.id;
const query = SQL`
SELECT m.id, m.thread AS threadID, m.content, m.time, m.type, m.creation,
m.user AS creatorID, stm.permissions AS subthread_permissions,
up.id AS uploadID, up.type AS uploadType, up.secret AS uploadSecret,
up.extra AS uploadExtra
FROM messages m
LEFT JOIN uploads up
ON m.type IN (${[messageTypes.IMAGES, messageTypes.MULTIMEDIA]})
AND JSON_CONTAINS(m.content, CAST(up.id as JSON), '$')
LEFT JOIN memberships mm ON mm.thread = m.thread AND mm.user = ${viewerID}
LEFT JOIN memberships stm ON m.type = ${messageTypes.CREATE_SUB_THREAD}
AND stm.thread = m.content AND stm.user = ${viewerID}
WHERE m.user = ${viewerID} AND m.creation = ${creation} AND
JSON_EXTRACT(mm.permissions, ${visibleExtractString}) IS TRUE
`;
const [result] = await dbQuery(query);
if (result.length === 0) {
return null;
}
return rawMessageInfoFromRows(result, viewer);
}
const entryIDExtractString = '$.entryID';
async function fetchMessageInfoForEntryAction(
viewer: Viewer,
messageType: MessageType,
entryID: string,
threadID: string,
): Promise<?RawMessageInfo> {
const viewerID = viewer.id;
const query = SQL`
SELECT m.id, m.thread AS threadID, m.content, m.time, m.type, m.creation,
m.user AS creatorID, up.id AS uploadID, up.type AS uploadType,
up.secret AS uploadSecret, up.extra AS uploadExtra
FROM messages m
LEFT JOIN uploads up
ON m.type IN (${[messageTypes.IMAGES, messageTypes.MULTIMEDIA]})
AND JSON_CONTAINS(m.content, CAST(up.id as JSON), '$')
LEFT JOIN memberships mm ON mm.thread = m.thread AND mm.user = ${viewerID}
WHERE m.user = ${viewerID} AND m.thread = ${threadID} AND
m.type = ${messageType} AND
JSON_EXTRACT(m.content, ${entryIDExtractString}) = ${entryID} AND
JSON_EXTRACT(mm.permissions, ${visibleExtractString}) IS TRUE
`;
const [result] = await dbQuery(query);
if (result.length === 0) {
return null;
}
return rawMessageInfoFromRows(result, viewer);
}
export {
fetchCollapsableNotifs,
fetchMessageInfos,
fetchMessageInfosSince,
getMessageFetchResultFromRedisMessages,
fetchMessageInfoForLocalID,
fetchMessageInfoForEntryAction,
};
diff --git a/server/src/responders/entry-responders.js b/server/src/responders/entry-responders.js
index 8e6613f13..96f020e73 100644
--- a/server/src/responders/entry-responders.js
+++ b/server/src/responders/entry-responders.js
@@ -1,258 +1,258 @@
// @flow
import type { Viewer } from '../session/viewer';
import type {
CalendarQuery,
SaveEntryRequest,
CreateEntryRequest,
DeleteEntryRequest,
DeleteEntryResponse,
RestoreEntryRequest,
RestoreEntryResponse,
FetchEntryInfosResponse,
DeltaEntryInfosResult,
SaveEntryResponse,
} from 'lib/types/entry-types';
import type {
FetchEntryRevisionInfosResult,
FetchEntryRevisionInfosRequest,
} from 'lib/types/history-types';
import { calendarThreadFilterTypes } from 'lib/types/filter-types';
import t from 'tcomb';
import { ServerError } from 'lib/utils/errors';
import { filteredThreadIDs } from 'lib/selectors/calendar-filter-selectors';
-import { values } from 'lib/utils/objects';
import {
validateInput,
tString,
tShape,
tDate,
} from '../utils/validation-utils';
import { verifyThreadIDs } from '../fetchers/thread-fetchers';
import {
fetchEntryInfos,
fetchEntryRevisionInfo,
fetchEntriesForSession,
} from '../fetchers/entry-fetchers';
import createEntry from '../creators/entry-creator';
import {
updateEntry,
compareNewCalendarQuery,
} from '../updaters/entry-updaters';
import { deleteEntry, restoreEntry } from '../deleters/entry-deleters';
import { commitSessionUpdate } from '../updaters/session-updaters';
const entryQueryInputValidator = tShape({
navID: t.maybe(t.String),
startDate: tDate,
endDate: tDate,
includeDeleted: t.maybe(t.Boolean),
filters: t.maybe(
t.list(
t.union([
tShape({
type: tString(calendarThreadFilterTypes.NOT_DELETED),
}),
tShape({
type: tString(calendarThreadFilterTypes.THREAD_LIST),
threadIDs: t.list(t.String),
}),
]),
),
),
});
const newEntryQueryInputValidator = tShape({
startDate: tDate,
endDate: tDate,
filters: t.list(
t.union([
tShape({
type: tString(calendarThreadFilterTypes.NOT_DELETED),
}),
tShape({
type: tString(calendarThreadFilterTypes.THREAD_LIST),
threadIDs: t.list(t.String),
}),
]),
),
});
function normalizeCalendarQuery(input: any): CalendarQuery {
if (input.filters) {
return {
startDate: input.startDate,
endDate: input.endDate,
filters: input.filters,
};
}
const filters = [];
if (!input.includeDeleted) {
filters.push({ type: calendarThreadFilterTypes.NOT_DELETED });
}
if (input.navID !== 'home') {
filters.push({
type: calendarThreadFilterTypes.THREAD_LIST,
threadIDs: [input.navID],
});
}
return {
startDate: input.startDate,
endDate: input.endDate,
filters,
};
}
async function verifyCalendarQueryThreadIDs(
request: CalendarQuery,
): Promise<void> {
const threadIDsToFilterTo = filteredThreadIDs(request.filters);
if (threadIDsToFilterTo && threadIDsToFilterTo.size > 0) {
const verifiedThreadIDs = await verifyThreadIDs([...threadIDsToFilterTo]);
if (verifiedThreadIDs.length !== threadIDsToFilterTo.size) {
throw new ServerError('invalid_parameters');
}
}
}
async function entryFetchResponder(
viewer: Viewer,
input: any,
): Promise<FetchEntryInfosResponse> {
await validateInput(viewer, entryQueryInputValidator, input);
const request = normalizeCalendarQuery(input);
await verifyCalendarQueryThreadIDs(request);
return await fetchEntryInfos(viewer, [request]);
}
const entryRevisionHistoryFetchInputValidator = tShape({
id: t.String,
});
async function entryRevisionFetchResponder(
viewer: Viewer,
input: any,
): Promise<FetchEntryRevisionInfosResult> {
const request: FetchEntryRevisionInfosRequest = input;
await validateInput(viewer, entryRevisionHistoryFetchInputValidator, request);
const entryHistory = await fetchEntryRevisionInfo(viewer, request.id);
return { result: entryHistory };
}
const createEntryRequestInputValidator = tShape({
text: t.String,
sessionID: t.maybe(t.String),
timestamp: t.Number,
date: tDate,
threadID: t.String,
localID: t.maybe(t.String),
calendarQuery: t.maybe(newEntryQueryInputValidator),
});
async function entryCreationResponder(
viewer: Viewer,
input: any,
): Promise<SaveEntryResponse> {
const request: CreateEntryRequest = input;
await validateInput(viewer, createEntryRequestInputValidator, request);
return await createEntry(viewer, request);
}
const saveEntryRequestInputValidator = tShape({
entryID: t.String,
text: t.String,
prevText: t.String,
sessionID: t.maybe(t.String),
timestamp: t.Number,
calendarQuery: t.maybe(newEntryQueryInputValidator),
});
async function entryUpdateResponder(
viewer: Viewer,
input: any,
): Promise<SaveEntryResponse> {
const request: SaveEntryRequest = input;
await validateInput(viewer, saveEntryRequestInputValidator, request);
return await updateEntry(viewer, request);
}
const deleteEntryRequestInputValidator = tShape({
entryID: t.String,
prevText: t.String,
sessionID: t.maybe(t.String),
timestamp: t.Number,
calendarQuery: t.maybe(newEntryQueryInputValidator),
});
async function entryDeletionResponder(
viewer: Viewer,
input: any,
): Promise<DeleteEntryResponse> {
const request: DeleteEntryRequest = input;
await validateInput(viewer, deleteEntryRequestInputValidator, request);
return await deleteEntry(viewer, request);
}
const restoreEntryRequestInputValidator = tShape({
entryID: t.String,
sessionID: t.maybe(t.String),
timestamp: t.Number,
calendarQuery: t.maybe(newEntryQueryInputValidator),
});
async function entryRestorationResponder(
viewer: Viewer,
input: any,
): Promise<RestoreEntryResponse> {
const request: RestoreEntryRequest = input;
await validateInput(viewer, restoreEntryRequestInputValidator, request);
return await restoreEntry(viewer, request);
}
async function calendarQueryUpdateResponder(
viewer: Viewer,
input: any,
): Promise<DeltaEntryInfosResult> {
const request: CalendarQuery = input;
await validateInput(viewer, newEntryQueryInputValidator, input);
await verifyCalendarQueryThreadIDs(request);
if (!viewer.loggedIn) {
throw new ServerError('not_logged_in');
}
const {
difference,
oldCalendarQuery,
sessionUpdate,
} = compareNewCalendarQuery(viewer, request);
const [response] = await Promise.all([
fetchEntriesForSession(viewer, difference, oldCalendarQuery),
commitSessionUpdate(viewer, sessionUpdate),
]);
return {
rawEntryInfos: response.rawEntryInfos,
deletedEntryIDs: response.deletedEntryIDs,
- userInfos: values(response.userInfos),
+ // Old clients expect userInfos object
+ userInfos: [],
};
}
export {
entryQueryInputValidator,
newEntryQueryInputValidator,
normalizeCalendarQuery,
verifyCalendarQueryThreadIDs,
entryFetchResponder,
entryRevisionFetchResponder,
entryCreationResponder,
entryUpdateResponder,
entryDeletionResponder,
entryRestorationResponder,
calendarQueryUpdateResponder,
};

File Metadata

Mime Type
text/x-diff
Expires
Mon, Dec 23, 4:44 AM (17 h, 22 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2690366
Default Alt Text
(152 KB)

Event Timeline