moon
/
soapbox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'ts' into 'develop' 

Actions: TypeScript

See merge request soapbox-pub/soapbox-fe!1534
This commit is contained in:
marcin mikołajczak 2022-06-21 19:09:44 +00:00
parent e5d6b4fd7b a16230780e
commit 31a73224a9
174 changed files with 8601 additions and 7671 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
app/soapbox/actions/__tests__/account-notes.test.ts
View File

@ -1,3 +1,5 @@
import { Map as ImmutableMap } from 'immutable';
import { __stub } from 'soapbox/api';
import { mockStore } from 'soapbox/jest/test-helpers';
import rootReducer from 'soapbox/reducers';
@ -10,7 +12,7 @@ describe('submitAccountNote()', () => {
beforeEach(() => {
const state = rootReducer(undefined, {})
.set('account_notes', { edit: { account_id: 1, comment: 'hello' } });
.set('account_notes', { edit: { account: 1, comment: 'hello' } });
store = mockStore(state);
});
@ -62,7 +64,7 @@ describe('initAccountNoteModal()', () => {
beforeEach(() => {
const state = rootReducer(undefined, {})
.set('relationships', { 1: { note: 'hello' } });
.set('relationships', ImmutableMap({ 1: { note: 'hello' } }));
store = mockStore(state);
});

6
app/soapbox/actions/__tests__/blocks.test.ts
View File

@ -1,3 +1,5 @@
import { Map as ImmutableMap } from 'immutable';
import { __stub } from 'soapbox/api';
import { mockStore } from 'soapbox/jest/test-helpers';
import rootReducer from 'soapbox/reducers';
@ -111,7 +113,7 @@ describe('expandBlocks()', () => {
beforeEach(() => {
const state = rootReducer(undefined, {})
.set('me', '1234')
.set('user_lists', { blocks: { next: null } });
.set('user_lists', ImmutableMap({ blocks: { next: null } }));
store = mockStore(state);
});
@ -127,7 +129,7 @@ describe('expandBlocks()', () => {
beforeEach(() => {
const state = rootReducer(undefined, {})
.set('me', '1234')
.set('user_lists', { blocks: { next: 'example' } });
.set('user_lists', ImmutableMap({ blocks: { next: 'example' } }));
store = mockStore(state);
});

10
app/soapbox/actions/__tests__/compose.test.ts
View File

@ -1,3 +1,5 @@
import { fromJS } from 'immutable';
import { mockStore } from 'soapbox/jest/test-helpers';
import { InstanceRecord } from 'soapbox/normalizers';
import rootReducer from 'soapbox/reducers';
@ -10,14 +12,14 @@ describe('uploadCompose()', () => {
beforeEach(() => {
const instance = InstanceRecord({
configuration: {
configuration: fromJS({
statuses: {
max_media_attachments: 4,
},
media_attachments: {
image_size_limit: 10,
},
},
}),
});
const state = rootReducer(undefined, {})
@ -62,14 +64,14 @@ describe('uploadCompose()', () => {
beforeEach(() => {
const instance = InstanceRecord({
configuration: {
configuration: fromJS({
statuses: {
max_media_attachments: 4,
},
media_attachments: {
video_size_limit: 10,
},
},
}),
});
const state = rootReducer(undefined, {})

8
app/soapbox/actions/__tests__/statuses.test.ts
View File

@ -40,7 +40,7 @@ describe('deleteStatus()', () => {
});
it('should do nothing', async() => {
await store.dispatch(deleteStatus('1', {}));
await store.dispatch(deleteStatus('1'));
const actions = store.getActions();
expect(actions).toEqual([]);
@ -88,7 +88,7 @@ describe('deleteStatus()', () => {
reblogOf: null,
},
];
await store.dispatch(deleteStatus(statusId, {}));
await store.dispatch(deleteStatus(statusId));
const actions = store.getActions();
expect(actions).toEqual(expectedActions);
@ -125,7 +125,7 @@ describe('deleteStatus()', () => {
},
{ type: 'MODAL_OPEN', modalType: 'COMPOSE', modalProps: undefined },
];
await store.dispatch(deleteStatus(statusId, {}, true));
await store.dispatch(deleteStatus(statusId, true));
const actions = store.getActions();
expect(actions).toEqual(expectedActions);
@ -151,7 +151,7 @@ describe('deleteStatus()', () => {
error: new Error('Network Error'),
},
];
await store.dispatch(deleteStatus(statusId, {}, true));
await store.dispatch(deleteStatus(statusId, true));
const actions = store.getActions();
expect(actions).toEqual(expectedActions);

2
app/soapbox/actions/about.ts
View File

@ -6,7 +6,7 @@ const FETCH_ABOUT_PAGE_REQUEST = 'FETCH_ABOUT_PAGE_REQUEST';
const FETCH_ABOUT_PAGE_SUCCESS = 'FETCH_ABOUT_PAGE_SUCCESS';
const FETCH_ABOUT_PAGE_FAIL = 'FETCH_ABOUT_PAGE_FAIL';
const fetchAboutPage = (slug = 'index', locale?: string) => (dispatch: React.Dispatch<AnyAction>, getState: any) => {
const fetchAboutPage = (slug = 'index', locale?: string) => (dispatch: React.Dispatch<AnyAction>) => {
dispatch({ type: FETCH_ABOUT_PAGE_REQUEST, slug, locale });
const filename = `${slug}${locale ? `.${locale}` : ''}.html`;

11
app/soapbox/actions/account-notes.ts
View File

@ -4,6 +4,7 @@ import { openModal, closeModal } from './modals';
import type { AxiosError } from 'axios';
import type { AnyAction } from 'redux';
import type { RootState } from 'soapbox/store';
import type { Account } from 'soapbox/types/entities';
const ACCOUNT_NOTE_SUBMIT_REQUEST = 'ACCOUNT_NOTE_SUBMIT_REQUEST';
@ -14,14 +15,14 @@ const ACCOUNT_NOTE_INIT_MODAL = 'ACCOUNT_NOTE_INIT_MODAL';
const ACCOUNT_NOTE_CHANGE_COMMENT = 'ACCOUNT_NOTE_CHANGE_COMMENT';
const submitAccountNote = () => (dispatch: React.Dispatch<AnyAction>, getState: any) => {
const submitAccountNote = () => (dispatch: React.Dispatch<AnyAction>, getState: () => RootState) => {
dispatch(submitAccountNoteRequest());
const id = getState().getIn(['account_notes', 'edit', 'account_id']);
const id = getState().account_notes.edit.account;
return api(getState)
.post(`/api/v1/accounts/${id}/note`, {
comment: getState().getIn(['account_notes', 'edit', 'comment']),
comment: getState().account_notes.edit.comment,
})
.then(response => {
dispatch(closeModal());
@ -50,8 +51,8 @@ function submitAccountNoteFail(error: AxiosError) {
};
}
const initAccountNoteModal = (account: Account) => (dispatch: React.Dispatch<AnyAction>, getState: any) => {
const comment = getState().getIn(['relationships', account.get('id'), 'note']);
const initAccountNoteModal = (account: Account) => (dispatch: React.Dispatch<AnyAction>, getState: () => RootState) => {
const comment = getState().relationships.get(account.id)!.note;
dispatch({
type: ACCOUNT_NOTE_INIT_MODAL,

1099
app/soapbox/actions/accounts.js
View File

File diff suppressed because it is too large Load Diff

1124
app/soapbox/actions/accounts.ts Normal file
View File

File diff suppressed because it is too large Load Diff

446
app/soapbox/actions/admin.js → app/soapbox/actions/admin.ts
View File

@ -4,78 +4,82 @@ import { getFeatures } from 'soapbox/utils/features';
import api, { getLinks } from '../api';
export const ADMIN_CONFIG_FETCH_REQUEST = 'ADMIN_CONFIG_FETCH_REQUEST';
export const ADMIN_CONFIG_FETCH_SUCCESS = 'ADMIN_CONFIG_FETCH_SUCCESS';
export const ADMIN_CONFIG_FETCH_FAIL = 'ADMIN_CONFIG_FETCH_FAIL';
import type { AxiosResponse } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
export const ADMIN_CONFIG_UPDATE_REQUEST = 'ADMIN_CONFIG_UPDATE_REQUEST';
export const ADMIN_CONFIG_UPDATE_SUCCESS = 'ADMIN_CONFIG_UPDATE_SUCCESS';
export const ADMIN_CONFIG_UPDATE_FAIL = 'ADMIN_CONFIG_UPDATE_FAIL';
const ADMIN_CONFIG_FETCH_REQUEST = 'ADMIN_CONFIG_FETCH_REQUEST';
const ADMIN_CONFIG_FETCH_SUCCESS = 'ADMIN_CONFIG_FETCH_SUCCESS';
const ADMIN_CONFIG_FETCH_FAIL = 'ADMIN_CONFIG_FETCH_FAIL';
export const ADMIN_REPORTS_FETCH_REQUEST = 'ADMIN_REPORTS_FETCH_REQUEST';
export const ADMIN_REPORTS_FETCH_SUCCESS = 'ADMIN_REPORTS_FETCH_SUCCESS';
export const ADMIN_REPORTS_FETCH_FAIL = 'ADMIN_REPORTS_FETCH_FAIL';
const ADMIN_CONFIG_UPDATE_REQUEST = 'ADMIN_CONFIG_UPDATE_REQUEST';
const ADMIN_CONFIG_UPDATE_SUCCESS = 'ADMIN_CONFIG_UPDATE_SUCCESS';
const ADMIN_CONFIG_UPDATE_FAIL = 'ADMIN_CONFIG_UPDATE_FAIL';
export const ADMIN_REPORTS_PATCH_REQUEST = 'ADMIN_REPORTS_PATCH_REQUEST';
export const ADMIN_REPORTS_PATCH_SUCCESS = 'ADMIN_REPORTS_PATCH_SUCCESS';
export const ADMIN_REPORTS_PATCH_FAIL = 'ADMIN_REPORTS_PATCH_FAIL';
const ADMIN_REPORTS_FETCH_REQUEST = 'ADMIN_REPORTS_FETCH_REQUEST';
const ADMIN_REPORTS_FETCH_SUCCESS = 'ADMIN_REPORTS_FETCH_SUCCESS';
const ADMIN_REPORTS_FETCH_FAIL = 'ADMIN_REPORTS_FETCH_FAIL';
export const ADMIN_USERS_FETCH_REQUEST = 'ADMIN_USERS_FETCH_REQUEST';
export const ADMIN_USERS_FETCH_SUCCESS = 'ADMIN_USERS_FETCH_SUCCESS';
export const ADMIN_USERS_FETCH_FAIL = 'ADMIN_USERS_FETCH_FAIL';
const ADMIN_REPORTS_PATCH_REQUEST = 'ADMIN_REPORTS_PATCH_REQUEST';
const ADMIN_REPORTS_PATCH_SUCCESS = 'ADMIN_REPORTS_PATCH_SUCCESS';
const ADMIN_REPORTS_PATCH_FAIL = 'ADMIN_REPORTS_PATCH_FAIL';
export const ADMIN_USERS_DELETE_REQUEST = 'ADMIN_USERS_DELETE_REQUEST';
export const ADMIN_USERS_DELETE_SUCCESS = 'ADMIN_USERS_DELETE_SUCCESS';
export const ADMIN_USERS_DELETE_FAIL = 'ADMIN_USERS_DELETE_FAIL';
const ADMIN_USERS_FETCH_REQUEST = 'ADMIN_USERS_FETCH_REQUEST';
const ADMIN_USERS_FETCH_SUCCESS = 'ADMIN_USERS_FETCH_SUCCESS';
const ADMIN_USERS_FETCH_FAIL = 'ADMIN_USERS_FETCH_FAIL';
export const ADMIN_USERS_APPROVE_REQUEST = 'ADMIN_USERS_APPROVE_REQUEST';
export const ADMIN_USERS_APPROVE_SUCCESS = 'ADMIN_USERS_APPROVE_SUCCESS';
export const ADMIN_USERS_APPROVE_FAIL = 'ADMIN_USERS_APPROVE_FAIL';
const ADMIN_USERS_DELETE_REQUEST = 'ADMIN_USERS_DELETE_REQUEST';
const ADMIN_USERS_DELETE_SUCCESS = 'ADMIN_USERS_DELETE_SUCCESS';
const ADMIN_USERS_DELETE_FAIL = 'ADMIN_USERS_DELETE_FAIL';
export const ADMIN_USERS_DEACTIVATE_REQUEST = 'ADMIN_USERS_DEACTIVATE_REQUEST';
export const ADMIN_USERS_DEACTIVATE_SUCCESS = 'ADMIN_USERS_DEACTIVATE_SUCCESS';
export const ADMIN_USERS_DEACTIVATE_FAIL = 'ADMIN_USERS_DEACTIVATE_FAIL';
const ADMIN_USERS_APPROVE_REQUEST = 'ADMIN_USERS_APPROVE_REQUEST';
const ADMIN_USERS_APPROVE_SUCCESS = 'ADMIN_USERS_APPROVE_SUCCESS';
const ADMIN_USERS_APPROVE_FAIL = 'ADMIN_USERS_APPROVE_FAIL';
export const ADMIN_STATUS_DELETE_REQUEST = 'ADMIN_STATUS_DELETE_REQUEST';
export const ADMIN_STATUS_DELETE_SUCCESS = 'ADMIN_STATUS_DELETE_SUCCESS';
export const ADMIN_STATUS_DELETE_FAIL = 'ADMIN_STATUS_DELETE_FAIL';
const ADMIN_USERS_DEACTIVATE_REQUEST = 'ADMIN_USERS_DEACTIVATE_REQUEST';
const ADMIN_USERS_DEACTIVATE_SUCCESS = 'ADMIN_USERS_DEACTIVATE_SUCCESS';
const ADMIN_USERS_DEACTIVATE_FAIL = 'ADMIN_USERS_DEACTIVATE_FAIL';
export const ADMIN_STATUS_TOGGLE_SENSITIVITY_REQUEST = 'ADMIN_STATUS_TOGGLE_SENSITIVITY_REQUEST';
export const ADMIN_STATUS_TOGGLE_SENSITIVITY_SUCCESS = 'ADMIN_STATUS_TOGGLE_SENSITIVITY_SUCCESS';
export const ADMIN_STATUS_TOGGLE_SENSITIVITY_FAIL = 'ADMIN_STATUS_TOGGLE_SENSITIVITY_FAIL';
const ADMIN_STATUS_DELETE_REQUEST = 'ADMIN_STATUS_DELETE_REQUEST';
const ADMIN_STATUS_DELETE_SUCCESS = 'ADMIN_STATUS_DELETE_SUCCESS';
const ADMIN_STATUS_DELETE_FAIL = 'ADMIN_STATUS_DELETE_FAIL';
export const ADMIN_LOG_FETCH_REQUEST = 'ADMIN_LOG_FETCH_REQUEST';
export const ADMIN_LOG_FETCH_SUCCESS = 'ADMIN_LOG_FETCH_SUCCESS';
export const ADMIN_LOG_FETCH_FAIL = 'ADMIN_LOG_FETCH_FAIL';
const ADMIN_STATUS_TOGGLE_SENSITIVITY_REQUEST = 'ADMIN_STATUS_TOGGLE_SENSITIVITY_REQUEST';
const ADMIN_STATUS_TOGGLE_SENSITIVITY_SUCCESS = 'ADMIN_STATUS_TOGGLE_SENSITIVITY_SUCCESS';
const ADMIN_STATUS_TOGGLE_SENSITIVITY_FAIL = 'ADMIN_STATUS_TOGGLE_SENSITIVITY_FAIL';
export const ADMIN_USERS_TAG_REQUEST = 'ADMIN_USERS_TAG_REQUEST';
export const ADMIN_USERS_TAG_SUCCESS = 'ADMIN_USERS_TAG_SUCCESS';
export const ADMIN_USERS_TAG_FAIL = 'ADMIN_USERS_TAG_FAIL';
const ADMIN_LOG_FETCH_REQUEST = 'ADMIN_LOG_FETCH_REQUEST';
const ADMIN_LOG_FETCH_SUCCESS = 'ADMIN_LOG_FETCH_SUCCESS';
const ADMIN_LOG_FETCH_FAIL = 'ADMIN_LOG_FETCH_FAIL';
export const ADMIN_USERS_UNTAG_REQUEST = 'ADMIN_USERS_UNTAG_REQUEST';
export const ADMIN_USERS_UNTAG_SUCCESS = 'ADMIN_USERS_UNTAG_SUCCESS';
export const ADMIN_USERS_UNTAG_FAIL = 'ADMIN_USERS_UNTAG_FAIL';
const ADMIN_USERS_TAG_REQUEST = 'ADMIN_USERS_TAG_REQUEST';
const ADMIN_USERS_TAG_SUCCESS = 'ADMIN_USERS_TAG_SUCCESS';
const ADMIN_USERS_TAG_FAIL = 'ADMIN_USERS_TAG_FAIL';
export const ADMIN_ADD_PERMISSION_GROUP_REQUEST = 'ADMIN_ADD_PERMISSION_GROUP_REQUEST';
export const ADMIN_ADD_PERMISSION_GROUP_SUCCESS = 'ADMIN_ADD_PERMISSION_GROUP_SUCCESS';
export const ADMIN_ADD_PERMISSION_GROUP_FAIL = 'ADMIN_ADD_PERMISSION_GROUP_FAIL';
const ADMIN_USERS_UNTAG_REQUEST = 'ADMIN_USERS_UNTAG_REQUEST';
const ADMIN_USERS_UNTAG_SUCCESS = 'ADMIN_USERS_UNTAG_SUCCESS';
const ADMIN_USERS_UNTAG_FAIL = 'ADMIN_USERS_UNTAG_FAIL';
export const ADMIN_REMOVE_PERMISSION_GROUP_REQUEST = 'ADMIN_REMOVE_PERMISSION_GROUP_REQUEST';
export const ADMIN_REMOVE_PERMISSION_GROUP_SUCCESS = 'ADMIN_REMOVE_PERMISSION_GROUP_SUCCESS';
export const ADMIN_REMOVE_PERMISSION_GROUP_FAIL = 'ADMIN_REMOVE_PERMISSION_GROUP_FAIL';
const ADMIN_ADD_PERMISSION_GROUP_REQUEST = 'ADMIN_ADD_PERMISSION_GROUP_REQUEST';
const ADMIN_ADD_PERMISSION_GROUP_SUCCESS = 'ADMIN_ADD_PERMISSION_GROUP_SUCCESS';
const ADMIN_ADD_PERMISSION_GROUP_FAIL = 'ADMIN_ADD_PERMISSION_GROUP_FAIL';
export const ADMIN_USERS_SUGGEST_REQUEST = 'ADMIN_USERS_SUGGEST_REQUEST';
export const ADMIN_USERS_SUGGEST_SUCCESS = 'ADMIN_USERS_SUGGEST_SUCCESS';
export const ADMIN_USERS_SUGGEST_FAIL = 'ADMIN_USERS_SUGGEST_FAIL';
const ADMIN_REMOVE_PERMISSION_GROUP_REQUEST = 'ADMIN_REMOVE_PERMISSION_GROUP_REQUEST';
const ADMIN_REMOVE_PERMISSION_GROUP_SUCCESS = 'ADMIN_REMOVE_PERMISSION_GROUP_SUCCESS';
const ADMIN_REMOVE_PERMISSION_GROUP_FAIL = 'ADMIN_REMOVE_PERMISSION_GROUP_FAIL';
export const ADMIN_USERS_UNSUGGEST_REQUEST = 'ADMIN_USERS_UNSUGGEST_REQUEST';
export const ADMIN_USERS_UNSUGGEST_SUCCESS = 'ADMIN_USERS_UNSUGGEST_SUCCESS';
export const ADMIN_USERS_UNSUGGEST_FAIL = 'ADMIN_USERS_UNSUGGEST_FAIL';
const ADMIN_USERS_SUGGEST_REQUEST = 'ADMIN_USERS_SUGGEST_REQUEST';
const ADMIN_USERS_SUGGEST_SUCCESS = 'ADMIN_USERS_SUGGEST_SUCCESS';
const ADMIN_USERS_SUGGEST_FAIL = 'ADMIN_USERS_SUGGEST_FAIL';
const nicknamesFromIds = (getState, ids) => ids.map(id => getState().getIn(['accounts', id, 'acct']));
const ADMIN_USERS_UNSUGGEST_REQUEST = 'ADMIN_USERS_UNSUGGEST_REQUEST';
const ADMIN_USERS_UNSUGGEST_SUCCESS = 'ADMIN_USERS_UNSUGGEST_SUCCESS';
const ADMIN_USERS_UNSUGGEST_FAIL = 'ADMIN_USERS_UNSUGGEST_FAIL';
export function fetchConfig() {
return (dispatch, getState) => {
const nicknamesFromIds = (getState: () => RootState, ids: string[]) => ids.map(id => getState().accounts.get(id)!.acct);
const fetchConfig = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: ADMIN_CONFIG_FETCH_REQUEST });
return api(getState)
.get('/api/pleroma/admin/config')
@ -85,10 +89,9 @@ export function fetchConfig() {
dispatch({ type: ADMIN_CONFIG_FETCH_FAIL, error });
});
};
}
export function updateConfig(configs) {
return (dispatch, getState) => {
const updateConfig = (configs: Record<string, any>[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: ADMIN_CONFIG_UPDATE_REQUEST, configs });
return api(getState)
.post('/api/pleroma/admin/config', { configs })
@ -98,14 +101,13 @@ export function updateConfig(configs) {
dispatch({ type: ADMIN_CONFIG_UPDATE_FAIL, error, configs });
});
};
}
function fetchMastodonReports(params) {
return (dispatch, getState) => {
return api(getState)
const fetchMastodonReports = (params: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) =>
api(getState)
.get('/api/v1/admin/reports', { params })
.then(({ data: reports }) => {
reports.forEach(report => {
reports.forEach((report: APIEntity) => {
dispatch(importFetchedAccount(report.account?.account));
dispatch(importFetchedAccount(report.target_account?.account));
dispatch(importFetchedStatuses(report.statuses));
@ -114,15 +116,13 @@ function fetchMastodonReports(params) {
}).catch(error => {
dispatch({ type: ADMIN_REPORTS_FETCH_FAIL, error, params });
});
};
}
function fetchPleromaReports(params) {
return (dispatch, getState) => {
return api(getState)
const fetchPleromaReports = (params: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) =>
api(getState)
.get('/api/pleroma/admin/reports', { params })
.then(({ data: { reports } }) => {
reports.forEach(report => {
reports.forEach((report: APIEntity) => {
dispatch(importFetchedAccount(report.account));
dispatch(importFetchedAccount(report.actor));
dispatch(importFetchedStatuses(report.statuses));
@ -131,19 +131,17 @@ function fetchPleromaReports(params) {
}).catch(error => {
dispatch({ type: ADMIN_REPORTS_FETCH_FAIL, error, params });
});
};
}
export function fetchReports(params = {}) {
return (dispatch, getState) => {
const fetchReports = (params: Record<string, any> = {}) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const instance = state.get('instance');
const instance = state.instance;
const features = getFeatures(instance);
dispatch({ type: ADMIN_REPORTS_FETCH_REQUEST, params });
if (features.mastodonAdmi) {
if (features.mastodonAdmin) {
return dispatch(fetchMastodonReports(params));
} else {
const { resolved } = params;
@ -153,11 +151,10 @@ export function fetchReports(params = {}) {
}));
}
};
}
function patchMastodonReports(reports) {
return (dispatch, getState) => {
return Promise.all(reports.map(({ id, state }) => api(getState)
const patchMastodonReports = (reports: { id: string, state: string }[]) =>
(dispatch: AppDispatch, getState: () => RootState) =>
Promise.all(reports.map(({ id, state }) => api(getState)
.post(`/api/v1/admin/reports/${id}/${state === 'resolved' ? 'reopen' : 'resolve'}`)
.then(() => {
dispatch({ type: ADMIN_REPORTS_PATCH_SUCCESS, reports });
@ -165,26 +162,22 @@ function patchMastodonReports(reports) {
dispatch({ type: ADMIN_REPORTS_PATCH_FAIL, error, reports });
}),
));
};
}
function patchPleromaReports(reports) {
return (dispatch, getState) => {
return api(getState)
const patchPleromaReports = (reports: { id: string, state: string }[]) =>
(dispatch: AppDispatch, getState: () => RootState) =>
api(getState)
.patch('/api/pleroma/admin/reports', { reports })
.then(() => {
dispatch({ type: ADMIN_REPORTS_PATCH_SUCCESS, reports });
}).catch(error => {
dispatch({ type: ADMIN_REPORTS_PATCH_FAIL, error, reports });
});
};
}
function patchReports(ids, reportState) {
return (dispatch, getState) => {
const patchReports = (ids: string[], reportState: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const instance = state.get('instance');
const instance = state.instance;
const features = getFeatures(instance);
const reports = ids.map(id => ({ id, state: reportState }));
@ -197,15 +190,13 @@ function patchReports(ids, reportState) {
return dispatch(patchPleromaReports(reports));
}
};
}
export function closeReports(ids) {
return patchReports(ids, 'closed');
}
const closeReports = (ids: string[]) =>
patchReports(ids, 'closed');
function fetchMastodonUsers(filters, page, query, pageSize, next) {
return (dispatch, getState) => {
const params = {
const fetchMastodonUsers = (filters: string[], page: number, query: string | null | undefined, pageSize: number, next?: string | null) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const params: Record<string, any> = {
username: query,
};
@ -216,59 +207,56 @@ function fetchMastodonUsers(filters, page, query, pageSize, next) {
return api(getState)
.get(next || '/api/v1/admin/accounts', { params })
.then(({ data: accounts, ...response }) => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
const next = getLinks(response as AxiosResponse<any, any>).refs.find(link => link.rel === 'next');
const count = next
? page * pageSize + 1
: (page - 1) * pageSize + accounts.length;
dispatch(importFetchedAccounts(accounts.map(({ account }) => account)));
dispatch(fetchRelationships(accounts.map(account => account.id)));
dispatch(importFetchedAccounts(accounts.map(({ account }: APIEntity) => account)));
dispatch(fetchRelationships(accounts.map((account: APIEntity) => account.id)));
dispatch({ type: ADMIN_USERS_FETCH_SUCCESS, users: accounts, count, pageSize, filters, page, next: next?.uri || false });
return { users: accounts, count, pageSize, next: next?.uri || false };
}).catch(error => {
dispatch({ type: ADMIN_USERS_FETCH_FAIL, error, filters, page, pageSize });
});
}).catch(error =>
dispatch({ type: ADMIN_USERS_FETCH_FAIL, error, filters, page, pageSize }),
);
};
}
function fetchPleromaUsers(filters, page, query, pageSize) {
return (dispatch, getState) => {
const params = { filters: filters.join(), page, page_size: pageSize };
const fetchPleromaUsers = (filters: string[], page: number, query?: string | null, pageSize?: number) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const params: Record<string, any> = { filters: filters.join(), page, page_size: pageSize };
if (query) params.query = query;
return api(getState)
.get('/api/pleroma/admin/users', { params })
.then(({ data: { users, count, page_size: pageSize } }) => {
dispatch(fetchRelationships(users.map(user => user.id)));
dispatch(fetchRelationships(users.map((user: APIEntity) => user.id)));
dispatch({ type: ADMIN_USERS_FETCH_SUCCESS, users, count, pageSize, filters, page });
return { users, count, pageSize };
}).catch(error => {
dispatch({ type: ADMIN_USERS_FETCH_FAIL, error, filters, page, pageSize });
});
}).catch(error =>
dispatch({ type: ADMIN_USERS_FETCH_FAIL, error, filters, page, pageSize }),
);
};
}
export function fetchUsers(filters = [], page = 1, query, pageSize = 50, next) {
return (dispatch, getState) => {
const fetchUsers = (filters: string[] = [], page = 1, query?: string | null, pageSize = 50, next?: string | null) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const instance = state.get('instance');
const instance = state.instance;
const features = getFeatures(instance);
dispatch({ type: ADMIN_USERS_FETCH_REQUEST, filters, page, pageSize });
if (features.mastodonAdmi) {
if (features.mastodonAdmin) {
return dispatch(fetchMastodonUsers(filters, page, query, pageSize, next));
} else {
return dispatch(fetchPleromaUsers(filters, page, query, pageSize));
}
};
}
function deactivateMastodonUsers(accountIds, reportId) {
return (dispatch, getState) => {
return Promise.all(accountIds.map(accountId => {
const deactivateMastodonUsers = (accountIds: string[], reportId?: string) =>
(dispatch: AppDispatch, getState: () => RootState) =>
Promise.all(accountIds.map(accountId => {
api(getState)
.post(`/api/v1/admin/accounts/${accountId}/action`, {
type: 'disable',
@ -280,11 +268,9 @@ function deactivateMastodonUsers(accountIds, reportId) {
dispatch({ type: ADMIN_USERS_DEACTIVATE_FAIL, error, accountIds: [accountId] });
});
}));
};
}
function deactivatePleromaUsers(accountIds) {
return (dispatch, getState) => {
const deactivatePleromaUsers = (accountIds: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const nicknames = nicknamesFromIds(getState, accountIds);
return api(getState)
.patch('/api/pleroma/admin/users/deactivate', { nicknames })
@ -294,27 +280,25 @@ function deactivatePleromaUsers(accountIds) {
dispatch({ type: ADMIN_USERS_DEACTIVATE_FAIL, error, accountIds });
});
};
}
export function deactivateUsers(accountIds, reportId) {
return (dispatch, getState) => {
const deactivateUsers = (accountIds: string[], reportId?: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const instance = state.get('instance');
const instance = state.instance;
const features = getFeatures(instance);
dispatch({ type: ADMIN_USERS_DEACTIVATE_REQUEST, accountIds });
if (features.mastodonAdmi) {
if (features.mastodonAdmin) {
return dispatch(deactivateMastodonUsers(accountIds, reportId));
} else {
return dispatch(deactivatePleromaUsers(accountIds));
}
};
}
export function deleteUsers(accountIds) {
return (dispatch, getState) => {
const deleteUsers = (accountIds: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const nicknames = nicknamesFromIds(getState, accountIds);
dispatch({ type: ADMIN_USERS_DELETE_REQUEST, accountIds });
return api(getState)
@ -325,11 +309,10 @@ export function deleteUsers(accountIds) {
dispatch({ type: ADMIN_USERS_DELETE_FAIL, error, accountIds });
});
};
}
function approveMastodonUsers(accountIds) {
return (dispatch, getState) => {
return Promise.all(accountIds.map(accountId => {
const approveMastodonUsers = (accountIds: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) =>
Promise.all(accountIds.map(accountId => {
api(getState)
.post(`/api/v1/admin/accounts/${accountId}/approve`)
.then(({ data: user }) => {
@ -338,11 +321,9 @@ function approveMastodonUsers(accountIds) {
dispatch({ type: ADMIN_USERS_APPROVE_FAIL, error, accountIds: [accountId] });
});
}));
};
}
function approvePleromaUsers(accountIds) {
return (dispatch, getState) => {
const approvePleromaUsers = (accountIds: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const nicknames = nicknamesFromIds(getState, accountIds);
return api(getState)
.patch('/api/pleroma/admin/users/approve', { nicknames })
@ -352,27 +333,25 @@ function approvePleromaUsers(accountIds) {
dispatch({ type: ADMIN_USERS_APPROVE_FAIL, error, accountIds });
});
};
}
export function approveUsers(accountIds) {
return (dispatch, getState) => {
const approveUsers = (accountIds: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const instance = state.get('instance');
const instance = state.instance;
const features = getFeatures(instance);
dispatch({ type: ADMIN_USERS_APPROVE_REQUEST, accountIds });
if (features.mastodonAdmi) {
if (features.mastodonAdmin) {
return dispatch(approveMastodonUsers(accountIds));
} else {
return dispatch(approvePleromaUsers(accountIds));
}
};
}
export function deleteStatus(id) {
return (dispatch, getState) => {
const deleteStatus = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: ADMIN_STATUS_DELETE_REQUEST, id });
return api(getState)
.delete(`/api/pleroma/admin/statuses/${id}`)
@ -382,10 +361,9 @@ export function deleteStatus(id) {
dispatch({ type: ADMIN_STATUS_DELETE_FAIL, error, id });
});
};
}
export function toggleStatusSensitivity(id, sensitive) {
return (dispatch, getState) => {
const toggleStatusSensitivity = (id: string, sensitive: boolean) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: ADMIN_STATUS_TOGGLE_SENSITIVITY_REQUEST, id });
return api(getState)
.put(`/api/pleroma/admin/statuses/${id}`, { sensitive: !sensitive })
@ -395,10 +373,9 @@ export function toggleStatusSensitivity(id, sensitive) {
dispatch({ type: ADMIN_STATUS_TOGGLE_SENSITIVITY_FAIL, error, id });
});
};
}
export function fetchModerationLog(params) {
return (dispatch, getState) => {
const fetchModerationLog = (params?: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: ADMIN_LOG_FETCH_REQUEST });
return api(getState)
.get('/api/pleroma/admin/moderation_log', { params })
@ -409,10 +386,9 @@ export function fetchModerationLog(params) {
dispatch({ type: ADMIN_LOG_FETCH_FAIL, error });
});
};
}
export function tagUsers(accountIds, tags) {
return (dispatch, getState) => {
const tagUsers = (accountIds: string[], tags: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const nicknames = nicknamesFromIds(getState, accountIds);
dispatch({ type: ADMIN_USERS_TAG_REQUEST, accountIds, tags });
return api(getState)
@ -423,10 +399,9 @@ export function tagUsers(accountIds, tags) {
dispatch({ type: ADMIN_USERS_TAG_FAIL, error, accountIds, tags });
});
};
}
export function untagUsers(accountIds, tags) {
return (dispatch, getState) => {
const untagUsers = (accountIds: string[], tags: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const nicknames = nicknamesFromIds(getState, accountIds);
dispatch({ type: ADMIN_USERS_UNTAG_REQUEST, accountIds, tags });
return api(getState)
@ -437,34 +412,25 @@ export function untagUsers(accountIds, tags) {
dispatch({ type: ADMIN_USERS_UNTAG_FAIL, error, accountIds, tags });
});
};
}
export function verifyUser(accountId) {
return (dispatch, getState) => {
return dispatch(tagUsers([accountId], ['verified']));
};
}
const verifyUser = (accountId: string) =>
(dispatch: AppDispatch) =>
dispatch(tagUsers([accountId], ['verified']));
export function unverifyUser(accountId) {
return (dispatch, getState) => {
return dispatch(untagUsers([accountId], ['verified']));
};
}
const unverifyUser = (accountId: string) =>
(dispatch: AppDispatch) =>
dispatch(untagUsers([accountId], ['verified']));
export function setDonor(accountId) {
return (dispatch, getState) => {
return dispatch(tagUsers([accountId], ['donor']));
};
}
const setDonor = (accountId: string) =>
(dispatch: AppDispatch) =>
dispatch(tagUsers([accountId], ['donor']));
export function removeDonor(accountId) {
return (dispatch, getState) => {
return dispatch(untagUsers([accountId], ['donor']));
};
}
const removeDonor = (accountId: string) =>
(dispatch: AppDispatch) =>
dispatch(untagUsers([accountId], ['donor']));
export function addPermission(accountIds, permissionGroup) {
return (dispatch, getState) => {
const addPermission = (accountIds: string[], permissionGroup: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const nicknames = nicknamesFromIds(getState, accountIds);
dispatch({ type: ADMIN_ADD_PERMISSION_GROUP_REQUEST, accountIds, permissionGroup });
return api(getState)
@ -475,10 +441,9 @@ export function addPermission(accountIds, permissionGroup) {
dispatch({ type: ADMIN_ADD_PERMISSION_GROUP_FAIL, error, accountIds, permissionGroup });
});
};
}
export function removePermission(accountIds, permissionGroup) {
return (dispatch, getState) => {
const removePermission = (accountIds: string[], permissionGroup: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const nicknames = nicknamesFromIds(getState, accountIds);
dispatch({ type: ADMIN_REMOVE_PERMISSION_GROUP_REQUEST, accountIds, permissionGroup });
return api(getState)
@ -489,37 +454,30 @@ export function removePermission(accountIds, permissionGroup) {
dispatch({ type: ADMIN_REMOVE_PERMISSION_GROUP_FAIL, error, accountIds, permissionGroup });
});
};
}
export function promoteToAdmin(accountId) {
return (dispatch, getState) => {
return Promise.all([
const promoteToAdmin = (accountId: string) =>
(dispatch: AppDispatch) =>
Promise.all([
dispatch(addPermission([accountId], 'admin')),
dispatch(removePermission([accountId], 'moderator')),
]);
};
}
export function promoteToModerator(accountId) {
return (dispatch, getState) => {
return Promise.all([
const promoteToModerator = (accountId: string) =>
(dispatch: AppDispatch) =>
Promise.all([
dispatch(removePermission([accountId], 'admin')),
dispatch(addPermission([accountId], 'moderator')),
]);
};
}
export function demoteToUser(accountId) {
return (dispatch, getState) => {
return Promise.all([
const demoteToUser = (accountId: string) =>
(dispatch: AppDispatch) =>
Promise.all([
dispatch(removePermission([accountId], 'admin')),
dispatch(removePermission([accountId], 'moderator')),
]);
};
}
export function suggestUsers(accountIds) {
return (dispatch, getState) => {
const suggestUsers = (accountIds: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const nicknames = nicknamesFromIds(getState, accountIds);
dispatch({ type: ADMIN_USERS_SUGGEST_REQUEST, accountIds });
return api(getState)
@ -530,10 +488,9 @@ export function suggestUsers(accountIds) {
dispatch({ type: ADMIN_USERS_SUGGEST_FAIL, error, accountIds });
});
};
}
export function unsuggestUsers(accountIds) {
return (dispatch, getState) => {
const unsuggestUsers = (accountIds: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const nicknames = nicknamesFromIds(getState, accountIds);
dispatch({ type: ADMIN_USERS_UNSUGGEST_REQUEST, accountIds });
return api(getState)
@ -544,4 +501,81 @@ export function unsuggestUsers(accountIds) {
dispatch({ type: ADMIN_USERS_UNSUGGEST_FAIL, error, accountIds });
});
};
}
export {
ADMIN_CONFIG_FETCH_REQUEST,
ADMIN_CONFIG_FETCH_SUCCESS,
ADMIN_CONFIG_FETCH_FAIL,
ADMIN_CONFIG_UPDATE_REQUEST,
ADMIN_CONFIG_UPDATE_SUCCESS,
ADMIN_CONFIG_UPDATE_FAIL,
ADMIN_REPORTS_FETCH_REQUEST,
ADMIN_REPORTS_FETCH_SUCCESS,
ADMIN_REPORTS_FETCH_FAIL,
ADMIN_REPORTS_PATCH_REQUEST,
ADMIN_REPORTS_PATCH_SUCCESS,
ADMIN_REPORTS_PATCH_FAIL,
ADMIN_USERS_FETCH_REQUEST,
ADMIN_USERS_FETCH_SUCCESS,
ADMIN_USERS_FETCH_FAIL,
ADMIN_USERS_DELETE_REQUEST,
ADMIN_USERS_DELETE_SUCCESS,
ADMIN_USERS_DELETE_FAIL,
ADMIN_USERS_APPROVE_REQUEST,
ADMIN_USERS_APPROVE_SUCCESS,
ADMIN_USERS_APPROVE_FAIL,
ADMIN_USERS_DEACTIVATE_REQUEST,
ADMIN_USERS_DEACTIVATE_SUCCESS,
ADMIN_USERS_DEACTIVATE_FAIL,
ADMIN_STATUS_DELETE_REQUEST,
ADMIN_STATUS_DELETE_SUCCESS,
ADMIN_STATUS_DELETE_FAIL,
ADMIN_STATUS_TOGGLE_SENSITIVITY_REQUEST,
ADMIN_STATUS_TOGGLE_SENSITIVITY_SUCCESS,
ADMIN_STATUS_TOGGLE_SENSITIVITY_FAIL,
ADMIN_LOG_FETCH_REQUEST,
ADMIN_LOG_FETCH_SUCCESS,
ADMIN_LOG_FETCH_FAIL,
ADMIN_USERS_TAG_REQUEST,
ADMIN_USERS_TAG_SUCCESS,
ADMIN_USERS_TAG_FAIL,
ADMIN_USERS_UNTAG_REQUEST,
ADMIN_USERS_UNTAG_SUCCESS,
ADMIN_USERS_UNTAG_FAIL,
ADMIN_ADD_PERMISSION_GROUP_REQUEST,
ADMIN_ADD_PERMISSION_GROUP_SUCCESS,
ADMIN_ADD_PERMISSION_GROUP_FAIL,
ADMIN_REMOVE_PERMISSION_GROUP_REQUEST,
ADMIN_REMOVE_PERMISSION_GROUP_SUCCESS,
ADMIN_REMOVE_PERMISSION_GROUP_FAIL,
ADMIN_USERS_SUGGEST_REQUEST,
ADMIN_USERS_SUGGEST_SUCCESS,
ADMIN_USERS_SUGGEST_FAIL,
ADMIN_USERS_UNSUGGEST_REQUEST,
ADMIN_USERS_UNSUGGEST_SUCCESS,
ADMIN_USERS_UNSUGGEST_FAIL,
fetchConfig,
updateConfig,
fetchReports,
closeReports,
fetchUsers,
deactivateUsers,
deleteUsers,
approveUsers,
deleteStatus,
toggleStatusSensitivity,
fetchModerationLog,
tagUsers,
untagUsers,
verifyUser,
unverifyUser,
setDonor,
removeDonor,
addPermission,
removePermission,
promoteToAdmin,
promoteToModerator,
demoteToUser,
suggestUsers,
unsuggestUsers,
};

196
app/soapbox/actions/aliases.js
View File

@ -1,196 +0,0 @@
import { defineMessages } from 'react-intl';
import { isLoggedIn } from 'soapbox/utils/auth';
import { getFeatures } from 'soapbox/utils/features';
import api from '../api';
import { showAlertForError } from './alerts';
import { importFetchedAccounts } from './importer';
import { patchMeSuccess } from './me';
import snackbar from './snackbar';
export const ALIASES_FETCH_REQUEST = 'ALIASES_FETCH_REQUEST';
export const ALIASES_FETCH_SUCCESS = 'ALIASES_FETCH_SUCCESS';
export const ALIASES_FETCH_FAIL = 'ALIASES_FETCH_FAIL';
export const ALIASES_SUGGESTIONS_CHANGE = 'ALIASES_SUGGESTIONS_CHANGE';
export const ALIASES_SUGGESTIONS_READY = 'ALIASES_SUGGESTIONS_READY';
export const ALIASES_SUGGESTIONS_CLEAR = 'ALIASES_SUGGESTIONS_CLEAR';
export const ALIASES_ADD_REQUEST = 'ALIASES_ADD_REQUEST';
export const ALIASES_ADD_SUCCESS = 'ALIASES_ADD_SUCCESS';
export const ALIASES_ADD_FAIL = 'ALIASES_ADD_FAIL';
export const ALIASES_REMOVE_REQUEST = 'ALIASES_REMOVE_REQUEST';
export const ALIASES_REMOVE_SUCCESS = 'ALIASES_REMOVE_SUCCESS';
export const ALIASES_REMOVE_FAIL = 'ALIASES_REMOVE_FAIL';
const messages = defineMessages({
createSuccess: { id: 'aliases.success.add', defaultMessage: 'Account alias created successfully' },
removeSuccess: { id: 'aliases.success.remove', defaultMessage: 'Account alias removed successfully' },
});
export const fetchAliases = (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const state = getState();
const instance = state.get('instance');
const features = getFeatures(instance);
if (!features.accountMoving) return;
dispatch(fetchAliasesRequest());
api(getState).get('/api/pleroma/aliases')
.then(response => {
dispatch(fetchAliasesSuccess(response.data.aliases));
})
.catch(err => dispatch(fetchAliasesFail(err)));
};
export const fetchAliasesRequest = () => ({
type: ALIASES_FETCH_REQUEST,
});
export const fetchAliasesSuccess = aliases => ({
type: ALIASES_FETCH_SUCCESS,
value: aliases,
});
export const fetchAliasesFail = error => ({
type: ALIASES_FETCH_FAIL,
error,
});
export const fetchAliasesSuggestions = q => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const params = {
q,
resolve: true,
limit: 4,
};
api(getState).get('/api/v1/accounts/search', { params }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(fetchAliasesSuggestionsReady(q, data));
}).catch(error => dispatch(showAlertForError(error)));
};
export const fetchAliasesSuggestionsReady = (query, accounts) => ({
type: ALIASES_SUGGESTIONS_READY,
query,
accounts,
});
export const clearAliasesSuggestions = () => ({
type: ALIASES_SUGGESTIONS_CLEAR,
});
export const changeAliasesSuggestions = value => ({
type: ALIASES_SUGGESTIONS_CHANGE,
value,
});
export const addToAliases = (account) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const state = getState();
const instance = state.get('instance');
const features = getFeatures(instance);
if (!features.accountMoving) {
const me = state.get('me');
const alsoKnownAs = state.getIn(['accounts_meta', me, 'pleroma', 'also_known_as']);
dispatch(addToAliasesRequest());
api(getState).patch('/api/v1/accounts/update_credentials', { also_known_as: [...alsoKnownAs, account.getIn(['pleroma', 'ap_id'])] })
.then((response => {
dispatch(snackbar.success(messages.createSuccess));
dispatch(addToAliasesSuccess);
dispatch(patchMeSuccess(response.data));
}))
.catch(err => dispatch(addToAliasesFail(err)));
return;
}
dispatch(addToAliasesRequest());
api(getState).put('/api/pleroma/aliases', {
alias: account.get('acct'),
})
.then(response => {
dispatch(snackbar.success(messages.createSuccess));
dispatch(addToAliasesSuccess);
dispatch(fetchAliases);
})
.catch(err => dispatch(fetchAliasesFail(err)));
};
export const addToAliasesRequest = () => ({
type: ALIASES_ADD_REQUEST,
});
export const addToAliasesSuccess = () => ({
type: ALIASES_ADD_SUCCESS,
});
export const addToAliasesFail = error => ({
type: ALIASES_ADD_FAIL,
error,
});
export const removeFromAliases = (account) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const state = getState();
const instance = state.get('instance');
const features = getFeatures(instance);
if (!features.accountMoving) {
const me = state.get('me');
const alsoKnownAs = state.getIn(['accounts_meta', me, 'pleroma', 'also_known_as']);
dispatch(removeFromAliasesRequest());
api(getState).patch('/api/v1/accounts/update_credentials', { also_known_as: alsoKnownAs.filter(id => id !== account) })
.then(response => {
dispatch(snackbar.success(messages.removeSuccess));
dispatch(removeFromAliasesSuccess);
dispatch(patchMeSuccess(response.data));
})
.catch(err => dispatch(removeFromAliasesFail(err)));
return;
}
dispatch(addToAliasesRequest());
api(getState).delete('/api/pleroma/aliases', {
data: {
alias: account,
},
})
.then(response => {
dispatch(snackbar.success(messages.removeSuccess));
dispatch(removeFromAliasesSuccess);
dispatch(fetchAliases);
})
.catch(err => dispatch(fetchAliasesFail(err)));
};
export const removeFromAliasesRequest = () => ({
type: ALIASES_REMOVE_REQUEST,
});
export const removeFromAliasesSuccess = () => ({
type: ALIASES_REMOVE_SUCCESS,
});
export const removeFromAliasesFail = error => ({
type: ALIASES_REMOVE_FAIL,
error,
});

234
app/soapbox/actions/aliases.ts Normal file
View File

@ -0,0 +1,234 @@
import { defineMessages } from 'react-intl';
import { isLoggedIn } from 'soapbox/utils/auth';
import { getFeatures } from 'soapbox/utils/features';
import api from '../api';
import { showAlertForError } from './alerts';
import { importFetchedAccounts } from './importer';
import { patchMeSuccess } from './me';
import snackbar from './snackbar';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity, Account } from 'soapbox/types/entities';
const ALIASES_FETCH_REQUEST = 'ALIASES_FETCH_REQUEST';
const ALIASES_FETCH_SUCCESS = 'ALIASES_FETCH_SUCCESS';
const ALIASES_FETCH_FAIL = 'ALIASES_FETCH_FAIL';
const ALIASES_SUGGESTIONS_CHANGE = 'ALIASES_SUGGESTIONS_CHANGE';
const ALIASES_SUGGESTIONS_READY = 'ALIASES_SUGGESTIONS_READY';
const ALIASES_SUGGESTIONS_CLEAR = 'ALIASES_SUGGESTIONS_CLEAR';
const ALIASES_ADD_REQUEST = 'ALIASES_ADD_REQUEST';
const ALIASES_ADD_SUCCESS = 'ALIASES_ADD_SUCCESS';
const ALIASES_ADD_FAIL = 'ALIASES_ADD_FAIL';
const ALIASES_REMOVE_REQUEST = 'ALIASES_REMOVE_REQUEST';
const ALIASES_REMOVE_SUCCESS = 'ALIASES_REMOVE_SUCCESS';
const ALIASES_REMOVE_FAIL = 'ALIASES_REMOVE_FAIL';
const messages = defineMessages({
createSuccess: { id: 'aliases.success.add', defaultMessage: 'Account alias created successfully' },
removeSuccess: { id: 'aliases.success.remove', defaultMessage: 'Account alias removed successfully' },
});
const fetchAliases = (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const state = getState();
const instance = state.instance;
const features = getFeatures(instance);
if (!features.accountMoving) return;
dispatch(fetchAliasesRequest());
api(getState).get('/api/pleroma/aliases')
.then(response => {
dispatch(fetchAliasesSuccess(response.data.aliases));
})
.catch(err => dispatch(fetchAliasesFail(err)));
};
const fetchAliasesRequest = () => ({
type: ALIASES_FETCH_REQUEST,
});
const fetchAliasesSuccess = (aliases: APIEntity[]) => ({
type: ALIASES_FETCH_SUCCESS,
value: aliases,
});
const fetchAliasesFail = (error: AxiosError) => ({
type: ALIASES_FETCH_FAIL,
error,
});
const fetchAliasesSuggestions = (q: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const params = {
q,
resolve: true,
limit: 4,
};
api(getState).get('/api/v1/accounts/search', { params }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(fetchAliasesSuggestionsReady(q, data));
}).catch(error => dispatch(showAlertForError(error)));
};
const fetchAliasesSuggestionsReady = (query: string, accounts: APIEntity[]) => ({
type: ALIASES_SUGGESTIONS_READY,
query,
accounts,
});
const clearAliasesSuggestions = () => ({
type: ALIASES_SUGGESTIONS_CLEAR,
});
const changeAliasesSuggestions = (value: string) => ({
type: ALIASES_SUGGESTIONS_CHANGE,
value,
});
const addToAliases = (account: Account) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const state = getState();
const instance = state.instance;
const features = getFeatures(instance);
if (!features.accountMoving) {
const me = state.me;
const alsoKnownAs = state.accounts_meta.get(me as string)!.pleroma.get('also_known_as');
dispatch(addToAliasesRequest());
api(getState).patch('/api/v1/accounts/update_credentials', { also_known_as: [...alsoKnownAs, account.pleroma.get('ap_id')] })
.then((response => {
dispatch(snackbar.success(messages.createSuccess));
dispatch(addToAliasesSuccess);
dispatch(patchMeSuccess(response.data));
}))
.catch(err => dispatch(addToAliasesFail(err)));
return;
}
dispatch(addToAliasesRequest());
api(getState).put('/api/pleroma/aliases', {
alias: account.acct,
})
.then(() => {
dispatch(snackbar.success(messages.createSuccess));
dispatch(addToAliasesSuccess);
dispatch(fetchAliases);
})
.catch(err => dispatch(fetchAliasesFail(err)));
};
const addToAliasesRequest = () => ({
type: ALIASES_ADD_REQUEST,
});
const addToAliasesSuccess = () => ({
type: ALIASES_ADD_SUCCESS,
});
const addToAliasesFail = (error: AxiosError) => ({
type: ALIASES_ADD_FAIL,
error,
});
const removeFromAliases = (account: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const state = getState();
const instance = state.instance;
const features = getFeatures(instance);
if (!features.accountMoving) {
const me = state.me;
const alsoKnownAs = state.accounts_meta.get(me as string)!.pleroma.get('also_known_as');
dispatch(removeFromAliasesRequest());
api(getState).patch('/api/v1/accounts/update_credentials', { also_known_as: alsoKnownAs.filter((id: string) => id !== account) })
.then(response => {
dispatch(snackbar.success(messages.removeSuccess));
dispatch(removeFromAliasesSuccess);
dispatch(patchMeSuccess(response.data));
})
.catch(err => dispatch(removeFromAliasesFail(err)));
return;
}
dispatch(addToAliasesRequest());
api(getState).delete('/api/pleroma/aliases', {
data: {
alias: account,
},
})
.then(response => {
dispatch(snackbar.success(messages.removeSuccess));
dispatch(removeFromAliasesSuccess);
dispatch(fetchAliases);
})
.catch(err => dispatch(fetchAliasesFail(err)));
};
const removeFromAliasesRequest = () => ({
type: ALIASES_REMOVE_REQUEST,
});
const removeFromAliasesSuccess = () => ({
type: ALIASES_REMOVE_SUCCESS,
});
const removeFromAliasesFail = (error: AxiosError) => ({
type: ALIASES_REMOVE_FAIL,
error,
});
export {
ALIASES_FETCH_REQUEST,
ALIASES_FETCH_SUCCESS,
ALIASES_FETCH_FAIL,
ALIASES_SUGGESTIONS_CHANGE,
ALIASES_SUGGESTIONS_READY,
ALIASES_SUGGESTIONS_CLEAR,
ALIASES_ADD_REQUEST,
ALIASES_ADD_SUCCESS,
ALIASES_ADD_FAIL,
ALIASES_REMOVE_REQUEST,
ALIASES_REMOVE_SUCCESS,
ALIASES_REMOVE_FAIL,
fetchAliases,
fetchAliasesRequest,
fetchAliasesSuccess,
fetchAliasesFail,
fetchAliasesSuggestions,
fetchAliasesSuggestionsReady,
clearAliasesSuggestions,
changeAliasesSuggestions,
addToAliases,
addToAliasesRequest,
addToAliasesSuccess,
addToAliasesFail,
removeFromAliases,
removeFromAliasesRequest,
removeFromAliasesSuccess,
removeFromAliasesFail,
};

19
app/soapbox/actions/auth.ts
View File

@ -77,7 +77,7 @@ const getAuthApp = () =>
};
const createAuthApp = () =>
(dispatch: AppDispatch, getState: () => any) => {
(dispatch: AppDispatch, getState: () => RootState) => {
const params = {
client_name: sourceCode.displayName,
redirect_uris: 'urn:ietf:wg:oauth:2.0:oob',
@ -91,7 +91,7 @@ const createAuthApp = () =>
};
const createAppToken = () =>
(dispatch: AppDispatch, getState: () => any) => {
(dispatch: AppDispatch, getState: () => RootState) => {
const app = getState().auth.get('app');
const params = {
@ -108,7 +108,7 @@ const createAppToken = () =>
};
const createUserToken = (username: string, password: string) =>
(dispatch: AppDispatch, getState: () => any) => {
(dispatch: AppDispatch, getState: () => RootState) => {
const app = getState().auth.get('app');
const params = {
@ -146,7 +146,7 @@ export const refreshUserToken = () =>
};
export const otpVerify = (code: string, mfa_token: string) =>
(dispatch: AppDispatch, getState: () => any) => {
(dispatch: AppDispatch, getState: () => RootState) => {
const app = getState().auth.get('app');
return api(getState, 'app').post('/oauth/mfa/challenge', {
client_id: app.get('client_id'),
@ -162,7 +162,7 @@ export const otpVerify = (code: string, mfa_token: string) =>
export const verifyCredentials = (token: string, accountUrl?: string) => {
const baseURL = parseBaseURL(accountUrl);
return (dispatch: AppDispatch, getState: () => any) => {
return (dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: VERIFY_CREDENTIALS_REQUEST, token });
return baseClient(token, baseURL).get('/api/v1/accounts/verify_credentials').then(({ data: account }) => {
@ -188,7 +188,7 @@ export const verifyCredentials = (token: string, accountUrl?: string) => {
};
export const rememberAuthAccount = (accountUrl: string) =>
(dispatch: AppDispatch, getState: () => any) => {
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: AUTH_ACCOUNT_REMEMBER_REQUEST, accountUrl });
return KVStore.getItemOrError(`authAccount:${accountUrl}`).then(account => {
dispatch(importFetchedAccount(account));
@ -229,6 +229,9 @@ export const logIn = (username: string, password: string) =>
throw error;
});
export const deleteSession = () =>
(dispatch: AppDispatch, getState: () => RootState) => api(getState).delete('/api/sign_out');
export const logOut = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
@ -250,7 +253,7 @@ export const logOut = () =>
};
export const switchAccount = (accountId: string, background = false) =>
(dispatch: AppDispatch, getState: () => any) => {
(dispatch: AppDispatch, getState: () => RootState) => {
const account = getState().accounts.get(accountId);
return dispatch({ type: SWITCH_ACCOUNT, account, background });
};
@ -280,7 +283,7 @@ export const register = (params: Record<string, any>) =>
};
export const fetchCaptcha = () =>
(_dispatch: AppDispatch, getState: () => any) => {
(_dispatch: AppDispatch, getState: () => RootState) => {
return api(getState).get('/api/pleroma/captcha');
};

6
app/soapbox/actions/backups.ts
View File

@ -1,6 +1,6 @@
import api from '../api';
import type { AppDispatch } from 'soapbox/store';
import type { AppDispatch, RootState } from 'soapbox/store';
export const BACKUPS_FETCH_REQUEST = 'BACKUPS_FETCH_REQUEST';
export const BACKUPS_FETCH_SUCCESS = 'BACKUPS_FETCH_SUCCESS';
@ -11,7 +11,7 @@ export const BACKUPS_CREATE_SUCCESS = 'BACKUPS_CREATE_SUCCESS';
export const BACKUPS_CREATE_FAIL = 'BACKUPS_CREATE_FAIL';
export const fetchBackups = () =>
(dispatch: AppDispatch, getState: () => any) => {
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: BACKUPS_FETCH_REQUEST });
return api(getState).get('/api/v1/pleroma/backups').then(({ data: backups }) =>
dispatch({ type: BACKUPS_FETCH_SUCCESS, backups }),
@ -21,7 +21,7 @@ export const fetchBackups = () =>
};
export const createBackup = () =>
(dispatch: AppDispatch, getState: () => any) => {
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: BACKUPS_CREATE_REQUEST });
return api(getState).post('/api/v1/pleroma/backups').then(({ data: backups }) =>
dispatch({ type: BACKUPS_CREATE_SUCCESS, backups }),

7
app/soapbox/actions/blocks.ts
View File

@ -8,6 +8,7 @@ import { importFetchedAccounts } from './importer';
import type { AnyAction } from '@reduxjs/toolkit';
import type { AxiosError } from 'axios';
import type { RootState } from 'soapbox/store';
const BLOCKS_FETCH_REQUEST = 'BLOCKS_FETCH_REQUEST';
const BLOCKS_FETCH_SUCCESS = 'BLOCKS_FETCH_SUCCESS';
@ -17,7 +18,7 @@ const BLOCKS_EXPAND_REQUEST = 'BLOCKS_EXPAND_REQUEST';
const BLOCKS_EXPAND_SUCCESS = 'BLOCKS_EXPAND_SUCCESS';
const BLOCKS_EXPAND_FAIL = 'BLOCKS_EXPAND_FAIL';
const fetchBlocks = () => (dispatch: React.Dispatch<AnyAction>, getState: any) => {
const fetchBlocks = () => (dispatch: React.Dispatch<AnyAction>, getState: () => RootState) => {
if (!isLoggedIn(getState)) return null;
const nextLinkName = getNextLinkName(getState);
@ -53,11 +54,11 @@ function fetchBlocksFail(error: AxiosError) {
};
}
const expandBlocks = () => (dispatch: React.Dispatch<AnyAction>, getState: any) => {
const expandBlocks = () => (dispatch: React.Dispatch<AnyAction>, getState: () => RootState) => {
if (!isLoggedIn(getState)) return null;
const nextLinkName = getNextLinkName(getState);
const url = getState().getIn(['user_lists', 'blocks', 'next']);
const url = getState().user_lists.getIn(['blocks', 'next']);
if (url === null) {
return null;

93
app/soapbox/actions/bookmarks.js
View File

@ -1,93 +0,0 @@
import api, { getLinks } from '../api';
import { importFetchedStatuses } from './importer';
export const BOOKMARKED_STATUSES_FETCH_REQUEST = 'BOOKMARKED_STATUSES_FETCH_REQUEST';
export const BOOKMARKED_STATUSES_FETCH_SUCCESS = 'BOOKMARKED_STATUSES_FETCH_SUCCESS';
export const BOOKMARKED_STATUSES_FETCH_FAIL = 'BOOKMARKED_STATUSES_FETCH_FAIL';
export const BOOKMARKED_STATUSES_EXPAND_REQUEST = 'BOOKMARKED_STATUSES_EXPAND_REQUEST';
export const BOOKMARKED_STATUSES_EXPAND_SUCCESS = 'BOOKMARKED_STATUSES_EXPAND_SUCCESS';
export const BOOKMARKED_STATUSES_EXPAND_FAIL = 'BOOKMARKED_STATUSES_EXPAND_FAIL';
const noOp = () => new Promise(f => f());
export function fetchBookmarkedStatuses() {
return (dispatch, getState) => {
if (getState().getIn(['status_lists', 'bookmarks', 'isLoading'])) {
return dispatch(noOp);
}
dispatch(fetchBookmarkedStatusesRequest());
return api(getState).get('/api/v1/bookmarks').then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(fetchBookmarkedStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(fetchBookmarkedStatusesFail(error));
});
};
}
export function fetchBookmarkedStatusesRequest() {
return {
type: BOOKMARKED_STATUSES_FETCH_REQUEST,
};
}
export function fetchBookmarkedStatusesSuccess(statuses, next) {
return {
type: BOOKMARKED_STATUSES_FETCH_SUCCESS,
statuses,
next,
};
}
export function fetchBookmarkedStatusesFail(error) {
return {
type: BOOKMARKED_STATUSES_FETCH_FAIL,
error,
};
}
export function expandBookmarkedStatuses() {
return (dispatch, getState) => {
const url = getState().getIn(['status_lists', 'bookmarks', 'next'], null);
if (url === null || getState().getIn(['status_lists', 'bookmarks', 'isLoading'])) {
return dispatch(noOp);
}
dispatch(expandBookmarkedStatusesRequest());
return api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(expandBookmarkedStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(expandBookmarkedStatusesFail(error));
});
};
}
export function expandBookmarkedStatusesRequest() {
return {
type: BOOKMARKED_STATUSES_EXPAND_REQUEST,
};
}
export function expandBookmarkedStatusesSuccess(statuses, next) {
return {
type: BOOKMARKED_STATUSES_EXPAND_SUCCESS,
statuses,
next,
};
}
export function expandBookmarkedStatusesFail(error) {
return {
type: BOOKMARKED_STATUSES_EXPAND_FAIL,
error,
};
}

100
app/soapbox/actions/bookmarks.ts Normal file
View File

@ -0,0 +1,100 @@
import api, { getLinks } from '../api';
import { importFetchedStatuses } from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const BOOKMARKED_STATUSES_FETCH_REQUEST = 'BOOKMARKED_STATUSES_FETCH_REQUEST';
const BOOKMARKED_STATUSES_FETCH_SUCCESS = 'BOOKMARKED_STATUSES_FETCH_SUCCESS';
const BOOKMARKED_STATUSES_FETCH_FAIL = 'BOOKMARKED_STATUSES_FETCH_FAIL';
const BOOKMARKED_STATUSES_EXPAND_REQUEST = 'BOOKMARKED_STATUSES_EXPAND_REQUEST';
const BOOKMARKED_STATUSES_EXPAND_SUCCESS = 'BOOKMARKED_STATUSES_EXPAND_SUCCESS';
const BOOKMARKED_STATUSES_EXPAND_FAIL = 'BOOKMARKED_STATUSES_EXPAND_FAIL';
const noOp = () => new Promise(f => f(undefined));
const fetchBookmarkedStatuses = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (getState().status_lists.get('bookmarks')?.isLoading) {
return dispatch(noOp);
}
dispatch(fetchBookmarkedStatusesRequest());
return api(getState).get('/api/v1/bookmarks').then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
return dispatch(fetchBookmarkedStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(fetchBookmarkedStatusesFail(error));
});
};
const fetchBookmarkedStatusesRequest = () => ({
type: BOOKMARKED_STATUSES_FETCH_REQUEST,
});
const fetchBookmarkedStatusesSuccess = (statuses: APIEntity[], next: string | null) => ({
type: BOOKMARKED_STATUSES_FETCH_SUCCESS,
statuses,
next,
});
const fetchBookmarkedStatusesFail = (error: AxiosError) => ({
type: BOOKMARKED_STATUSES_FETCH_FAIL,
error,
});
const expandBookmarkedStatuses = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const url = getState().status_lists.get('bookmarks')?.next || null;
if (url === null || getState().status_lists.get('bookmarks')?.isLoading) {
return dispatch(noOp);
}
dispatch(expandBookmarkedStatusesRequest());
return api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
return dispatch(expandBookmarkedStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(expandBookmarkedStatusesFail(error));
});
};
const expandBookmarkedStatusesRequest = () => ({
type: BOOKMARKED_STATUSES_EXPAND_REQUEST,
});
const expandBookmarkedStatusesSuccess = (statuses: APIEntity[], next: string | null) => ({
type: BOOKMARKED_STATUSES_EXPAND_SUCCESS,
statuses,
next,
});
const expandBookmarkedStatusesFail = (error: AxiosError) => ({
type: BOOKMARKED_STATUSES_EXPAND_FAIL,
error,
});
export {
BOOKMARKED_STATUSES_FETCH_REQUEST,
BOOKMARKED_STATUSES_FETCH_SUCCESS,
BOOKMARKED_STATUSES_FETCH_FAIL,
BOOKMARKED_STATUSES_EXPAND_REQUEST,
BOOKMARKED_STATUSES_EXPAND_SUCCESS,
BOOKMARKED_STATUSES_EXPAND_FAIL,
fetchBookmarkedStatuses,
fetchBookmarkedStatusesRequest,
fetchBookmarkedStatusesSuccess,
fetchBookmarkedStatusesFail,
expandBookmarkedStatuses,
expandBookmarkedStatusesRequest,
expandBookmarkedStatusesSuccess,
expandBookmarkedStatusesFail,
};

25
app/soapbox/actions/bundles.js
View File

@ -1,25 +0,0 @@
export const BUNDLE_FETCH_REQUEST = 'BUNDLE_FETCH_REQUEST';
export const BUNDLE_FETCH_SUCCESS = 'BUNDLE_FETCH_SUCCESS';
export const BUNDLE_FETCH_FAIL = 'BUNDLE_FETCH_FAIL';
export function fetchBundleRequest(skipLoading) {
return {
type: BUNDLE_FETCH_REQUEST,
skipLoading,
};
}
export function fetchBundleSuccess(skipLoading) {
return {
type: BUNDLE_FETCH_SUCCESS,
skipLoading,
};
}
export function fetchBundleFail(error, skipLoading) {
return {
type: BUNDLE_FETCH_FAIL,
error,
skipLoading,
};
}

28
app/soapbox/actions/bundles.ts Normal file
View File

@ -0,0 +1,28 @@
const BUNDLE_FETCH_REQUEST = 'BUNDLE_FETCH_REQUEST';
const BUNDLE_FETCH_SUCCESS = 'BUNDLE_FETCH_SUCCESS';
const BUNDLE_FETCH_FAIL = 'BUNDLE_FETCH_FAIL';
const fetchBundleRequest = (skipLoading?: boolean) => ({
type: BUNDLE_FETCH_REQUEST,
skipLoading,
});
const fetchBundleSuccess = (skipLoading?: boolean) => ({
type: BUNDLE_FETCH_SUCCESS,
skipLoading,
});
const fetchBundleFail = (error: any, skipLoading?: boolean) => ({
type: BUNDLE_FETCH_FAIL,
error,
skipLoading,
});
export {
BUNDLE_FETCH_REQUEST,
BUNDLE_FETCH_SUCCESS,
BUNDLE_FETCH_FAIL,
fetchBundleRequest,
fetchBundleSuccess,
fetchBundleFail,
};

188
app/soapbox/actions/chats.js → app/soapbox/actions/chats.ts
View File

@ -1,4 +1,4 @@
import { Map as ImmutableMap } from 'immutable';
import { List as ImmutableList, Map as ImmutableMap } from 'immutable';
import { v4 as uuidv4 } from 'uuid';
import { getSettings, changeSetting } from 'soapbox/actions/settings';
@ -6,47 +6,49 @@ import { getFeatures } from 'soapbox/utils/features';
import api, { getLinks } from '../api';
export const CHATS_FETCH_REQUEST = 'CHATS_FETCH_REQUEST';
export const CHATS_FETCH_SUCCESS = 'CHATS_FETCH_SUCCESS';
export const CHATS_FETCH_FAIL = 'CHATS_FETCH_FAIL';
import type { History } from 'history';
import type { AppDispatch, RootState } from 'soapbox/store';
export const CHATS_EXPAND_REQUEST = 'CHATS_EXPAND_REQUEST';
export const CHATS_EXPAND_SUCCESS = 'CHATS_EXPAND_SUCCESS';
export const CHATS_EXPAND_FAIL = 'CHATS_EXPAND_FAIL';
const CHATS_FETCH_REQUEST = 'CHATS_FETCH_REQUEST';
const CHATS_FETCH_SUCCESS = 'CHATS_FETCH_SUCCESS';
const CHATS_FETCH_FAIL = 'CHATS_FETCH_FAIL';
export const CHAT_MESSAGES_FETCH_REQUEST = 'CHAT_MESSAGES_FETCH_REQUEST';
export const CHAT_MESSAGES_FETCH_SUCCESS = 'CHAT_MESSAGES_FETCH_SUCCESS';
export const CHAT_MESSAGES_FETCH_FAIL = 'CHAT_MESSAGES_FETCH_FAIL';
const CHATS_EXPAND_REQUEST = 'CHATS_EXPAND_REQUEST';
const CHATS_EXPAND_SUCCESS = 'CHATS_EXPAND_SUCCESS';
const CHATS_EXPAND_FAIL = 'CHATS_EXPAND_FAIL';
export const CHAT_MESSAGE_SEND_REQUEST = 'CHAT_MESSAGE_SEND_REQUEST';
export const CHAT_MESSAGE_SEND_SUCCESS = 'CHAT_MESSAGE_SEND_SUCCESS';
export const CHAT_MESSAGE_SEND_FAIL = 'CHAT_MESSAGE_SEND_FAIL';
const CHAT_MESSAGES_FETCH_REQUEST = 'CHAT_MESSAGES_FETCH_REQUEST';
const CHAT_MESSAGES_FETCH_SUCCESS = 'CHAT_MESSAGES_FETCH_SUCCESS';
const CHAT_MESSAGES_FETCH_FAIL = 'CHAT_MESSAGES_FETCH_FAIL';
export const CHAT_FETCH_REQUEST = 'CHAT_FETCH_REQUEST';
export const CHAT_FETCH_SUCCESS = 'CHAT_FETCH_SUCCESS';
export const CHAT_FETCH_FAIL = 'CHAT_FETCH_FAIL';
const CHAT_MESSAGE_SEND_REQUEST = 'CHAT_MESSAGE_SEND_REQUEST';
const CHAT_MESSAGE_SEND_SUCCESS = 'CHAT_MESSAGE_SEND_SUCCESS';
const CHAT_MESSAGE_SEND_FAIL = 'CHAT_MESSAGE_SEND_FAIL';
export const CHAT_READ_REQUEST = 'CHAT_READ_REQUEST';
export const CHAT_READ_SUCCESS = 'CHAT_READ_SUCCESS';
export const CHAT_READ_FAIL = 'CHAT_READ_FAIL';
const CHAT_FETCH_REQUEST = 'CHAT_FETCH_REQUEST';
const CHAT_FETCH_SUCCESS = 'CHAT_FETCH_SUCCESS';
const CHAT_FETCH_FAIL = 'CHAT_FETCH_FAIL';
export const CHAT_MESSAGE_DELETE_REQUEST = 'CHAT_MESSAGE_DELETE_REQUEST';
export const CHAT_MESSAGE_DELETE_SUCCESS = 'CHAT_MESSAGE_DELETE_SUCCESS';
export const CHAT_MESSAGE_DELETE_FAIL = 'CHAT_MESSAGE_DELETE_FAIL';
const CHAT_READ_REQUEST = 'CHAT_READ_REQUEST';
const CHAT_READ_SUCCESS = 'CHAT_READ_SUCCESS';
const CHAT_READ_FAIL = 'CHAT_READ_FAIL';
export function fetchChatsV1() {
return (dispatch, getState) =>
const CHAT_MESSAGE_DELETE_REQUEST = 'CHAT_MESSAGE_DELETE_REQUEST';
const CHAT_MESSAGE_DELETE_SUCCESS = 'CHAT_MESSAGE_DELETE_SUCCESS';
const CHAT_MESSAGE_DELETE_FAIL = 'CHAT_MESSAGE_DELETE_FAIL';
const fetchChatsV1 = () =>
(dispatch: AppDispatch, getState: () => RootState) =>
api(getState).get('/api/v1/pleroma/chats').then((response) => {
dispatch({ type: CHATS_FETCH_SUCCESS, chats: response.data });
}).catch(error => {
dispatch({ type: CHATS_FETCH_FAIL, error });
});
}
export function fetchChatsV2() {
return (dispatch, getState) =>
const fetchChatsV2 = () =>
(dispatch: AppDispatch, getState: () => RootState) =>
api(getState).get('/api/v2/pleroma/chats').then((response) => {
let next = getLinks(response).refs.find(link => link.rel === 'next');
let next: { uri: string } | undefined = getLinks(response).refs.find(link => link.rel === 'next');
if (!next && response.data.length) {
next = { uri: `/api/v2/pleroma/chats?max_id=${response.data[response.data.length - 1].id}&offset=0` };
@ -56,10 +58,9 @@ export function fetchChatsV2() {
}).catch(error => {
dispatch({ type: CHATS_FETCH_FAIL, error });
});
}
export function fetchChats() {
return (dispatch, getState) => {
const fetchChats = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const { instance } = state;
const features = getFeatures(instance);
@ -71,11 +72,10 @@ export function fetchChats() {
return dispatch(fetchChatsV1());
}
};
}
export function expandChats() {
return (dispatch, getState) => {
const url = getState().getIn(['chats', 'next']);
const expandChats = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const url = getState().chats.next;
if (url === null) {
return;
@ -90,10 +90,9 @@ export function expandChats() {
dispatch({ type: CHATS_EXPAND_FAIL, error });
});
};
}
export function fetchChatMessages(chatId, maxId = null) {
return (dispatch, getState) => {
const fetchChatMessages = (chatId: string, maxId: string | null = null) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: CHAT_MESSAGES_FETCH_REQUEST, chatId, maxId });
return api(getState).get(`/api/v1/pleroma/chats/${chatId}/messages`, { params: { max_id: maxId } }).then(({ data }) => {
dispatch({ type: CHAT_MESSAGES_FETCH_SUCCESS, chatId, maxId, chatMessages: data });
@ -101,12 +100,11 @@ export function fetchChatMessages(chatId, maxId = null) {
dispatch({ type: CHAT_MESSAGES_FETCH_FAIL, chatId, maxId, error });
});
};
}
export function sendChatMessage(chatId, params) {
return (dispatch, getState) => {
const sendChatMessage = (chatId: string, params: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const uuid = `末_${Date.now()}_${uuidv4()}`;
const me = getState().get('me');
const me = getState().me;
dispatch({ type: CHAT_MESSAGE_SEND_REQUEST, chatId, params, uuid, me });
return api(getState).post(`/api/v1/pleroma/chats/${chatId}/messages`, params).then(({ data }) => {
dispatch({ type: CHAT_MESSAGE_SEND_SUCCESS, chatId, chatMessage: data, uuid });
@ -114,28 +112,26 @@ export function sendChatMessage(chatId, params) {
dispatch({ type: CHAT_MESSAGE_SEND_FAIL, chatId, error, uuid });
});
};
}
export function openChat(chatId) {
return (dispatch, getState) => {
const openChat = (chatId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const panes = getSettings(state).getIn(['chats', 'panes']);
const panes = getSettings(state).getIn(['chats', 'panes']) as ImmutableList<ImmutableMap<string, any>>;
const idx = panes.findIndex(pane => pane.get('chat_id') === chatId);
dispatch(markChatRead(chatId));
if (idx > -1) {
return dispatch(changeSetting(['chats', 'panes', idx, 'state'], 'open'));
return dispatch(changeSetting(['chats', 'panes', idx as any, 'state'], 'open'));
} else {
const newPane = ImmutableMap({ chat_id: chatId, state: 'open' });
return dispatch(changeSetting(['chats', 'panes'], panes.push(newPane)));
}
};
}
export function closeChat(chatId) {
return (dispatch, getState) => {
const panes = getSettings(getState()).getIn(['chats', 'panes']);
const closeChat = (chatId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const panes = getSettings(getState()).getIn(['chats', 'panes']) as ImmutableList<ImmutableMap<string, any>>;
const idx = panes.findIndex(pane => pane.get('chat_id') === chatId);
if (idx > -1) {
@ -144,33 +140,30 @@ export function closeChat(chatId) {
return false;
}
};
}
export function toggleChat(chatId) {
return (dispatch, getState) => {
const panes = getSettings(getState()).getIn(['chats', 'panes']);
const [idx, pane] = panes.findEntry(pane => pane.get('chat_id') === chatId);
const toggleChat = (chatId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const panes = getSettings(getState()).getIn(['chats', 'panes']) as ImmutableList<ImmutableMap<string, any>>;
const [idx, pane] = panes.findEntry(pane => pane.get('chat_id') === chatId)!;
if (idx > -1) {
const state = pane.get('state') === 'minimized' ? 'open' : 'minimized';
if (state === 'open') dispatch(markChatRead(chatId));
return dispatch(changeSetting(['chats', 'panes', idx, 'state'], state));
return dispatch(changeSetting(['chats', 'panes', idx as any, 'state'], state));
} else {
return false;
}
};
}
export function toggleMainWindow() {
return (dispatch, getState) => {
const main = getSettings(getState()).getIn(['chats', 'mainWindow']);
const toggleMainWindow = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const main = getSettings(getState()).getIn(['chats', 'mainWindow']) as 'minimized' | 'open';
const state = main === 'minimized' ? 'open' : 'minimized';
return dispatch(changeSetting(['chats', 'mainWindow'], state));
};
}
export function fetchChat(chatId) {
return (dispatch, getState) => {
const fetchChat = (chatId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: CHAT_FETCH_REQUEST, chatId });
return api(getState).get(`/api/v1/pleroma/chats/${chatId}`).then(({ data }) => {
dispatch({ type: CHAT_FETCH_SUCCESS, chat: data });
@ -178,10 +171,9 @@ export function fetchChat(chatId) {
dispatch({ type: CHAT_FETCH_FAIL, chatId, error });
});
};
}
export function startChat(accountId) {
return (dispatch, getState) => {
const startChat = (accountId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: CHAT_FETCH_REQUEST, accountId });
return api(getState).post(`/api/v1/pleroma/chats/by-account-id/${accountId}`).then(({ data }) => {
dispatch({ type: CHAT_FETCH_SUCCESS, chat: data });
@ -190,12 +182,11 @@ export function startChat(accountId) {
dispatch({ type: CHAT_FETCH_FAIL, accountId, error });
});
};
}
export function markChatRead(chatId, lastReadId) {
return (dispatch, getState) => {
const chat = getState().getIn(['chats', 'items', chatId]);
if (!lastReadId) lastReadId = chat.get('last_message');
const markChatRead = (chatId: string, lastReadId?: string | null) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const chat = getState().chats.items.get(chatId)!;
if (!lastReadId) lastReadId = chat.last_message;
if (chat.get('unread') < 1) return;
if (!lastReadId) return;
@ -207,10 +198,9 @@ export function markChatRead(chatId, lastReadId) {
dispatch({ type: CHAT_READ_FAIL, chatId, error, lastReadId });
});
};
}
export function deleteChatMessage(chatId, messageId) {
return (dispatch, getState) => {
const deleteChatMessage = (chatId: string, messageId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: CHAT_MESSAGE_DELETE_REQUEST, chatId, messageId });
api(getState).delete(`/api/v1/pleroma/chats/${chatId}/messages/${messageId}`).then(({ data }) => {
dispatch({ type: CHAT_MESSAGE_DELETE_SUCCESS, chatId, messageId, chatMessage: data });
@ -218,13 +208,12 @@ export function deleteChatMessage(chatId, messageId) {
dispatch({ type: CHAT_MESSAGE_DELETE_FAIL, chatId, messageId, error });
});
};
}
/** Start a chat and launch it in the UI */
export function launchChat(accountId, router, forceNavigate = false) {
const isMobile = width => width <= 1190;
const launchChat = (accountId: string, router: History, forceNavigate = false) => {
const isMobile = (width: number) => width <= 1190;
return (dispatch, getState) => {
return (dispatch: AppDispatch) => {
// TODO: make this faster
return dispatch(startChat(accountId)).then(chat => {
if (forceNavigate || isMobile(window.innerWidth)) {
@ -234,4 +223,43 @@ export function launchChat(accountId, router, forceNavigate = false) {
}
});
};
}
};
export {
CHATS_FETCH_REQUEST,
CHATS_FETCH_SUCCESS,
CHATS_FETCH_FAIL,
CHATS_EXPAND_REQUEST,
CHATS_EXPAND_SUCCESS,
CHATS_EXPAND_FAIL,
CHAT_MESSAGES_FETCH_REQUEST,
CHAT_MESSAGES_FETCH_SUCCESS,
CHAT_MESSAGES_FETCH_FAIL,
CHAT_MESSAGE_SEND_REQUEST,
CHAT_MESSAGE_SEND_SUCCESS,
CHAT_MESSAGE_SEND_FAIL,
CHAT_FETCH_REQUEST,
CHAT_FETCH_SUCCESS,
CHAT_FETCH_FAIL,
CHAT_READ_REQUEST,
CHAT_READ_SUCCESS,
CHAT_READ_FAIL,
CHAT_MESSAGE_DELETE_REQUEST,
CHAT_MESSAGE_DELETE_SUCCESS,
CHAT_MESSAGE_DELETE_FAIL,
fetchChatsV1,
fetchChatsV2,
fetchChats,
expandChats,
fetchChatMessages,
sendChatMessage,
openChat,
closeChat,
toggleChat,
toggleMainWindow,
fetchChat,
startChat,
markChatRead,
deleteChatMessage,
launchChat,
};

760
app/soapbox/actions/compose.js
View File

@ -1,760 +0,0 @@
import { CancelToken, isCancel } from 'axios';
import { OrderedSet as ImmutableOrderedSet } from 'immutable';
import throttle from 'lodash/throttle';
import { defineMessages } from 'react-intl';
import snackbar from 'soapbox/actions/snackbar';
import { isLoggedIn } from 'soapbox/utils/auth';
import { getFeatures, parseVersion } from 'soapbox/utils/features';
import { formatBytes } from 'soapbox/utils/media';
import api from '../api';
import { search as emojiSearch } from '../features/emoji/emoji_mart_search_light';
import { tagHistory } from '../settings';
import resizeImage from '../utils/resize_image';
import { showAlert, showAlertForError } from './alerts';
import { useEmoji } from './emojis';
import { importFetchedAccounts } from './importer';
import { uploadMedia, fetchMedia, updateMedia } from './media';
import { openModal, closeModal } from './modals';
import { getSettings } from './settings';
import { createStatus } from './statuses';
let cancelFetchComposeSuggestionsAccounts;
export const COMPOSE_CHANGE = 'COMPOSE_CHANGE';
export const COMPOSE_SUBMIT_REQUEST = 'COMPOSE_SUBMIT_REQUEST';
export const COMPOSE_SUBMIT_SUCCESS = 'COMPOSE_SUBMIT_SUCCESS';
export const COMPOSE_SUBMIT_FAIL = 'COMPOSE_SUBMIT_FAIL';
export const COMPOSE_REPLY = 'COMPOSE_REPLY';
export const COMPOSE_REPLY_CANCEL = 'COMPOSE_REPLY_CANCEL';
export const COMPOSE_QUOTE = 'COMPOSE_QUOTE';
export const COMPOSE_QUOTE_CANCEL = 'COMPOSE_QUOTE_CANCEL';
export const COMPOSE_DIRECT = 'COMPOSE_DIRECT';
export const COMPOSE_MENTION = 'COMPOSE_MENTION';
export const COMPOSE_RESET = 'COMPOSE_RESET';
export const COMPOSE_UPLOAD_REQUEST = 'COMPOSE_UPLOAD_REQUEST';
export const COMPOSE_UPLOAD_SUCCESS = 'COMPOSE_UPLOAD_SUCCESS';
export const COMPOSE_UPLOAD_FAIL = 'COMPOSE_UPLOAD_FAIL';
export const COMPOSE_UPLOAD_PROGRESS = 'COMPOSE_UPLOAD_PROGRESS';
export const COMPOSE_UPLOAD_UNDO = 'COMPOSE_UPLOAD_UNDO';
export const COMPOSE_SUGGESTIONS_CLEAR = 'COMPOSE_SUGGESTIONS_CLEAR';
export const COMPOSE_SUGGESTIONS_READY = 'COMPOSE_SUGGESTIONS_READY';
export const COMPOSE_SUGGESTION_SELECT = 'COMPOSE_SUGGESTION_SELECT';
export const COMPOSE_SUGGESTION_TAGS_UPDATE = 'COMPOSE_SUGGESTION_TAGS_UPDATE';
export const COMPOSE_TAG_HISTORY_UPDATE = 'COMPOSE_TAG_HISTORY_UPDATE';
export const COMPOSE_MOUNT = 'COMPOSE_MOUNT';
export const COMPOSE_UNMOUNT = 'COMPOSE_UNMOUNT';
export const COMPOSE_SENSITIVITY_CHANGE = 'COMPOSE_SENSITIVITY_CHANGE';
export const COMPOSE_SPOILERNESS_CHANGE = 'COMPOSE_SPOILERNESS_CHANGE';
export const COMPOSE_TYPE_CHANGE = 'COMPOSE_TYPE_CHANGE';
export const COMPOSE_SPOILER_TEXT_CHANGE = 'COMPOSE_SPOILER_TEXT_CHANGE';
export const COMPOSE_VISIBILITY_CHANGE = 'COMPOSE_VISIBILITY_CHANGE';
export const COMPOSE_LISTABILITY_CHANGE = 'COMPOSE_LISTABILITY_CHANGE';
export const COMPOSE_COMPOSING_CHANGE = 'COMPOSE_COMPOSING_CHANGE';
export const COMPOSE_EMOJI_INSERT = 'COMPOSE_EMOJI_INSERT';
export const COMPOSE_UPLOAD_CHANGE_REQUEST = 'COMPOSE_UPLOAD_UPDATE_REQUEST';
export const COMPOSE_UPLOAD_CHANGE_SUCCESS = 'COMPOSE_UPLOAD_UPDATE_SUCCESS';
export const COMPOSE_UPLOAD_CHANGE_FAIL = 'COMPOSE_UPLOAD_UPDATE_FAIL';
export const COMPOSE_POLL_ADD = 'COMPOSE_POLL_ADD';
export const COMPOSE_POLL_REMOVE = 'COMPOSE_POLL_REMOVE';
export const COMPOSE_POLL_OPTION_ADD = 'COMPOSE_POLL_OPTION_ADD';
export const COMPOSE_POLL_OPTION_CHANGE = 'COMPOSE_POLL_OPTION_CHANGE';
export const COMPOSE_POLL_OPTION_REMOVE = 'COMPOSE_POLL_OPTION_REMOVE';
export const COMPOSE_POLL_SETTINGS_CHANGE = 'COMPOSE_POLL_SETTINGS_CHANGE';
export const COMPOSE_SCHEDULE_ADD = 'COMPOSE_SCHEDULE_ADD';
export const COMPOSE_SCHEDULE_SET = 'COMPOSE_SCHEDULE_SET';
export const COMPOSE_SCHEDULE_REMOVE = 'COMPOSE_SCHEDULE_REMOVE';
export const COMPOSE_ADD_TO_MENTIONS = 'COMPOSE_ADD_TO_MENTIONS';
export const COMPOSE_REMOVE_FROM_MENTIONS = 'COMPOSE_REMOVE_FROM_MENTIONS';
export const COMPOSE_SET_STATUS = 'COMPOSE_SET_STATUS';
const messages = defineMessages({
exceededImageSizeLimit: { id: 'upload_error.image_size_limit', defaultMessage: 'Image exceeds the current file size limit ({limit})' },
exceededVideoSizeLimit: { id: 'upload_error.video_size_limit', defaultMessage: 'Video exceeds the current file size limit ({limit})' },
scheduleError: { id: 'compose.invalid_schedule', defaultMessage: 'You must schedule a post at least 5 minutes out.' },
success: { id: 'compose.submit_success', defaultMessage: 'Your post was sent' },
uploadErrorLimit: { id: 'upload_error.limit', defaultMessage: 'File upload limit exceeded.' },
uploadErrorPoll: { id: 'upload_error.poll', defaultMessage: 'File upload not allowed with polls.' },
view: { id: 'snackbar.view', defaultMessage: 'View' },
});
const COMPOSE_PANEL_BREAKPOINT = 600 + (285 * 1) + (10 * 1);
export const ensureComposeIsVisible = (getState, routerHistory) => {
if (!getState().getIn(['compose', 'mounted']) && window.innerWidth < COMPOSE_PANEL_BREAKPOINT) {
routerHistory.push('/posts/new');
}
};
export function setComposeToStatus(status, rawText, spoilerText, contentType, withRedraft) {
return (dispatch, getState) => {
const { instance } = getState();
const { explicitAddressing } = getFeatures(instance);
dispatch({
type: COMPOSE_SET_STATUS,
status,
rawText,
explicitAddressing,
spoilerText,
contentType,
v: parseVersion(instance.version),
withRedraft,
});
};
}
export function changeCompose(text) {
return {
type: COMPOSE_CHANGE,
text: text,
};
}
export function replyCompose(status, routerHistory) {
return (dispatch, getState) => {
const state = getState();
const instance = state.get('instance');
const { explicitAddressing } = getFeatures(instance);
dispatch({
type: COMPOSE_REPLY,
status: status,
account: state.getIn(['accounts', state.get('me')]),
explicitAddressing,
});
dispatch(openModal('COMPOSE'));
};
}
export function cancelReplyCompose() {
return {
type: COMPOSE_REPLY_CANCEL,
};
}
export function quoteCompose(status, routerHistory) {
return (dispatch, getState) => {
const state = getState();
const instance = state.get('instance');
const { explicitAddressing } = getFeatures(instance);
dispatch({
type: COMPOSE_QUOTE,
status: status,
account: state.getIn(['accounts', state.get('me')]),
explicitAddressing,
});
dispatch(openModal('COMPOSE'));
};
}
export function cancelQuoteCompose() {
return {
type: COMPOSE_QUOTE_CANCEL,
};
}
export function resetCompose() {
return {
type: COMPOSE_RESET,
};
}
export function mentionCompose(account, routerHistory) {
return (dispatch, getState) => {
dispatch({
type: COMPOSE_MENTION,
account: account,
});
dispatch(openModal('COMPOSE'));
};
}
export function directCompose(account, routerHistory) {
return (dispatch, getState) => {
dispatch({
type: COMPOSE_DIRECT,
account: account,
});
dispatch(openModal('COMPOSE'));
};
}
export function directComposeById(accountId) {
return (dispatch, getState) => {
const account = getState().getIn(['accounts', accountId]);
dispatch({
type: COMPOSE_DIRECT,
account: account,
});
dispatch(openModal('COMPOSE'));
};
}
export function handleComposeSubmit(dispatch, getState, data, status) {
if (!dispatch || !getState) return;
dispatch(insertIntoTagHistory(data.tags || [], status));
dispatch(submitComposeSuccess({ ...data }));
dispatch(snackbar.success(messages.success, messages.view, `/@${data.account.acct}/posts/${data.id}`));
}
const needsDescriptions = state => {
const media = state.getIn(['compose', 'media_attachments']);
const missingDescriptionModal = getSettings(state).get('missingDescriptionModal');
const hasMissing = media.filter(item => !item.get('description')).size > 0;
return missingDescriptionModal && hasMissing;
};
const validateSchedule = state => {
const schedule = state.getIn(['compose', 'schedule']);
if (!schedule) return true;
const fiveMinutesFromNow = new Date(new Date().getTime() + 300000);
return schedule.getTime() > fiveMinutesFromNow.getTime();
};
export function submitCompose(routerHistory, force = false) {
return function(dispatch, getState) {
if (!isLoggedIn(getState)) return;
const state = getState();
const status = state.getIn(['compose', 'text'], '');
const media = state.getIn(['compose', 'media_attachments']);
const statusId = state.getIn(['compose', 'id'], null);
let to = state.getIn(['compose', 'to'], ImmutableOrderedSet());
if (!validateSchedule(state)) {
dispatch(snackbar.error(messages.scheduleError));
return;
}
if ((!status || !status.length) && media.size === 0) {
return;
}
if (!force && needsDescriptions(state)) {
dispatch(openModal('MISSING_DESCRIPTION', {
onContinue: () => {
dispatch(closeModal('MISSING_DESCRIPTION'));
dispatch(submitCompose(routerHistory, true));
},
}));
return;
}
if (to && status) {
const mentions = status.match(/(?:^|\s|\.)@([a-z0-9_]+(?:@[a-z0-9\.\-]+)?)/gi); // not a perfect regex
if (mentions)
to = to.union(mentions.map(mention => mention.trim().slice(1)));
}
dispatch(submitComposeRequest());
dispatch(closeModal());
const idempotencyKey = state.getIn(['compose', 'idempotencyKey']);
const params = {
status,
in_reply_to_id: state.getIn(['compose', 'in_reply_to'], null),
quote_id: state.getIn(['compose', 'quote'], null),
media_ids: media.map(item => item.get('id')),
sensitive: state.getIn(['compose', 'sensitive']),
spoiler_text: state.getIn(['compose', 'spoiler_text'], ''),
visibility: state.getIn(['compose', 'privacy']),
content_type: state.getIn(['compose', 'content_type']),
poll: state.getIn(['compose', 'poll'], null),
scheduled_at: state.getIn(['compose', 'schedule'], null),
to,
};
dispatch(createStatus(params, idempotencyKey, statusId)).then(function(data) {
if (!statusId && data.visibility === 'direct' && getState().getIn(['conversations', 'mounted']) <= 0 && routerHistory) {
routerHistory.push('/messages');
}
handleComposeSubmit(dispatch, getState, data, status);
}).catch(function(error) {
dispatch(submitComposeFail(error));
});
};
}
export function submitComposeRequest() {
return {
type: COMPOSE_SUBMIT_REQUEST,
};
}
export function submitComposeSuccess(status) {
return {
type: COMPOSE_SUBMIT_SUCCESS,
status: status,
};
}
export function submitComposeFail(error) {
return {
type: COMPOSE_SUBMIT_FAIL,
error: error,
};
}
export function uploadCompose(files, intl) {
return function(dispatch, getState) {
if (!isLoggedIn(getState)) return;
const attachmentLimit = getState().getIn(['instance', 'configuration', 'statuses', 'max_media_attachments']);
const maxImageSize = getState().getIn(['instance', 'configuration', 'media_attachments', 'image_size_limit']);
const maxVideoSize = getState().getIn(['instance', 'configuration', 'media_attachments', 'video_size_limit']);
const media = getState().getIn(['compose', 'media_attachments']);
const progress = new Array(files.length).fill(0);
let total = Array.from(files).reduce((a, v) => a + v.size, 0);
if (files.length + media.size > attachmentLimit) {
dispatch(showAlert(undefined, messages.uploadErrorLimit, 'error'));
return;
}
dispatch(uploadComposeRequest());
Array.from(files).forEach((f, i) => {
if (media.size + i > attachmentLimit - 1) return;
const isImage = f.type.match(/image.*/);
const isVideo = f.type.match(/video.*/);
if (isImage && maxImageSize && (f.size > maxImageSize)) {
const limit = formatBytes(maxImageSize);
const message = intl.formatMessage(messages.exceededImageSizeLimit, { limit });
dispatch(snackbar.error(message));
dispatch(uploadComposeFail(true));
return;
} else if (isVideo && maxVideoSize && (f.size > maxVideoSize)) {
const limit = formatBytes(maxVideoSize);
const message = intl.formatMessage(messages.exceededVideoSizeLimit, { limit });
dispatch(snackbar.error(message));
dispatch(uploadComposeFail(true));
return;
}
// FIXME: Don't define function in loop
/* eslint-disable no-loop-func */
resizeImage(f).then(file => {
const data = new FormData();
data.append('file', file);
// Account for disparity in size of original image and resized data
total += file.size - f.size;
const onUploadProgress = function({ loaded }) {
progress[i] = loaded;
dispatch(uploadComposeProgress(progress.reduce((a, v) => a + v, 0), total));
};
return dispatch(uploadMedia(data, onUploadProgress))
.then(({ status, data }) => {
// If server-side processing of the media attachment has not completed yet,
// poll the server until it is, before showing the media attachment as uploaded
if (status === 200) {
dispatch(uploadComposeSuccess(data, f));
} else if (status === 202) {
const poll = () => {
dispatch(fetchMedia(data.id)).then(({ status, data }) => {
if (status === 200) {
dispatch(uploadComposeSuccess(data, f));
} else if (status === 206) {
setTimeout(() => poll(), 1000);
}
}).catch(error => dispatch(uploadComposeFail(error)));
};
poll();
}
});
}).catch(error => dispatch(uploadComposeFail(error)));
/* eslint-enable no-loop-func */
});
};
}
export function changeUploadCompose(id, params) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(changeUploadComposeRequest());
dispatch(updateMedia(id, params)).then(response => {
dispatch(changeUploadComposeSuccess(response.data));
}).catch(error => {
dispatch(changeUploadComposeFail(id, error));
});
};
}
export function changeUploadComposeRequest() {
return {
type: COMPOSE_UPLOAD_CHANGE_REQUEST,
skipLoading: true,
};
}
export function changeUploadComposeSuccess(media) {
return {
type: COMPOSE_UPLOAD_CHANGE_SUCCESS,
media: media,
skipLoading: true,
};
}
export function changeUploadComposeFail(error) {
return {
type: COMPOSE_UPLOAD_CHANGE_FAIL,
error: error,
skipLoading: true,
};
}
export function uploadComposeRequest() {
return {
type: COMPOSE_UPLOAD_REQUEST,
skipLoading: true,
};
}
export function uploadComposeProgress(loaded, total) {
return {
type: COMPOSE_UPLOAD_PROGRESS,
loaded: loaded,
total: total,
};
}
export function uploadComposeSuccess(media) {
return {
type: COMPOSE_UPLOAD_SUCCESS,
media: media,
skipLoading: true,
};
}
export function uploadComposeFail(error) {
return {
type: COMPOSE_UPLOAD_FAIL,
error: error,
skipLoading: true,
};
}
export function undoUploadCompose(media_id) {
return {
type: COMPOSE_UPLOAD_UNDO,
media_id: media_id,
};
}
export function clearComposeSuggestions() {
if (cancelFetchComposeSuggestionsAccounts) {
cancelFetchComposeSuggestionsAccounts();
}
return {
type: COMPOSE_SUGGESTIONS_CLEAR,
};
}
const fetchComposeSuggestionsAccounts = throttle((dispatch, getState, token) => {
if (cancelFetchComposeSuggestionsAccounts) {
cancelFetchComposeSuggestionsAccounts();
}
api(getState).get('/api/v1/accounts/search', {
cancelToken: new CancelToken(cancel => {
cancelFetchComposeSuggestionsAccounts = cancel;
}),
params: {
q: token.slice(1),
resolve: false,
limit: 4,
},
}).then(response => {
dispatch(importFetchedAccounts(response.data));
dispatch(readyComposeSuggestionsAccounts(token, response.data));
}).catch(error => {
if (!isCancel(error)) {
dispatch(showAlertForError(error));
}
});
}, 200, { leading: true, trailing: true });
const fetchComposeSuggestionsEmojis = (dispatch, getState, token) => {
const results = emojiSearch(token.replace(':', ''), { maxResults: 5 });
dispatch(readyComposeSuggestionsEmojis(token, results));
};
const fetchComposeSuggestionsTags = (dispatch, getState, token) => {
dispatch(updateSuggestionTags(token));
};
export function fetchComposeSuggestions(token) {
return (dispatch, getState) => {
switch (token[0]) {
case ':':
fetchComposeSuggestionsEmojis(dispatch, getState, token);
break;
case '#':
fetchComposeSuggestionsTags(dispatch, getState, token);
break;
default:
fetchComposeSuggestionsAccounts(dispatch, getState, token);
break;
}
};
}
export function readyComposeSuggestionsEmojis(token, emojis) {
return {
type: COMPOSE_SUGGESTIONS_READY,
token,
emojis,
};
}
export function readyComposeSuggestionsAccounts(token, accounts) {
return {
type: COMPOSE_SUGGESTIONS_READY,
token,
accounts,
};
}
export function selectComposeSuggestion(position, token, suggestion, path) {
return (dispatch, getState) => {
let completion, startPosition;
if (typeof suggestion === 'object' && suggestion.id) {
completion = suggestion.native || suggestion.colons;
startPosition = position - 1;
dispatch(useEmoji(suggestion));
} else if (suggestion[0] === '#') {
completion = suggestion;
startPosition = position - 1;
} else {
completion = getState().getIn(['accounts', suggestion, 'acct']);
startPosition = position;
}
dispatch({
type: COMPOSE_SUGGESTION_SELECT,
position: startPosition,
token,
completion,
path,
});
};
}
export function updateSuggestionTags(token) {
return {
type: COMPOSE_SUGGESTION_TAGS_UPDATE,
token,
};
}
export function updateTagHistory(tags) {
return {
type: COMPOSE_TAG_HISTORY_UPDATE,
tags,
};
}
function insertIntoTagHistory(recognizedTags, text) {
return (dispatch, getState) => {
const state = getState();
const oldHistory = state.getIn(['compose', 'tagHistory']);
const me = state.get('me');
const names = recognizedTags
.filter(tag => text.match(new RegExp(`#${tag.name}`, 'i')))
.map(tag => tag.name);
const intersectedOldHistory = oldHistory.filter(name => names.findIndex(newName => newName.toLowerCase() === name.toLowerCase()) === -1);
names.push(...intersectedOldHistory.toJS());
const newHistory = names.slice(0, 1000);
tagHistory.set(me, newHistory);
dispatch(updateTagHistory(newHistory));
};
}
export function mountCompose() {
return {
type: COMPOSE_MOUNT,
};
}
export function unmountCompose() {
return {
type: COMPOSE_UNMOUNT,
};
}
export function changeComposeSensitivity() {
return {
type: COMPOSE_SENSITIVITY_CHANGE,
};
}
export function changeComposeSpoilerness() {
return {
type: COMPOSE_SPOILERNESS_CHANGE,
};
}
export function changeComposeContentType(value) {
return {
type: COMPOSE_TYPE_CHANGE,
value,
};
}
export function changeComposeSpoilerText(text) {
return {
type: COMPOSE_SPOILER_TEXT_CHANGE,
text,
};
}
export function changeComposeVisibility(value) {
return {
type: COMPOSE_VISIBILITY_CHANGE,
value,
};
}
export function insertEmojiCompose(position, emoji, needsSpace) {
return {
type: COMPOSE_EMOJI_INSERT,
position,
emoji,
needsSpace,
};
}
export function changeComposing(value) {
return {
type: COMPOSE_COMPOSING_CHANGE,
value,
};
}
export function addPoll() {
return {
type: COMPOSE_POLL_ADD,
};
}
export function removePoll() {
return {
type: COMPOSE_POLL_REMOVE,
};
}
export function addSchedule() {
return {
type: COMPOSE_SCHEDULE_ADD,
};
}
export function setSchedule(date) {
return {
type: COMPOSE_SCHEDULE_SET,
date: date,
};
}
export function removeSchedule() {
return {
type: COMPOSE_SCHEDULE_REMOVE,
};
}
export function addPollOption(title) {
return {
type: COMPOSE_POLL_OPTION_ADD,
title,
};
}
export function changePollOption(index, title) {
return {
type: COMPOSE_POLL_OPTION_CHANGE,
index,
title,
};
}
export function removePollOption(index) {
return {
type: COMPOSE_POLL_OPTION_REMOVE,
index,
};
}
export function changePollSettings(expiresIn, isMultiple) {
return {
type: COMPOSE_POLL_SETTINGS_CHANGE,
expiresIn,
isMultiple,
};
}
export function openComposeWithText(text = '') {
return (dispatch, getState) => {
dispatch(resetCompose());
dispatch(openModal('COMPOSE'));
dispatch(changeCompose(text));
};
}
export function addToMentions(accountId) {
return (dispatch, getState) => {
const state = getState();
const acct = state.getIn(['accounts', accountId, 'acct']);
return dispatch({
type: COMPOSE_ADD_TO_MENTIONS,
account: acct,
});
};
}
export function removeFromMentions(accountId) {
return (dispatch, getState) => {
const state = getState();
const acct = state.getIn(['accounts', accountId, 'acct']);
return dispatch({
type: COMPOSE_REMOVE_FROM_MENTIONS,
account: acct,
});
};
}

783
app/soapbox/actions/compose.ts Normal file
View File

@ -0,0 +1,783 @@
import axios, { AxiosError, Canceler } from 'axios';
import throttle from 'lodash/throttle';
import { defineMessages, IntlShape } from 'react-intl';
import snackbar from 'soapbox/actions/snackbar';
import api from 'soapbox/api';
import { search as emojiSearch } from 'soapbox/features/emoji/emoji_mart_search_light';
import { tagHistory } from 'soapbox/settings';
import { isLoggedIn } from 'soapbox/utils/auth';
import { getFeatures, parseVersion } from 'soapbox/utils/features';
import { formatBytes } from 'soapbox/utils/media';
import resizeImage from 'soapbox/utils/resize_image';
import { showAlert, showAlertForError } from './alerts';
import { useEmoji } from './emojis';
import { importFetchedAccounts } from './importer';
import { uploadMedia, fetchMedia, updateMedia } from './media';
import { openModal, closeModal } from './modals';
import { getSettings } from './settings';
import { createStatus } from './statuses';
import type { History } from 'history';
import type { Emoji } from 'soapbox/components/autosuggest_emoji';
import type { AutoSuggestion } from 'soapbox/components/autosuggest_input';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { Account, APIEntity, Status } from 'soapbox/types/entities';
const { CancelToken, isCancel } = axios;
let cancelFetchComposeSuggestionsAccounts: Canceler;
const COMPOSE_CHANGE = 'COMPOSE_CHANGE';
const COMPOSE_SUBMIT_REQUEST = 'COMPOSE_SUBMIT_REQUEST';
const COMPOSE_SUBMIT_SUCCESS = 'COMPOSE_SUBMIT_SUCCESS';
const COMPOSE_SUBMIT_FAIL = 'COMPOSE_SUBMIT_FAIL';
const COMPOSE_REPLY = 'COMPOSE_REPLY';
const COMPOSE_REPLY_CANCEL = 'COMPOSE_REPLY_CANCEL';
const COMPOSE_QUOTE = 'COMPOSE_QUOTE';
const COMPOSE_QUOTE_CANCEL = 'COMPOSE_QUOTE_CANCEL';
const COMPOSE_DIRECT = 'COMPOSE_DIRECT';
const COMPOSE_MENTION = 'COMPOSE_MENTION';
const COMPOSE_RESET = 'COMPOSE_RESET';
const COMPOSE_UPLOAD_REQUEST = 'COMPOSE_UPLOAD_REQUEST';
const COMPOSE_UPLOAD_SUCCESS = 'COMPOSE_UPLOAD_SUCCESS';
const COMPOSE_UPLOAD_FAIL = 'COMPOSE_UPLOAD_FAIL';
const COMPOSE_UPLOAD_PROGRESS = 'COMPOSE_UPLOAD_PROGRESS';
const COMPOSE_UPLOAD_UNDO = 'COMPOSE_UPLOAD_UNDO';
const COMPOSE_SUGGESTIONS_CLEAR = 'COMPOSE_SUGGESTIONS_CLEAR';
const COMPOSE_SUGGESTIONS_READY = 'COMPOSE_SUGGESTIONS_READY';
const COMPOSE_SUGGESTION_SELECT = 'COMPOSE_SUGGESTION_SELECT';
const COMPOSE_SUGGESTION_TAGS_UPDATE = 'COMPOSE_SUGGESTION_TAGS_UPDATE';
const COMPOSE_TAG_HISTORY_UPDATE = 'COMPOSE_TAG_HISTORY_UPDATE';
const COMPOSE_MOUNT = 'COMPOSE_MOUNT';
const COMPOSE_UNMOUNT = 'COMPOSE_UNMOUNT';
const COMPOSE_SENSITIVITY_CHANGE = 'COMPOSE_SENSITIVITY_CHANGE';
const COMPOSE_SPOILERNESS_CHANGE = 'COMPOSE_SPOILERNESS_CHANGE';
const COMPOSE_TYPE_CHANGE = 'COMPOSE_TYPE_CHANGE';
const COMPOSE_SPOILER_TEXT_CHANGE = 'COMPOSE_SPOILER_TEXT_CHANGE';
const COMPOSE_VISIBILITY_CHANGE = 'COMPOSE_VISIBILITY_CHANGE';
const COMPOSE_LISTABILITY_CHANGE = 'COMPOSE_LISTABILITY_CHANGE';
const COMPOSE_COMPOSING_CHANGE = 'COMPOSE_COMPOSING_CHANGE';
const COMPOSE_EMOJI_INSERT = 'COMPOSE_EMOJI_INSERT';
const COMPOSE_UPLOAD_CHANGE_REQUEST = 'COMPOSE_UPLOAD_UPDATE_REQUEST';
const COMPOSE_UPLOAD_CHANGE_SUCCESS = 'COMPOSE_UPLOAD_UPDATE_SUCCESS';
const COMPOSE_UPLOAD_CHANGE_FAIL = 'COMPOSE_UPLOAD_UPDATE_FAIL';
const COMPOSE_POLL_ADD = 'COMPOSE_POLL_ADD';
const COMPOSE_POLL_REMOVE = 'COMPOSE_POLL_REMOVE';
const COMPOSE_POLL_OPTION_ADD = 'COMPOSE_POLL_OPTION_ADD';
const COMPOSE_POLL_OPTION_CHANGE = 'COMPOSE_POLL_OPTION_CHANGE';
const COMPOSE_POLL_OPTION_REMOVE = 'COMPOSE_POLL_OPTION_REMOVE';
const COMPOSE_POLL_SETTINGS_CHANGE = 'COMPOSE_POLL_SETTINGS_CHANGE';
const COMPOSE_SCHEDULE_ADD = 'COMPOSE_SCHEDULE_ADD';
const COMPOSE_SCHEDULE_SET = 'COMPOSE_SCHEDULE_SET';
const COMPOSE_SCHEDULE_REMOVE = 'COMPOSE_SCHEDULE_REMOVE';
const COMPOSE_ADD_TO_MENTIONS = 'COMPOSE_ADD_TO_MENTIONS';
const COMPOSE_REMOVE_FROM_MENTIONS = 'COMPOSE_REMOVE_FROM_MENTIONS';
const COMPOSE_SET_STATUS = 'COMPOSE_SET_STATUS';
const messages = defineMessages({
exceededImageSizeLimit: { id: 'upload_error.image_size_limit', defaultMessage: 'Image exceeds the current file size limit ({limit})' },
exceededVideoSizeLimit: { id: 'upload_error.video_size_limit', defaultMessage: 'Video exceeds the current file size limit ({limit})' },
scheduleError: { id: 'compose.invalid_schedule', defaultMessage: 'You must schedule a post at least 5 minutes out.' },
success: { id: 'compose.submit_success', defaultMessage: 'Your post was sent' },
uploadErrorLimit: { id: 'upload_error.limit', defaultMessage: 'File upload limit exceeded.' },
uploadErrorPoll: { id: 'upload_error.poll', defaultMessage: 'File upload not allowed with polls.' },
view: { id: 'snackbar.view', defaultMessage: 'View' },
});
const COMPOSE_PANEL_BREAKPOINT = 600 + (285 * 1) + (10 * 1);
const ensureComposeIsVisible = (getState: () => RootState, routerHistory: History) => {
if (!getState().compose.mounted && window.innerWidth < COMPOSE_PANEL_BREAKPOINT) {
routerHistory.push('/posts/new');
}
};
const setComposeToStatus = (status: Status, rawText: string, spoilerText?: string, contentType?: string | false, withRedraft?: boolean) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const { instance } = getState();
const { explicitAddressing } = getFeatures(instance);
dispatch({
type: COMPOSE_SET_STATUS,
status,
rawText,
explicitAddressing,
spoilerText,
contentType,
v: parseVersion(instance.version),
withRedraft,
});
};
const changeCompose = (text: string) => ({
type: COMPOSE_CHANGE,
text: text,
});
const replyCompose = (status: Status) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const instance = state.instance;
const { explicitAddressing } = getFeatures(instance);
dispatch({
type: COMPOSE_REPLY,
status: status,
account: state.accounts.get(state.me),
explicitAddressing,
});
dispatch(openModal('COMPOSE'));
};
const cancelReplyCompose = () => ({
type: COMPOSE_REPLY_CANCEL,
});
const quoteCompose = (status: Status) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const instance = state.instance;
const { explicitAddressing } = getFeatures(instance);
dispatch({
type: COMPOSE_QUOTE,
status: status,
account: state.accounts.get(state.me),
explicitAddressing,
});
dispatch(openModal('COMPOSE'));
};
const cancelQuoteCompose = () => ({
type: COMPOSE_QUOTE_CANCEL,
});
const resetCompose = () => ({
type: COMPOSE_RESET,
});
const mentionCompose = (account: Account) =>
(dispatch: AppDispatch) => {
dispatch({
type: COMPOSE_MENTION,
account: account,
});
dispatch(openModal('COMPOSE'));
};
const directCompose = (account: Account) =>
(dispatch: AppDispatch) => {
dispatch({
type: COMPOSE_DIRECT,
account: account,
});
dispatch(openModal('COMPOSE'));
};
const directComposeById = (accountId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const account = getState().accounts.get(accountId);
dispatch({
type: COMPOSE_DIRECT,
account: account,
});
dispatch(openModal('COMPOSE'));
};
const handleComposeSubmit = (dispatch: AppDispatch, getState: () => RootState, data: APIEntity, status: string) => {
if (!dispatch || !getState) return;
dispatch(insertIntoTagHistory(data.tags || [], status));
dispatch(submitComposeSuccess({ ...data }));
dispatch(snackbar.success(messages.success, messages.view, `/@${data.account.acct}/posts/${data.id}`));
};
const needsDescriptions = (state: RootState) => {
const media = state.compose.media_attachments;
const missingDescriptionModal = getSettings(state).get('missingDescriptionModal');
const hasMissing = media.filter(item => !item.description).size > 0;
return missingDescriptionModal && hasMissing;
};
const validateSchedule = (state: RootState) => {
const schedule = state.compose.schedule;
if (!schedule) return true;
const fiveMinutesFromNow = new Date(new Date().getTime() + 300000);
return schedule.getTime() > fiveMinutesFromNow.getTime();
};
const submitCompose = (routerHistory: History, force = false) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const state = getState();
const status = state.compose.text;
const media = state.compose.media_attachments;
const statusId = state.compose.id;
let to = state.compose.to;
if (!validateSchedule(state)) {
dispatch(snackbar.error(messages.scheduleError));
return;
}
if ((!status || !status.length) && media.size === 0) {
return;
}
if (!force && needsDescriptions(state)) {
dispatch(openModal('MISSING_DESCRIPTION', {
onContinue: () => {
dispatch(closeModal('MISSING_DESCRIPTION'));
dispatch(submitCompose(routerHistory, true));
},
}));
return;
}
if (to && status) {
const mentions: string[] | null = status.match(/(?:^|\s|\.)@([a-z0-9_]+(?:@[a-z0-9\.\-]+)?)/gi); // not a perfect regex
if (mentions)
to = to.union(mentions.map(mention => mention.trim().slice(1)));
}
dispatch(submitComposeRequest());
dispatch(closeModal());
const idempotencyKey = state.compose.idempotencyKey;
const params = {
status,
in_reply_to_id: state.compose.in_reply_to,
quote_id: state.compose.quote,
media_ids: media.map(item => item.id),
sensitive: state.compose.sensitive,
spoiler_text: state.compose.spoiler_text,
visibility: state.compose.privacy,
content_type: state.compose.content_type,
poll: state.compose.poll,
scheduled_at: state.compose.schedule,
to,
};
dispatch(createStatus(params, idempotencyKey, statusId)).then(function(data) {
if (!statusId && data.visibility === 'direct' && getState().conversations.get('mounted') <= 0 && routerHistory) {
routerHistory.push('/messages');
}
handleComposeSubmit(dispatch, getState, data, status);
}).catch(function(error) {
dispatch(submitComposeFail(error));
});
};
const submitComposeRequest = () => ({
type: COMPOSE_SUBMIT_REQUEST,
});
const submitComposeSuccess = (status: APIEntity) => ({
type: COMPOSE_SUBMIT_SUCCESS,
status: status,
});
const submitComposeFail = (error: AxiosError) => ({
type: COMPOSE_SUBMIT_FAIL,
error: error,
});
const uploadCompose = (files: FileList, intl: IntlShape) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const attachmentLimit = getState().instance.configuration.getIn(['statuses', 'max_media_attachments']) as number;
const maxImageSize = getState().instance.configuration.getIn(['media_attachments', 'image_size_limit']) as number | undefined;
const maxVideoSize = getState().instance.configuration.getIn(['media_attachments', 'video_size_limit']) as number | undefined;
const media = getState().compose.media_attachments;
const progress = new Array(files.length).fill(0);
let total = Array.from(files).reduce((a, v) => a + v.size, 0);
if (files.length + media.size > attachmentLimit) {
dispatch(showAlert(undefined, messages.uploadErrorLimit, 'error'));
return;
}
dispatch(uploadComposeRequest());
Array.from(files).forEach((f, i) => {
if (media.size + i > attachmentLimit - 1) return;
const isImage = f.type.match(/image.*/);
const isVideo = f.type.match(/video.*/);
if (isImage && maxImageSize && (f.size > maxImageSize)) {
const limit = formatBytes(maxImageSize);
const message = intl.formatMessage(messages.exceededImageSizeLimit, { limit });
dispatch(snackbar.error(message));
dispatch(uploadComposeFail(true));
return;
} else if (isVideo && maxVideoSize && (f.size > maxVideoSize)) {
const limit = formatBytes(maxVideoSize);
const message = intl.formatMessage(messages.exceededVideoSizeLimit, { limit });
dispatch(snackbar.error(message));
dispatch(uploadComposeFail(true));
return;
}
// FIXME: Don't define const in loop
/* eslint-disable no-loop-func */
resizeImage(f).then(file => {
const data = new FormData();
data.append('file', file);
// Account for disparity in size of original image and resized data
total += file.size - f.size;
const onUploadProgress = ({ loaded }: any) => {
progress[i] = loaded;
dispatch(uploadComposeProgress(progress.reduce((a, v) => a + v, 0), total));
};
return dispatch(uploadMedia(data, onUploadProgress))
.then(({ status, data }) => {
// If server-side processing of the media attachment has not completed yet,
// poll the server until it is, before showing the media attachment as uploaded
if (status === 200) {
dispatch(uploadComposeSuccess(data, f));
} else if (status === 202) {
const poll = () => {
dispatch(fetchMedia(data.id)).then(({ status, data }) => {
if (status === 200) {
dispatch(uploadComposeSuccess(data, f));
} else if (status === 206) {
setTimeout(() => poll(), 1000);
}
}).catch(error => dispatch(uploadComposeFail(error)));
};
poll();
}
});
}).catch(error => dispatch(uploadComposeFail(error)));
/* eslint-enable no-loop-func */
});
};
const changeUploadCompose = (id: string, params: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(changeUploadComposeRequest());
dispatch(updateMedia(id, params)).then(response => {
dispatch(changeUploadComposeSuccess(response.data));
}).catch(error => {
dispatch(changeUploadComposeFail(id, error));
});
};
const changeUploadComposeRequest = () => ({
type: COMPOSE_UPLOAD_CHANGE_REQUEST,
skipLoading: true,
});
const changeUploadComposeSuccess = (media: APIEntity) => ({
type: COMPOSE_UPLOAD_CHANGE_SUCCESS,
media: media,
skipLoading: true,
});
const changeUploadComposeFail = (id: string, error: AxiosError) => ({
type: COMPOSE_UPLOAD_CHANGE_FAIL,
id,
error: error,
skipLoading: true,
});
const uploadComposeRequest = () => ({
type: COMPOSE_UPLOAD_REQUEST,
skipLoading: true,
});
const uploadComposeProgress = (loaded: number, total: number) => ({
type: COMPOSE_UPLOAD_PROGRESS,
loaded: loaded,
total: total,
});
const uploadComposeSuccess = (media: APIEntity, file: File) => ({
type: COMPOSE_UPLOAD_SUCCESS,
media: media,
file,
skipLoading: true,
});
const uploadComposeFail = (error: AxiosError | true) => ({
type: COMPOSE_UPLOAD_FAIL,
error: error,
skipLoading: true,
});
const undoUploadCompose = (media_id: string) => ({
type: COMPOSE_UPLOAD_UNDO,
media_id: media_id,
});
const clearComposeSuggestions = () => {
if (cancelFetchComposeSuggestionsAccounts) {
cancelFetchComposeSuggestionsAccounts();
}
return {
type: COMPOSE_SUGGESTIONS_CLEAR,
};
};
const fetchComposeSuggestionsAccounts = throttle((dispatch, getState, token) => {
if (cancelFetchComposeSuggestionsAccounts) {
cancelFetchComposeSuggestionsAccounts();
}
api(getState).get('/api/v1/accounts/search', {
cancelToken: new CancelToken(cancel => {
cancelFetchComposeSuggestionsAccounts = cancel;
}),
params: {
q: token.slice(1),
resolve: false,
limit: 4,
},
}).then(response => {
dispatch(importFetchedAccounts(response.data));
dispatch(readyComposeSuggestionsAccounts(token, response.data));
}).catch(error => {
if (!isCancel(error)) {
dispatch(showAlertForError(error));
}
});
}, 200, { leading: true, trailing: true });
const fetchComposeSuggestionsEmojis = (dispatch: AppDispatch, getState: () => RootState, token: string) => {
const results = emojiSearch(token.replace(':', ''), { maxResults: 5 } as any);
dispatch(readyComposeSuggestionsEmojis(token, results));
};
const fetchComposeSuggestionsTags = (dispatch: AppDispatch, getState: () => RootState, token: string) => {
dispatch(updateSuggestionTags(token));
};
const fetchComposeSuggestions = (token: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
switch (token[0]) {
case ':':
fetchComposeSuggestionsEmojis(dispatch, getState, token);
break;
case '#':
fetchComposeSuggestionsTags(dispatch, getState, token);
break;
default:
fetchComposeSuggestionsAccounts(dispatch, getState, token);
break;
}
};
const readyComposeSuggestionsEmojis = (token: string, emojis: Emoji[]) => ({
type: COMPOSE_SUGGESTIONS_READY,
token,
emojis,
});
const readyComposeSuggestionsAccounts = (token: string, accounts: APIEntity[]) => ({
type: COMPOSE_SUGGESTIONS_READY,
token,
accounts,
});
const selectComposeSuggestion = (position: number, token: string | null, suggestion: AutoSuggestion, path: Array<string | number>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
let completion, startPosition;
if (typeof suggestion === 'object' && suggestion.id) {
completion = suggestion.native || suggestion.colons;
startPosition = position - 1;
dispatch(useEmoji(suggestion));
} else if (typeof suggestion === 'string' && suggestion[0] === '#') {
completion = suggestion;
startPosition = position - 1;
} else {
completion = getState().accounts.get(suggestion)!.acct;
startPosition = position;
}
dispatch({
type: COMPOSE_SUGGESTION_SELECT,
position: startPosition,
token,
completion,
path,
});
};
const updateSuggestionTags = (token: string) => ({
type: COMPOSE_SUGGESTION_TAGS_UPDATE,
token,
});
const updateTagHistory = (tags: string[]) => ({
type: COMPOSE_TAG_HISTORY_UPDATE,
tags,
});
const insertIntoTagHistory = (recognizedTags: APIEntity[], text: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const oldHistory = state.compose.tagHistory;
const me = state.me;
const names = recognizedTags
.filter(tag => text.match(new RegExp(`#${tag.name}`, 'i')))
.map(tag => tag.name);
const intersectedOldHistory = oldHistory.filter(name => names.findIndex(newName => newName.toLowerCase() === name.toLowerCase()) === -1);
names.push(...intersectedOldHistory.toJS());
const newHistory = names.slice(0, 1000);
tagHistory.set(me as string, newHistory);
dispatch(updateTagHistory(newHistory));
};
const mountCompose = () => ({
type: COMPOSE_MOUNT,
});
const unmountCompose = () => ({
type: COMPOSE_UNMOUNT,
});
const changeComposeSensitivity = () => ({
type: COMPOSE_SENSITIVITY_CHANGE,
});
const changeComposeSpoilerness = () => ({
type: COMPOSE_SPOILERNESS_CHANGE,
});
const changeComposeContentType = (value: string) => ({
type: COMPOSE_TYPE_CHANGE,
value,
});
const changeComposeSpoilerText = (text: string) => ({
type: COMPOSE_SPOILER_TEXT_CHANGE,
text,
});
const changeComposeVisibility = (value: string) => ({
type: COMPOSE_VISIBILITY_CHANGE,
value,
});
const insertEmojiCompose = (position: number, emoji: string, needsSpace: boolean) => ({
type: COMPOSE_EMOJI_INSERT,
position,
emoji,
needsSpace,
});
const changeComposing = (value: string) => ({
type: COMPOSE_COMPOSING_CHANGE,
value,
});
const addPoll = () => ({
type: COMPOSE_POLL_ADD,
});
const removePoll = () => ({
type: COMPOSE_POLL_REMOVE,
});
const addSchedule = () => ({
type: COMPOSE_SCHEDULE_ADD,
});
const setSchedule = (date: Date) => ({
type: COMPOSE_SCHEDULE_SET,
date: date,
});
const removeSchedule = () => ({
type: COMPOSE_SCHEDULE_REMOVE,
});
const addPollOption = (title: string) => ({
type: COMPOSE_POLL_OPTION_ADD,
title,
});
const changePollOption = (index: number, title: string) => ({
type: COMPOSE_POLL_OPTION_CHANGE,
index,
title,
});
const removePollOption = (index: number) => ({
type: COMPOSE_POLL_OPTION_REMOVE,
index,
});
const changePollSettings = (expiresIn?: string | number, isMultiple?: boolean) => ({
type: COMPOSE_POLL_SETTINGS_CHANGE,
expiresIn,
isMultiple,
});
const openComposeWithText = (text = '') =>
(dispatch: AppDispatch) => {
dispatch(resetCompose());
dispatch(openModal('COMPOSE'));
dispatch(changeCompose(text));
};
const addToMentions = (accountId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const acct = state.accounts.get(accountId)!.acct;
return dispatch({
type: COMPOSE_ADD_TO_MENTIONS,
account: acct,
});
};
const removeFromMentions = (accountId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const acct = state.accounts.get(accountId)!.acct;
return dispatch({
type: COMPOSE_REMOVE_FROM_MENTIONS,
account: acct,
});
};
export {
COMPOSE_CHANGE,
COMPOSE_SUBMIT_REQUEST,
COMPOSE_SUBMIT_SUCCESS,
COMPOSE_SUBMIT_FAIL,
COMPOSE_REPLY,
COMPOSE_REPLY_CANCEL,
COMPOSE_QUOTE,
COMPOSE_QUOTE_CANCEL,
COMPOSE_DIRECT,
COMPOSE_MENTION,
COMPOSE_RESET,
COMPOSE_UPLOAD_REQUEST,
COMPOSE_UPLOAD_SUCCESS,
COMPOSE_UPLOAD_FAIL,
COMPOSE_UPLOAD_PROGRESS,
COMPOSE_UPLOAD_UNDO,
COMPOSE_SUGGESTIONS_CLEAR,
COMPOSE_SUGGESTIONS_READY,
COMPOSE_SUGGESTION_SELECT,
COMPOSE_SUGGESTION_TAGS_UPDATE,
COMPOSE_TAG_HISTORY_UPDATE,
COMPOSE_MOUNT,
COMPOSE_UNMOUNT,
COMPOSE_SENSITIVITY_CHANGE,
COMPOSE_SPOILERNESS_CHANGE,
COMPOSE_TYPE_CHANGE,
COMPOSE_SPOILER_TEXT_CHANGE,
COMPOSE_VISIBILITY_CHANGE,
COMPOSE_LISTABILITY_CHANGE,
COMPOSE_COMPOSING_CHANGE,
COMPOSE_EMOJI_INSERT,
COMPOSE_UPLOAD_CHANGE_REQUEST,
COMPOSE_UPLOAD_CHANGE_SUCCESS,
COMPOSE_UPLOAD_CHANGE_FAIL,
COMPOSE_POLL_ADD,
COMPOSE_POLL_REMOVE,
COMPOSE_POLL_OPTION_ADD,
COMPOSE_POLL_OPTION_CHANGE,
COMPOSE_POLL_OPTION_REMOVE,
COMPOSE_POLL_SETTINGS_CHANGE,
COMPOSE_SCHEDULE_ADD,
COMPOSE_SCHEDULE_SET,
COMPOSE_SCHEDULE_REMOVE,
COMPOSE_ADD_TO_MENTIONS,
COMPOSE_REMOVE_FROM_MENTIONS,
COMPOSE_SET_STATUS,
ensureComposeIsVisible,
setComposeToStatus,
changeCompose,
replyCompose,
cancelReplyCompose,
quoteCompose,
cancelQuoteCompose,
resetCompose,
mentionCompose,
directCompose,
directComposeById,
handleComposeSubmit,
submitCompose,
submitComposeRequest,
submitComposeSuccess,
submitComposeFail,
uploadCompose,
changeUploadCompose,
changeUploadComposeRequest,
changeUploadComposeSuccess,
changeUploadComposeFail,
uploadComposeRequest,
uploadComposeProgress,
uploadComposeSuccess,
uploadComposeFail,
undoUploadCompose,
clearComposeSuggestions,
fetchComposeSuggestions,
readyComposeSuggestionsEmojis,
readyComposeSuggestionsAccounts,
selectComposeSuggestion,
updateSuggestionTags,
updateTagHistory,
mountCompose,
unmountCompose,
changeComposeSensitivity,
changeComposeSpoilerness,
changeComposeContentType,
changeComposeSpoilerText,
changeComposeVisibility,
insertEmojiCompose,
changeComposing,
addPoll,
removePoll,
addSchedule,
setSchedule,
removeSchedule,
addPollOption,
changePollOption,
removePollOption,
changePollSettings,
openComposeWithText,
addToMentions,
removeFromMentions,
};

91
app/soapbox/actions/conversations.js
View File

@ -1,91 +0,0 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api, { getLinks } from '../api';
import {
importFetchedAccounts,
importFetchedStatuses,
importFetchedStatus,
} from './importer';
export const CONVERSATIONS_MOUNT = 'CONVERSATIONS_MOUNT';
export const CONVERSATIONS_UNMOUNT = 'CONVERSATIONS_UNMOUNT';
export const CONVERSATIONS_FETCH_REQUEST = 'CONVERSATIONS_FETCH_REQUEST';
export const CONVERSATIONS_FETCH_SUCCESS = 'CONVERSATIONS_FETCH_SUCCESS';
export const CONVERSATIONS_FETCH_FAIL = 'CONVERSATIONS_FETCH_FAIL';
export const CONVERSATIONS_UPDATE = 'CONVERSATIONS_UPDATE';
export const CONVERSATIONS_READ = 'CONVERSATIONS_READ';
export const mountConversations = () => ({
type: CONVERSATIONS_MOUNT,
});
export const unmountConversations = () => ({
type: CONVERSATIONS_UNMOUNT,
});
export const markConversationRead = conversationId => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch({
type: CONVERSATIONS_READ,
id: conversationId,
});
api(getState).post(`/api/v1/conversations/${conversationId}/read`);
};
export const expandConversations = ({ maxId } = {}) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(expandConversationsRequest());
const params = { max_id: maxId };
if (!maxId) {
params.since_id = getState().getIn(['conversations', 'items', 0, 'id']);
}
const isLoadingRecent = !!params.since_id;
api(getState).get('/api/v1/conversations', { params })
.then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data.reduce((aggr, item) => aggr.concat(item.accounts), [])));
dispatch(importFetchedStatuses(response.data.map(item => item.last_status).filter(x => !!x)));
dispatch(expandConversationsSuccess(response.data, next ? next.uri : null, isLoadingRecent));
})
.catch(err => dispatch(expandConversationsFail(err)));
};
export const expandConversationsRequest = () => ({
type: CONVERSATIONS_FETCH_REQUEST,
});
export const expandConversationsSuccess = (conversations, next, isLoadingRecent) => ({
type: CONVERSATIONS_FETCH_SUCCESS,
conversations,
next,
isLoadingRecent,
});
export const expandConversationsFail = error => ({
type: CONVERSATIONS_FETCH_FAIL,
error,
});
export const updateConversations = conversation => dispatch => {
dispatch(importFetchedAccounts(conversation.accounts));
if (conversation.last_status) {
dispatch(importFetchedStatus(conversation.last_status));
}
dispatch({
type: CONVERSATIONS_UPDATE,
conversation,
});
};

113
app/soapbox/actions/conversations.ts Normal file
View File

@ -0,0 +1,113 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api, { getLinks } from '../api';
import {
importFetchedAccounts,
importFetchedStatuses,
importFetchedStatus,
} from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const CONVERSATIONS_MOUNT = 'CONVERSATIONS_MOUNT';
const CONVERSATIONS_UNMOUNT = 'CONVERSATIONS_UNMOUNT';
const CONVERSATIONS_FETCH_REQUEST = 'CONVERSATIONS_FETCH_REQUEST';
const CONVERSATIONS_FETCH_SUCCESS = 'CONVERSATIONS_FETCH_SUCCESS';
const CONVERSATIONS_FETCH_FAIL = 'CONVERSATIONS_FETCH_FAIL';
const CONVERSATIONS_UPDATE = 'CONVERSATIONS_UPDATE';
const CONVERSATIONS_READ = 'CONVERSATIONS_READ';
const mountConversations = () => ({
type: CONVERSATIONS_MOUNT,
});
const unmountConversations = () => ({
type: CONVERSATIONS_UNMOUNT,
});
const markConversationRead = (conversationId: string) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch({
type: CONVERSATIONS_READ,
id: conversationId,
});
api(getState).post(`/api/v1/conversations/${conversationId}/read`);
};
const expandConversations = ({ maxId }: Record<string, any> = {}) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(expandConversationsRequest());
const params: Record<string, any> = { max_id: maxId };
if (!maxId) {
params.since_id = getState().conversations.getIn(['items', 0, 'id']);
}
const isLoadingRecent = !!params.since_id;
api(getState).get('/api/v1/conversations', { params })
.then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data.reduce((aggr: Array<APIEntity>, item: APIEntity) => aggr.concat(item.accounts), [])));
dispatch(importFetchedStatuses(response.data.map((item: Record<string, any>) => item.last_status).filter((x?: APIEntity) => !!x)));
dispatch(expandConversationsSuccess(response.data, next ? next.uri : null, isLoadingRecent));
})
.catch(err => dispatch(expandConversationsFail(err)));
};
const expandConversationsRequest = () => ({
type: CONVERSATIONS_FETCH_REQUEST,
});
const expandConversationsSuccess = (conversations: APIEntity[], next: string | null, isLoadingRecent: boolean) => ({
type: CONVERSATIONS_FETCH_SUCCESS,
conversations,
next,
isLoadingRecent,
});
const expandConversationsFail = (error: AxiosError) => ({
type: CONVERSATIONS_FETCH_FAIL,
error,
});
const updateConversations = (conversation: APIEntity) => (dispatch: AppDispatch) => {
dispatch(importFetchedAccounts(conversation.accounts));
if (conversation.last_status) {
dispatch(importFetchedStatus(conversation.last_status));
}
return dispatch({
type: CONVERSATIONS_UPDATE,
conversation,
});
};
export {
CONVERSATIONS_MOUNT,
CONVERSATIONS_UNMOUNT,
CONVERSATIONS_FETCH_REQUEST,
CONVERSATIONS_FETCH_SUCCESS,
CONVERSATIONS_FETCH_FAIL,
CONVERSATIONS_UPDATE,
CONVERSATIONS_READ,
mountConversations,
unmountConversations,
markConversationRead,
expandConversations,
expandConversationsRequest,
expandConversationsSuccess,
expandConversationsFail,
updateConversations,
};

43
app/soapbox/actions/custom_emojis.js
View File

@ -1,43 +0,0 @@
import api from '../api';
export const CUSTOM_EMOJIS_FETCH_REQUEST = 'CUSTOM_EMOJIS_FETCH_REQUEST';
export const CUSTOM_EMOJIS_FETCH_SUCCESS = 'CUSTOM_EMOJIS_FETCH_SUCCESS';
export const CUSTOM_EMOJIS_FETCH_FAIL = 'CUSTOM_EMOJIS_FETCH_FAIL';
export function fetchCustomEmojis() {
return (dispatch, getState) => {
const me = getState().get('me');
if (!me) return;
dispatch(fetchCustomEmojisRequest());
api(getState).get('/api/v1/custom_emojis').then(response => {
dispatch(fetchCustomEmojisSuccess(response.data));
}).catch(error => {
dispatch(fetchCustomEmojisFail(error));
});
};
}
export function fetchCustomEmojisRequest() {
return {
type: CUSTOM_EMOJIS_FETCH_REQUEST,
skipLoading: true,
};
}
export function fetchCustomEmojisSuccess(custom_emojis) {
return {
type: CUSTOM_EMOJIS_FETCH_SUCCESS,
custom_emojis,
skipLoading: true,
};
}
export function fetchCustomEmojisFail(error) {
return {
type: CUSTOM_EMOJIS_FETCH_FAIL,
error,
skipLoading: true,
};
}

50
app/soapbox/actions/custom_emojis.ts Normal file
View File

@ -0,0 +1,50 @@
import api from '../api';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const CUSTOM_EMOJIS_FETCH_REQUEST = 'CUSTOM_EMOJIS_FETCH_REQUEST';
const CUSTOM_EMOJIS_FETCH_SUCCESS = 'CUSTOM_EMOJIS_FETCH_SUCCESS';
const CUSTOM_EMOJIS_FETCH_FAIL = 'CUSTOM_EMOJIS_FETCH_FAIL';
const fetchCustomEmojis = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const me = getState().me;
if (!me) return;
dispatch(fetchCustomEmojisRequest());
api(getState).get('/api/v1/custom_emojis').then(response => {
dispatch(fetchCustomEmojisSuccess(response.data));
}).catch(error => {
dispatch(fetchCustomEmojisFail(error));
});
};
const fetchCustomEmojisRequest = () => ({
type: CUSTOM_EMOJIS_FETCH_REQUEST,
skipLoading: true,
});
const fetchCustomEmojisSuccess = (custom_emojis: APIEntity[]) => ({
type: CUSTOM_EMOJIS_FETCH_SUCCESS,
custom_emojis,
skipLoading: true,
});
const fetchCustomEmojisFail = (error: AxiosError) => ({
type: CUSTOM_EMOJIS_FETCH_FAIL,
error,
skipLoading: true,
});
export {
CUSTOM_EMOJIS_FETCH_REQUEST,
CUSTOM_EMOJIS_FETCH_SUCCESS,
CUSTOM_EMOJIS_FETCH_FAIL,
fetchCustomEmojis,
fetchCustomEmojisRequest,
fetchCustomEmojisSuccess,
fetchCustomEmojisFail,
};

62
app/soapbox/actions/directory.js
View File

@ -1,62 +0,0 @@
import api from '../api';
import { fetchRelationships } from './accounts';
import { importFetchedAccounts } from './importer';
export const DIRECTORY_FETCH_REQUEST = 'DIRECTORY_FETCH_REQUEST';
export const DIRECTORY_FETCH_SUCCESS = 'DIRECTORY_FETCH_SUCCESS';
export const DIRECTORY_FETCH_FAIL = 'DIRECTORY_FETCH_FAIL';
export const DIRECTORY_EXPAND_REQUEST = 'DIRECTORY_EXPAND_REQUEST';
export const DIRECTORY_EXPAND_SUCCESS = 'DIRECTORY_EXPAND_SUCCESS';
export const DIRECTORY_EXPAND_FAIL = 'DIRECTORY_EXPAND_FAIL';
export const fetchDirectory = params => (dispatch, getState) => {
dispatch(fetchDirectoryRequest());
api(getState).get('/api/v1/directory', { params: { ...params, limit: 20 } }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(fetchDirectorySuccess(data));
dispatch(fetchRelationships(data.map(x => x.id)));
}).catch(error => dispatch(fetchDirectoryFail(error)));
};
export const fetchDirectoryRequest = () => ({
type: DIRECTORY_FETCH_REQUEST,
});
export const fetchDirectorySuccess = accounts => ({
type: DIRECTORY_FETCH_SUCCESS,
accounts,
});
export const fetchDirectoryFail = error => ({
type: DIRECTORY_FETCH_FAIL,
error,
});
export const expandDirectory = params => (dispatch, getState) => {
dispatch(expandDirectoryRequest());
const loadedItems = getState().getIn(['user_lists', 'directory', 'items']).size;
api(getState).get('/api/v1/directory', { params: { ...params, offset: loadedItems, limit: 20 } }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(expandDirectorySuccess(data));
dispatch(fetchRelationships(data.map(x => x.id)));
}).catch(error => dispatch(expandDirectoryFail(error)));
};
export const expandDirectoryRequest = () => ({
type: DIRECTORY_EXPAND_REQUEST,
});
export const expandDirectorySuccess = accounts => ({
type: DIRECTORY_EXPAND_SUCCESS,
accounts,
});
export const expandDirectoryFail = error => ({
type: DIRECTORY_EXPAND_FAIL,
error,
});

85
app/soapbox/actions/directory.ts Normal file
View File

@ -0,0 +1,85 @@
import api from '../api';
import { fetchRelationships } from './accounts';
import { importFetchedAccounts } from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const DIRECTORY_FETCH_REQUEST = 'DIRECTORY_FETCH_REQUEST';
const DIRECTORY_FETCH_SUCCESS = 'DIRECTORY_FETCH_SUCCESS';
const DIRECTORY_FETCH_FAIL = 'DIRECTORY_FETCH_FAIL';
const DIRECTORY_EXPAND_REQUEST = 'DIRECTORY_EXPAND_REQUEST';
const DIRECTORY_EXPAND_SUCCESS = 'DIRECTORY_EXPAND_SUCCESS';
const DIRECTORY_EXPAND_FAIL = 'DIRECTORY_EXPAND_FAIL';
const fetchDirectory = (params: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(fetchDirectoryRequest());
api(getState).get('/api/v1/directory', { params: { ...params, limit: 20 } }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(fetchDirectorySuccess(data));
dispatch(fetchRelationships(data.map((x: APIEntity) => x.id)));
}).catch(error => dispatch(fetchDirectoryFail(error)));
};
const fetchDirectoryRequest = () => ({
type: DIRECTORY_FETCH_REQUEST,
});
const fetchDirectorySuccess = (accounts: APIEntity[]) => ({
type: DIRECTORY_FETCH_SUCCESS,
accounts,
});
const fetchDirectoryFail = (error: AxiosError) => ({
type: DIRECTORY_FETCH_FAIL,
error,
});
const expandDirectory = (params: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(expandDirectoryRequest());
const loadedItems = getState().user_lists.getIn(['directory', 'items']).size;
api(getState).get('/api/v1/directory', { params: { ...params, offset: loadedItems, limit: 20 } }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(expandDirectorySuccess(data));
dispatch(fetchRelationships(data.map((x: APIEntity) => x.id)));
}).catch(error => dispatch(expandDirectoryFail(error)));
};
const expandDirectoryRequest = () => ({
type: DIRECTORY_EXPAND_REQUEST,
});
const expandDirectorySuccess = (accounts: APIEntity[]) => ({
type: DIRECTORY_EXPAND_SUCCESS,
accounts,
});
const expandDirectoryFail = (error: AxiosError) => ({
type: DIRECTORY_EXPAND_FAIL,
error,
});
export {
DIRECTORY_FETCH_REQUEST,
DIRECTORY_FETCH_SUCCESS,
DIRECTORY_FETCH_FAIL,
DIRECTORY_EXPAND_REQUEST,
DIRECTORY_EXPAND_SUCCESS,
DIRECTORY_EXPAND_FAIL,
fetchDirectory,
fetchDirectoryRequest,
fetchDirectorySuccess,
fetchDirectoryFail,
expandDirectory,
expandDirectoryRequest,
expandDirectorySuccess,
expandDirectoryFail,
};

181
app/soapbox/actions/domain_blocks.js
View File

@ -1,181 +0,0 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api, { getLinks } from '../api';
export const DOMAIN_BLOCK_REQUEST = 'DOMAIN_BLOCK_REQUEST';
export const DOMAIN_BLOCK_SUCCESS = 'DOMAIN_BLOCK_SUCCESS';
export const DOMAIN_BLOCK_FAIL = 'DOMAIN_BLOCK_FAIL';
export const DOMAIN_UNBLOCK_REQUEST = 'DOMAIN_UNBLOCK_REQUEST';
export const DOMAIN_UNBLOCK_SUCCESS = 'DOMAIN_UNBLOCK_SUCCESS';
export const DOMAIN_UNBLOCK_FAIL = 'DOMAIN_UNBLOCK_FAIL';
export const DOMAIN_BLOCKS_FETCH_REQUEST = 'DOMAIN_BLOCKS_FETCH_REQUEST';
export const DOMAIN_BLOCKS_FETCH_SUCCESS = 'DOMAIN_BLOCKS_FETCH_SUCCESS';
export const DOMAIN_BLOCKS_FETCH_FAIL = 'DOMAIN_BLOCKS_FETCH_FAIL';
export const DOMAIN_BLOCKS_EXPAND_REQUEST = 'DOMAIN_BLOCKS_EXPAND_REQUEST';
export const DOMAIN_BLOCKS_EXPAND_SUCCESS = 'DOMAIN_BLOCKS_EXPAND_SUCCESS';
export const DOMAIN_BLOCKS_EXPAND_FAIL = 'DOMAIN_BLOCKS_EXPAND_FAIL';
export function blockDomain(domain) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(blockDomainRequest(domain));
api(getState).post('/api/v1/domain_blocks', { domain }).then(() => {
const at_domain = '@' + domain;
const accounts = getState().get('accounts').filter(item => item.get('acct').endsWith(at_domain)).valueSeq().map(item => item.get('id'));
dispatch(blockDomainSuccess(domain, accounts));
}).catch(err => {
dispatch(blockDomainFail(domain, err));
});
};
}
export function blockDomainRequest(domain) {
return {
type: DOMAIN_BLOCK_REQUEST,
domain,
};
}
export function blockDomainSuccess(domain, accounts) {
return {
type: DOMAIN_BLOCK_SUCCESS,
domain,
accounts,
};
}
export function blockDomainFail(domain, error) {
return {
type: DOMAIN_BLOCK_FAIL,
domain,
error,
};
}
export function unblockDomain(domain) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(unblockDomainRequest(domain));
// Do it both ways for maximum compatibility
const params = {
params: { domain },
data: { domain },
};
api(getState).delete('/api/v1/domain_blocks', params).then(() => {
const at_domain = '@' + domain;
const accounts = getState().get('accounts').filter(item => item.get('acct').endsWith(at_domain)).valueSeq().map(item => item.get('id'));
dispatch(unblockDomainSuccess(domain, accounts));
}).catch(err => {
dispatch(unblockDomainFail(domain, err));
});
};
}
export function unblockDomainRequest(domain) {
return {
type: DOMAIN_UNBLOCK_REQUEST,
domain,
};
}
export function unblockDomainSuccess(domain, accounts) {
return {
type: DOMAIN_UNBLOCK_SUCCESS,
domain,
accounts,
};
}
export function unblockDomainFail(domain, error) {
return {
type: DOMAIN_UNBLOCK_FAIL,
domain,
error,
};
}
export function fetchDomainBlocks() {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchDomainBlocksRequest());
api(getState).get('/api/v1/domain_blocks').then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(fetchDomainBlocksSuccess(response.data, next ? next.uri : null));
}).catch(err => {
dispatch(fetchDomainBlocksFail(err));
});
};
}
export function fetchDomainBlocksRequest() {
return {
type: DOMAIN_BLOCKS_FETCH_REQUEST,
};
}
export function fetchDomainBlocksSuccess(domains, next) {
return {
type: DOMAIN_BLOCKS_FETCH_SUCCESS,
domains,
next,
};
}
export function fetchDomainBlocksFail(error) {
return {
type: DOMAIN_BLOCKS_FETCH_FAIL,
error,
};
}
export function expandDomainBlocks() {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const url = getState().domain_lists.blocks.next;
if (!url) {
return;
}
dispatch(expandDomainBlocksRequest());
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(expandDomainBlocksSuccess(response.data, next ? next.uri : null));
}).catch(err => {
dispatch(expandDomainBlocksFail(err));
});
};
}
export function expandDomainBlocksRequest() {
return {
type: DOMAIN_BLOCKS_EXPAND_REQUEST,
};
}
export function expandDomainBlocksSuccess(domains, next) {
return {
type: DOMAIN_BLOCKS_EXPAND_SUCCESS,
domains,
next,
};
}
export function expandDomainBlocksFail(error) {
return {
type: DOMAIN_BLOCKS_EXPAND_FAIL,
error,
};
}

188
app/soapbox/actions/domain_blocks.ts Normal file
View File

@ -0,0 +1,188 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api, { getLinks } from '../api';
import type { AxiosError } from 'axios';
import type { List as ImmutableList } from 'immutable';
import type { AppDispatch, RootState } from 'soapbox/store';
const DOMAIN_BLOCK_REQUEST = 'DOMAIN_BLOCK_REQUEST';
const DOMAIN_BLOCK_SUCCESS = 'DOMAIN_BLOCK_SUCCESS';
const DOMAIN_BLOCK_FAIL = 'DOMAIN_BLOCK_FAIL';
const DOMAIN_UNBLOCK_REQUEST = 'DOMAIN_UNBLOCK_REQUEST';
const DOMAIN_UNBLOCK_SUCCESS = 'DOMAIN_UNBLOCK_SUCCESS';
const DOMAIN_UNBLOCK_FAIL = 'DOMAIN_UNBLOCK_FAIL';
const DOMAIN_BLOCKS_FETCH_REQUEST = 'DOMAIN_BLOCKS_FETCH_REQUEST';
const DOMAIN_BLOCKS_FETCH_SUCCESS = 'DOMAIN_BLOCKS_FETCH_SUCCESS';
const DOMAIN_BLOCKS_FETCH_FAIL = 'DOMAIN_BLOCKS_FETCH_FAIL';
const DOMAIN_BLOCKS_EXPAND_REQUEST = 'DOMAIN_BLOCKS_EXPAND_REQUEST';
const DOMAIN_BLOCKS_EXPAND_SUCCESS = 'DOMAIN_BLOCKS_EXPAND_SUCCESS';
const DOMAIN_BLOCKS_EXPAND_FAIL = 'DOMAIN_BLOCKS_EXPAND_FAIL';
const blockDomain = (domain: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(blockDomainRequest(domain));
api(getState).post('/api/v1/domain_blocks', { domain }).then(() => {
const at_domain = '@' + domain;
const accounts = getState().accounts.filter(item => item.acct.endsWith(at_domain)).valueSeq().map(item => item.id);
dispatch(blockDomainSuccess(domain, accounts.toList()));
}).catch(err => {
dispatch(blockDomainFail(domain, err));
});
};
const blockDomainRequest = (domain: string) => ({
type: DOMAIN_BLOCK_REQUEST,
domain,
});
const blockDomainSuccess = (domain: string, accounts: ImmutableList<string>) => ({
type: DOMAIN_BLOCK_SUCCESS,
domain,
accounts,
});
const blockDomainFail = (domain: string, error: AxiosError) => ({
type: DOMAIN_BLOCK_FAIL,
domain,
error,
});
const unblockDomain = (domain: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(unblockDomainRequest(domain));
// Do it both ways for maximum compatibility
const params = {
params: { domain },
data: { domain },
};
api(getState).delete('/api/v1/domain_blocks', params).then(() => {
const at_domain = '@' + domain;
const accounts = getState().accounts.filter(item => item.get('acct').endsWith(at_domain)).valueSeq().map(item => item.get('id'));
dispatch(unblockDomainSuccess(domain, accounts.toList()));
}).catch(err => {
dispatch(unblockDomainFail(domain, err));
});
};
const unblockDomainRequest = (domain: string) => ({
type: DOMAIN_UNBLOCK_REQUEST,
domain,
});
const unblockDomainSuccess = (domain: string, accounts: ImmutableList<string>) => ({
type: DOMAIN_UNBLOCK_SUCCESS,
domain,
accounts,
});
const unblockDomainFail = (domain: string, error: AxiosError) => ({
type: DOMAIN_UNBLOCK_FAIL,
domain,
error,
});
const fetchDomainBlocks = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchDomainBlocksRequest());
api(getState).get('/api/v1/domain_blocks').then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(fetchDomainBlocksSuccess(response.data, next ? next.uri : null));
}).catch(err => {
dispatch(fetchDomainBlocksFail(err));
});
};
const fetchDomainBlocksRequest = () => ({
type: DOMAIN_BLOCKS_FETCH_REQUEST,
});
const fetchDomainBlocksSuccess = (domains: string[], next: string | null) => ({
type: DOMAIN_BLOCKS_FETCH_SUCCESS,
domains,
next,
});
const fetchDomainBlocksFail = (error: AxiosError) => ({
type: DOMAIN_BLOCKS_FETCH_FAIL,
error,
});
const expandDomainBlocks = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const url = getState().domain_lists.blocks.next;
if (!url) {
return;
}
dispatch(expandDomainBlocksRequest());
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(expandDomainBlocksSuccess(response.data, next ? next.uri : null));
}).catch(err => {
dispatch(expandDomainBlocksFail(err));
});
};
const expandDomainBlocksRequest = () => ({
type: DOMAIN_BLOCKS_EXPAND_REQUEST,
});
const expandDomainBlocksSuccess = (domains: string[], next: string | null) => ({
type: DOMAIN_BLOCKS_EXPAND_SUCCESS,
domains,
next,
});
const expandDomainBlocksFail = (error: AxiosError) => ({
type: DOMAIN_BLOCKS_EXPAND_FAIL,
error,
});
export {
DOMAIN_BLOCK_REQUEST,
DOMAIN_BLOCK_SUCCESS,
DOMAIN_BLOCK_FAIL,
DOMAIN_UNBLOCK_REQUEST,
DOMAIN_UNBLOCK_SUCCESS,
DOMAIN_UNBLOCK_FAIL,
DOMAIN_BLOCKS_FETCH_REQUEST,
DOMAIN_BLOCKS_FETCH_SUCCESS,
DOMAIN_BLOCKS_FETCH_FAIL,
DOMAIN_BLOCKS_EXPAND_REQUEST,
DOMAIN_BLOCKS_EXPAND_SUCCESS,
DOMAIN_BLOCKS_EXPAND_FAIL,
blockDomain,
blockDomainRequest,
blockDomainSuccess,
blockDomainFail,
unblockDomain,
unblockDomainRequest,
unblockDomainSuccess,
unblockDomainFail,
fetchDomainBlocks,
fetchDomainBlocksRequest,
fetchDomainBlocksSuccess,
fetchDomainBlocksFail,
expandDomainBlocks,
expandDomainBlocksRequest,
expandDomainBlocksSuccess,
expandDomainBlocksFail,
};

10
app/soapbox/actions/dropdown_menu.js
View File

@ -1,10 +0,0 @@
export const DROPDOWN_MENU_OPEN = 'DROPDOWN_MENU_OPEN';
export const DROPDOWN_MENU_CLOSE = 'DROPDOWN_MENU_CLOSE';
export function openDropdownMenu(id, placement, keyboard) {
return { type: DROPDOWN_MENU_OPEN, id, placement, keyboard };
}
export function closeDropdownMenu(id) {
return { type: DROPDOWN_MENU_CLOSE, id };
}

17
app/soapbox/actions/dropdown_menu.ts Normal file
View File

@ -0,0 +1,17 @@
import type { DropdownPlacement } from 'soapbox/components/dropdown_menu';
const DROPDOWN_MENU_OPEN = 'DROPDOWN_MENU_OPEN';
const DROPDOWN_MENU_CLOSE = 'DROPDOWN_MENU_CLOSE';
const openDropdownMenu = (id: number, placement: DropdownPlacement, keyboard: boolean) =>
({ type: DROPDOWN_MENU_OPEN, id, placement, keyboard });
const closeDropdownMenu = (id: number) =>
({ type: DROPDOWN_MENU_CLOSE, id });
export {
DROPDOWN_MENU_OPEN,
DROPDOWN_MENU_CLOSE,
openDropdownMenu,
closeDropdownMenu,
};

19
app/soapbox/actions/email_list.js
View File

@ -1,19 +0,0 @@
import api from '../api';
export function getSubscribersCsv() {
return (dispatch, getState) => {
return api(getState).get('/api/v1/pleroma/admin/email_list/subscribers.csv');
};
}
export function getUnsubscribersCsv() {
return (dispatch, getState) => {
return api(getState).get('/api/v1/pleroma/admin/email_list/unsubscribers.csv');
};
}
export function getCombinedCsv() {
return (dispatch, getState) => {
return api(getState).get('/api/v1/pleroma/admin/email_list/combined.csv');
};
}

21
app/soapbox/actions/email_list.ts Normal file
View File

@ -0,0 +1,21 @@
import api from '../api';
import type { RootState } from 'soapbox/store';
const getSubscribersCsv = () =>
(dispatch: any, getState: () => RootState) =>
api(getState).get('/api/v1/pleroma/admin/email_list/subscribers.csv');
const getUnsubscribersCsv = () =>
(dispatch: any, getState: () => RootState) =>
api(getState).get('/api/v1/pleroma/admin/email_list/unsubscribers.csv');
const getCombinedCsv = () =>
(dispatch: any, getState: () => RootState) =>
api(getState).get('/api/v1/pleroma/admin/email_list/combined.csv');
export {
getSubscribersCsv,
getUnsubscribersCsv,
getCombinedCsv,
};

182
app/soapbox/actions/emoji_reacts.js
View File

@ -1,182 +0,0 @@
import { List as ImmutableList } from 'immutable';
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import { importFetchedAccounts, importFetchedStatus } from './importer';
import { favourite, unfavourite } from './interactions';
export const EMOJI_REACT_REQUEST = 'EMOJI_REACT_REQUEST';
export const EMOJI_REACT_SUCCESS = 'EMOJI_REACT_SUCCESS';
export const EMOJI_REACT_FAIL = 'EMOJI_REACT_FAIL';
export const UNEMOJI_REACT_REQUEST = 'UNEMOJI_REACT_REQUEST';
export const UNEMOJI_REACT_SUCCESS = 'UNEMOJI_REACT_SUCCESS';
export const UNEMOJI_REACT_FAIL = 'UNEMOJI_REACT_FAIL';
export const EMOJI_REACTS_FETCH_REQUEST = 'EMOJI_REACTS_FETCH_REQUEST';
export const EMOJI_REACTS_FETCH_SUCCESS = 'EMOJI_REACTS_FETCH_SUCCESS';
export const EMOJI_REACTS_FETCH_FAIL = 'EMOJI_REACTS_FETCH_FAIL';
const noOp = () => () => new Promise(f => f());
export const simpleEmojiReact = (status, emoji) => {
return (dispatch, getState) => {
const emojiReacts = status.getIn(['pleroma', 'emoji_reactions'], ImmutableList());
if (emoji === '👍' && status.get('favourited')) return dispatch(unfavourite(status));
const undo = emojiReacts.filter(e => e.get('me') === true && e.get('name') === emoji).count() > 0;
if (undo) return dispatch(unEmojiReact(status, emoji));
return Promise.all(
emojiReacts
.filter(emojiReact => emojiReact.get('me') === true)
.map(emojiReact => dispatch(unEmojiReact(status, emojiReact.get('name')))),
status.get('favourited') && dispatch(unfavourite(status)),
).then(() => {
if (emoji === '👍') {
dispatch(favourite(status));
} else {
dispatch(emojiReact(status, emoji));
}
}).catch(err => {
console.error(err);
});
};
};
export function fetchEmojiReacts(id, emoji) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return dispatch(noOp());
dispatch(fetchEmojiReactsRequest(id, emoji));
const url = emoji
? `/api/v1/pleroma/statuses/${id}/reactions/${emoji}`
: `/api/v1/pleroma/statuses/${id}/reactions`;
return api(getState).get(url).then(response => {
response.data.forEach(emojiReact => {
dispatch(importFetchedAccounts(emojiReact.accounts));
});
dispatch(fetchEmojiReactsSuccess(id, response.data));
}).catch(error => {
dispatch(fetchEmojiReactsFail(id, error));
});
};
}
export function emojiReact(status, emoji) {
return function(dispatch, getState) {
if (!isLoggedIn(getState)) return dispatch(noOp());
dispatch(emojiReactRequest(status, emoji));
return api(getState)
.put(`/api/v1/pleroma/statuses/${status.get('id')}/reactions/${emoji}`)
.then(function(response) {
dispatch(importFetchedStatus(response.data));
dispatch(emojiReactSuccess(status, emoji));
}).catch(function(error) {
dispatch(emojiReactFail(status, emoji, error));
});
};
}
export function unEmojiReact(status, emoji) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return dispatch(noOp());
dispatch(unEmojiReactRequest(status, emoji));
return api(getState)
.delete(`/api/v1/pleroma/statuses/${status.get('id')}/reactions/${emoji}`)
.then(response => {
dispatch(importFetchedStatus(response.data));
dispatch(unEmojiReactSuccess(status, emoji));
}).catch(error => {
dispatch(unEmojiReactFail(status, emoji, error));
});
};
}
export function fetchEmojiReactsRequest(id, emoji) {
return {
type: EMOJI_REACTS_FETCH_REQUEST,
id,
emoji,
};
}
export function fetchEmojiReactsSuccess(id, emojiReacts) {
return {
type: EMOJI_REACTS_FETCH_SUCCESS,
id,
emojiReacts,
};
}
export function fetchEmojiReactsFail(id, error) {
return {
type: EMOJI_REACTS_FETCH_FAIL,
error,
};
}
export function emojiReactRequest(status, emoji) {
return {
type: EMOJI_REACT_REQUEST,
status,
emoji,
skipLoading: true,
};
}
export function emojiReactSuccess(status, emoji) {
return {
type: EMOJI_REACT_SUCCESS,
status,
emoji,
skipLoading: true,
};
}
export function emojiReactFail(status, emoji, error) {
return {
type: EMOJI_REACT_FAIL,
status,
emoji,
error,
skipLoading: true,
};
}
export function unEmojiReactRequest(status, emoji) {
return {
type: UNEMOJI_REACT_REQUEST,
status,
emoji,
skipLoading: true,
};
}
export function unEmojiReactSuccess(status, emoji) {
return {
type: UNEMOJI_REACT_SUCCESS,
status,
emoji,
skipLoading: true,
};
}
export function unEmojiReactFail(status, emoji, error) {
return {
type: UNEMOJI_REACT_FAIL,
status,
emoji,
error,
skipLoading: true,
};
}

190
app/soapbox/actions/emoji_reacts.ts Normal file
View File

@ -0,0 +1,190 @@
import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import { importFetchedAccounts, importFetchedStatus } from './importer';
import { favourite, unfavourite } from './interactions';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity, Status } from 'soapbox/types/entities';
const EMOJI_REACT_REQUEST = 'EMOJI_REACT_REQUEST';
const EMOJI_REACT_SUCCESS = 'EMOJI_REACT_SUCCESS';
const EMOJI_REACT_FAIL = 'EMOJI_REACT_FAIL';
const UNEMOJI_REACT_REQUEST = 'UNEMOJI_REACT_REQUEST';
const UNEMOJI_REACT_SUCCESS = 'UNEMOJI_REACT_SUCCESS';
const UNEMOJI_REACT_FAIL = 'UNEMOJI_REACT_FAIL';
const EMOJI_REACTS_FETCH_REQUEST = 'EMOJI_REACTS_FETCH_REQUEST';
const EMOJI_REACTS_FETCH_SUCCESS = 'EMOJI_REACTS_FETCH_SUCCESS';
const EMOJI_REACTS_FETCH_FAIL = 'EMOJI_REACTS_FETCH_FAIL';
const noOp = () => () => new Promise(f => f(undefined));
const simpleEmojiReact = (status: Status, emoji: string) =>
(dispatch: AppDispatch) => {
const emojiReacts: ImmutableList<ImmutableMap<string, any>> = status.pleroma.get('emoji_reactions') || ImmutableList();
if (emoji === '👍' && status.favourited) return dispatch(unfavourite(status));
const undo = emojiReacts.filter(e => e.get('me') === true && e.get('name') === emoji).count() > 0;
if (undo) return dispatch(unEmojiReact(status, emoji));
return Promise.all([
...emojiReacts
.filter((emojiReact) => emojiReact.get('me') === true)
.map(emojiReact => dispatch(unEmojiReact(status, emojiReact.get('name')))).toArray(),
status.favourited && dispatch(unfavourite(status)),
]).then(() => {
if (emoji === '👍') {
dispatch(favourite(status));
} else {
dispatch(emojiReact(status, emoji));
}
}).catch(err => {
console.error(err);
});
};
const fetchEmojiReacts = (id: string, emoji: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return dispatch(noOp());
dispatch(fetchEmojiReactsRequest(id, emoji));
const url = emoji
? `/api/v1/pleroma/statuses/${id}/reactions/${emoji}`
: `/api/v1/pleroma/statuses/${id}/reactions`;
return api(getState).get(url).then(response => {
response.data.forEach((emojiReact: APIEntity) => {
dispatch(importFetchedAccounts(emojiReact.accounts));
});
dispatch(fetchEmojiReactsSuccess(id, response.data));
}).catch(error => {
dispatch(fetchEmojiReactsFail(id, error));
});
};
const emojiReact = (status: Status, emoji: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return dispatch(noOp());
dispatch(emojiReactRequest(status, emoji));
return api(getState)
.put(`/api/v1/pleroma/statuses/${status.get('id')}/reactions/${emoji}`)
.then(function(response) {
dispatch(importFetchedStatus(response.data));
dispatch(emojiReactSuccess(status, emoji));
}).catch(function(error) {
dispatch(emojiReactFail(status, emoji, error));
});
};
const unEmojiReact = (status: Status, emoji: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return dispatch(noOp());
dispatch(unEmojiReactRequest(status, emoji));
return api(getState)
.delete(`/api/v1/pleroma/statuses/${status.get('id')}/reactions/${emoji}`)
.then(response => {
dispatch(importFetchedStatus(response.data));
dispatch(unEmojiReactSuccess(status, emoji));
}).catch(error => {
dispatch(unEmojiReactFail(status, emoji, error));
});
};
const fetchEmojiReactsRequest = (id: string, emoji: string) => ({
type: EMOJI_REACTS_FETCH_REQUEST,
id,
emoji,
});
const fetchEmojiReactsSuccess = (id: string, emojiReacts: APIEntity[]) => ({
type: EMOJI_REACTS_FETCH_SUCCESS,
id,
emojiReacts,
});
const fetchEmojiReactsFail = (id: string, error: AxiosError) => ({
type: EMOJI_REACTS_FETCH_FAIL,
id,
error,
});
const emojiReactRequest = (status: Status, emoji: string) => ({
type: EMOJI_REACT_REQUEST,
status,
emoji,
skipLoading: true,
});
const emojiReactSuccess = (status: Status, emoji: string) => ({
type: EMOJI_REACT_SUCCESS,
status,
emoji,
skipLoading: true,
});
const emojiReactFail = (status: Status, emoji: string, error: AxiosError) => ({
type: EMOJI_REACT_FAIL,
status,
emoji,
error,
skipLoading: true,
});
const unEmojiReactRequest = (status: Status, emoji: string) => ({
type: UNEMOJI_REACT_REQUEST,
status,
emoji,
skipLoading: true,
});
const unEmojiReactSuccess = (status: Status, emoji: string) => ({
type: UNEMOJI_REACT_SUCCESS,
status,
emoji,
skipLoading: true,
});
const unEmojiReactFail = (status: Status, emoji: string, error: AxiosError) => ({
type: UNEMOJI_REACT_FAIL,
status,
emoji,
error,
skipLoading: true,
});
export {
EMOJI_REACT_REQUEST,
EMOJI_REACT_SUCCESS,
EMOJI_REACT_FAIL,
UNEMOJI_REACT_REQUEST,
UNEMOJI_REACT_SUCCESS,
UNEMOJI_REACT_FAIL,
EMOJI_REACTS_FETCH_REQUEST,
EMOJI_REACTS_FETCH_SUCCESS,
EMOJI_REACTS_FETCH_FAIL,
simpleEmojiReact,
fetchEmojiReacts,
emojiReact,
unEmojiReact,
fetchEmojiReactsRequest,
fetchEmojiReactsSuccess,
fetchEmojiReactsFail,
emojiReactRequest,
emojiReactSuccess,
emojiReactFail,
unEmojiReactRequest,
unEmojiReactSuccess,
unEmojiReactFail,
};

14
app/soapbox/actions/emojis.js
View File

@ -1,14 +0,0 @@
import { saveSettings } from './settings';
export const EMOJI_USE = 'EMOJI_USE';
export function useEmoji(emoji) {
return dispatch => {
dispatch({
type: EMOJI_USE,
emoji,
});
dispatch(saveSettings());
};
}

21
app/soapbox/actions/emojis.ts Normal file
View File

@ -0,0 +1,21 @@
import { saveSettings } from './settings';
import type { Emoji } from 'soapbox/components/autosuggest_emoji';
import type { AppDispatch } from 'soapbox/store';
const EMOJI_USE = 'EMOJI_USE';
const useEmoji = (emoji: Emoji) =>
(dispatch: AppDispatch) => {
dispatch({
type: EMOJI_USE,
emoji,
});
dispatch(saveSettings());
};
export {
EMOJI_USE,
useEmoji,
};

201
app/soapbox/actions/favourites.js
View File

@ -1,201 +0,0 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api, { getLinks } from '../api';
import { importFetchedStatuses } from './importer';
export const FAVOURITED_STATUSES_FETCH_REQUEST = 'FAVOURITED_STATUSES_FETCH_REQUEST';
export const FAVOURITED_STATUSES_FETCH_SUCCESS = 'FAVOURITED_STATUSES_FETCH_SUCCESS';
export const FAVOURITED_STATUSES_FETCH_FAIL = 'FAVOURITED_STATUSES_FETCH_FAIL';
export const FAVOURITED_STATUSES_EXPAND_REQUEST = 'FAVOURITED_STATUSES_EXPAND_REQUEST';
export const FAVOURITED_STATUSES_EXPAND_SUCCESS = 'FAVOURITED_STATUSES_EXPAND_SUCCESS';
export const FAVOURITED_STATUSES_EXPAND_FAIL = 'FAVOURITED_STATUSES_EXPAND_FAIL';
export const ACCOUNT_FAVOURITED_STATUSES_FETCH_REQUEST = 'ACCOUNT_FAVOURITED_STATUSES_FETCH_REQUEST';
export const ACCOUNT_FAVOURITED_STATUSES_FETCH_SUCCESS = 'ACCOUNT_FAVOURITED_STATUSES_FETCH_SUCCESS';
export const ACCOUNT_FAVOURITED_STATUSES_FETCH_FAIL = 'ACCOUNT_FAVOURITED_STATUSES_FETCH_FAIL';
export const ACCOUNT_FAVOURITED_STATUSES_EXPAND_REQUEST = 'ACCOUNT_FAVOURITED_STATUSES_EXPAND_REQUEST';
export const ACCOUNT_FAVOURITED_STATUSES_EXPAND_SUCCESS = 'ACCOUNT_FAVOURITED_STATUSES_EXPAND_SUCCESS';
export const ACCOUNT_FAVOURITED_STATUSES_EXPAND_FAIL = 'ACCOUNT_FAVOURITED_STATUSES_EXPAND_FAIL';
export function fetchFavouritedStatuses() {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
if (getState().getIn(['status_lists', 'favourites', 'isLoading'])) {
return;
}
dispatch(fetchFavouritedStatusesRequest());
api(getState).get('/api/v1/favourites').then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(fetchFavouritedStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(fetchFavouritedStatusesFail(error));
});
};
}
export function fetchFavouritedStatusesRequest() {
return {
type: FAVOURITED_STATUSES_FETCH_REQUEST,
skipLoading: true,
};
}
export function fetchFavouritedStatusesSuccess(statuses, next) {
return {
type: FAVOURITED_STATUSES_FETCH_SUCCESS,
statuses,
next,
skipLoading: true,
};
}
export function fetchFavouritedStatusesFail(error) {
return {
type: FAVOURITED_STATUSES_FETCH_FAIL,
error,
skipLoading: true,
};
}
export function expandFavouritedStatuses() {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const url = getState().getIn(['status_lists', 'favourites', 'next'], null);
if (url === null || getState().getIn(['status_lists', 'favourites', 'isLoading'])) {
return;
}
dispatch(expandFavouritedStatusesRequest());
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(expandFavouritedStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(expandFavouritedStatusesFail(error));
});
};
}
export function expandFavouritedStatusesRequest() {
return {
type: FAVOURITED_STATUSES_EXPAND_REQUEST,
};
}
export function expandFavouritedStatusesSuccess(statuses, next) {
return {
type: FAVOURITED_STATUSES_EXPAND_SUCCESS,
statuses,
next,
};
}
export function expandFavouritedStatusesFail(error) {
return {
type: FAVOURITED_STATUSES_EXPAND_FAIL,
error,
};
}
export function fetchAccountFavouritedStatuses(accountId) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
if (getState().getIn(['status_lists', `favourites:${accountId}`, 'isLoading'])) {
return;
}
dispatch(fetchAccountFavouritedStatusesRequest(accountId));
api(getState).get(`/api/v1/pleroma/accounts/${accountId}/favourites`).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(fetchAccountFavouritedStatusesSuccess(accountId, response.data, next ? next.uri : null));
}).catch(error => {
dispatch(fetchAccountFavouritedStatusesFail(accountId, error));
});
};
}
export function fetchAccountFavouritedStatusesRequest(accountId) {
return {
type: ACCOUNT_FAVOURITED_STATUSES_FETCH_REQUEST,
accountId,
skipLoading: true,
};
}
export function fetchAccountFavouritedStatusesSuccess(accountId, statuses, next) {
return {
type: ACCOUNT_FAVOURITED_STATUSES_FETCH_SUCCESS,
accountId,
statuses,
next,
skipLoading: true,
};
}
export function fetchAccountFavouritedStatusesFail(accountId, error) {
return {
type: ACCOUNT_FAVOURITED_STATUSES_FETCH_FAIL,
accountId,
error,
skipLoading: true,
};
}
export function expandAccountFavouritedStatuses(accountId) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const url = getState().getIn(['status_lists', `favourites:${accountId}`, 'next'], null);
if (url === null || getState().getIn(['status_lists', `favourites:${accountId}`, 'isLoading'])) {
return;
}
dispatch(expandAccountFavouritedStatusesRequest(accountId));
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(expandAccountFavouritedStatusesSuccess(accountId, response.data, next ? next.uri : null));
}).catch(error => {
dispatch(expandAccountFavouritedStatusesFail(accountId, error));
});
};
}
export function expandAccountFavouritedStatusesRequest(accountId) {
return {
type: ACCOUNT_FAVOURITED_STATUSES_EXPAND_REQUEST,
accountId,
};
}
export function expandAccountFavouritedStatusesSuccess(accountId, statuses, next) {
return {
type: ACCOUNT_FAVOURITED_STATUSES_EXPAND_SUCCESS,
accountId,
statuses,
next,
};
}
export function expandAccountFavouritedStatusesFail(accountId, error) {
return {
type: ACCOUNT_FAVOURITED_STATUSES_EXPAND_FAIL,
accountId,
error,
};
}

208
app/soapbox/actions/favourites.ts Normal file
View File

@ -0,0 +1,208 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api, { getLinks } from '../api';
import { importFetchedStatuses } from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const FAVOURITED_STATUSES_FETCH_REQUEST = 'FAVOURITED_STATUSES_FETCH_REQUEST';
const FAVOURITED_STATUSES_FETCH_SUCCESS = 'FAVOURITED_STATUSES_FETCH_SUCCESS';
const FAVOURITED_STATUSES_FETCH_FAIL = 'FAVOURITED_STATUSES_FETCH_FAIL';
const FAVOURITED_STATUSES_EXPAND_REQUEST = 'FAVOURITED_STATUSES_EXPAND_REQUEST';
const FAVOURITED_STATUSES_EXPAND_SUCCESS = 'FAVOURITED_STATUSES_EXPAND_SUCCESS';
const FAVOURITED_STATUSES_EXPAND_FAIL = 'FAVOURITED_STATUSES_EXPAND_FAIL';
const ACCOUNT_FAVOURITED_STATUSES_FETCH_REQUEST = 'ACCOUNT_FAVOURITED_STATUSES_FETCH_REQUEST';
const ACCOUNT_FAVOURITED_STATUSES_FETCH_SUCCESS = 'ACCOUNT_FAVOURITED_STATUSES_FETCH_SUCCESS';
const ACCOUNT_FAVOURITED_STATUSES_FETCH_FAIL = 'ACCOUNT_FAVOURITED_STATUSES_FETCH_FAIL';
const ACCOUNT_FAVOURITED_STATUSES_EXPAND_REQUEST = 'ACCOUNT_FAVOURITED_STATUSES_EXPAND_REQUEST';
const ACCOUNT_FAVOURITED_STATUSES_EXPAND_SUCCESS = 'ACCOUNT_FAVOURITED_STATUSES_EXPAND_SUCCESS';
const ACCOUNT_FAVOURITED_STATUSES_EXPAND_FAIL = 'ACCOUNT_FAVOURITED_STATUSES_EXPAND_FAIL';
const fetchFavouritedStatuses = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
if (getState().status_lists.get('favourites')?.isLoading) {
return;
}
dispatch(fetchFavouritedStatusesRequest());
api(getState).get('/api/v1/favourites').then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(fetchFavouritedStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(fetchFavouritedStatusesFail(error));
});
};
const fetchFavouritedStatusesRequest = () => ({
type: FAVOURITED_STATUSES_FETCH_REQUEST,
skipLoading: true,
});
const fetchFavouritedStatusesSuccess = (statuses: APIEntity[], next: string | null) => ({
type: FAVOURITED_STATUSES_FETCH_SUCCESS,
statuses,
next,
skipLoading: true,
});
const fetchFavouritedStatusesFail = (error: AxiosError) => ({
type: FAVOURITED_STATUSES_FETCH_FAIL,
error,
skipLoading: true,
});
const expandFavouritedStatuses = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const url = getState().status_lists.get('favourites')?.next || null;
if (url === null || getState().status_lists.get('favourites')?.isLoading) {
return;
}
dispatch(expandFavouritedStatusesRequest());
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(expandFavouritedStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(expandFavouritedStatusesFail(error));
});
};
const expandFavouritedStatusesRequest = () => ({
type: FAVOURITED_STATUSES_EXPAND_REQUEST,
});
const expandFavouritedStatusesSuccess = (statuses: APIEntity[], next: string | null) => ({
type: FAVOURITED_STATUSES_EXPAND_SUCCESS,
statuses,
next,
});
const expandFavouritedStatusesFail = (error: AxiosError) => ({
type: FAVOURITED_STATUSES_EXPAND_FAIL,
error,
});
const fetchAccountFavouritedStatuses = (accountId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
if (getState().status_lists.get(`favourites:${accountId}`)?.isLoading) {
return;
}
dispatch(fetchAccountFavouritedStatusesRequest(accountId));
api(getState).get(`/api/v1/pleroma/accounts/${accountId}/favourites`).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(fetchAccountFavouritedStatusesSuccess(accountId, response.data, next ? next.uri : null));
}).catch(error => {
dispatch(fetchAccountFavouritedStatusesFail(accountId, error));
});
};
const fetchAccountFavouritedStatusesRequest = (accountId: string) => ({
type: ACCOUNT_FAVOURITED_STATUSES_FETCH_REQUEST,
accountId,
skipLoading: true,
});
const fetchAccountFavouritedStatusesSuccess = (accountId: string, statuses: APIEntity, next: string | null) => ({
type: ACCOUNT_FAVOURITED_STATUSES_FETCH_SUCCESS,
accountId,
statuses,
next,
skipLoading: true,
});
const fetchAccountFavouritedStatusesFail = (accountId: string, error: AxiosError) => ({
type: ACCOUNT_FAVOURITED_STATUSES_FETCH_FAIL,
accountId,
error,
skipLoading: true,
});
const expandAccountFavouritedStatuses = (accountId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const url = getState().status_lists.get(`favourites:${accountId}`)?.next || null;
if (url === null || getState().status_lists.get(`favourites:${accountId}`)?.isLoading) {
return;
}
dispatch(expandAccountFavouritedStatusesRequest(accountId));
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedStatuses(response.data));
dispatch(expandAccountFavouritedStatusesSuccess(accountId, response.data, next ? next.uri : null));
}).catch(error => {
dispatch(expandAccountFavouritedStatusesFail(accountId, error));
});
};
const expandAccountFavouritedStatusesRequest = (accountId: string) => ({
type: ACCOUNT_FAVOURITED_STATUSES_EXPAND_REQUEST,
accountId,
});
const expandAccountFavouritedStatusesSuccess = (accountId: string, statuses: APIEntity[], next: string | null) => ({
type: ACCOUNT_FAVOURITED_STATUSES_EXPAND_SUCCESS,
accountId,
statuses,
next,
});
const expandAccountFavouritedStatusesFail = (accountId: string, error: AxiosError) => ({
type: ACCOUNT_FAVOURITED_STATUSES_EXPAND_FAIL,
accountId,
error,
});
export {
FAVOURITED_STATUSES_FETCH_REQUEST,
FAVOURITED_STATUSES_FETCH_SUCCESS,
FAVOURITED_STATUSES_FETCH_FAIL,
FAVOURITED_STATUSES_EXPAND_REQUEST,
FAVOURITED_STATUSES_EXPAND_SUCCESS,
FAVOURITED_STATUSES_EXPAND_FAIL,
ACCOUNT_FAVOURITED_STATUSES_FETCH_REQUEST,
ACCOUNT_FAVOURITED_STATUSES_FETCH_SUCCESS,
ACCOUNT_FAVOURITED_STATUSES_FETCH_FAIL,
ACCOUNT_FAVOURITED_STATUSES_EXPAND_REQUEST,
ACCOUNT_FAVOURITED_STATUSES_EXPAND_SUCCESS,
ACCOUNT_FAVOURITED_STATUSES_EXPAND_FAIL,
fetchFavouritedStatuses,
fetchFavouritedStatusesRequest,
fetchFavouritedStatusesSuccess,
fetchFavouritedStatusesFail,
expandFavouritedStatuses,
expandFavouritedStatusesRequest,
expandFavouritedStatusesSuccess,
expandFavouritedStatusesFail,
fetchAccountFavouritedStatuses,
fetchAccountFavouritedStatusesRequest,
fetchAccountFavouritedStatusesSuccess,
fetchAccountFavouritedStatusesFail,
expandAccountFavouritedStatuses,
expandAccountFavouritedStatusesRequest,
expandAccountFavouritedStatusesSuccess,
expandAccountFavouritedStatusesFail,
};

77
app/soapbox/actions/filters.js
View File

@ -1,77 +0,0 @@
import { defineMessages } from 'react-intl';
import snackbar from 'soapbox/actions/snackbar';
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
export const FILTERS_FETCH_REQUEST = 'FILTERS_FETCH_REQUEST';
export const FILTERS_FETCH_SUCCESS = 'FILTERS_FETCH_SUCCESS';
export const FILTERS_FETCH_FAIL = 'FILTERS_FETCH_FAIL';
export const FILTERS_CREATE_REQUEST = 'FILTERS_CREATE_REQUEST';
export const FILTERS_CREATE_SUCCESS = 'FILTERS_CREATE_SUCCESS';
export const FILTERS_CREATE_FAIL = 'FILTERS_CREATE_FAIL';
export const FILTERS_DELETE_REQUEST = 'FILTERS_DELETE_REQUEST';
export const FILTERS_DELETE_SUCCESS = 'FILTERS_DELETE_SUCCESS';
export const FILTERS_DELETE_FAIL = 'FILTERS_DELETE_FAIL';
const messages = defineMessages({
added: { id: 'filters.added', defaultMessage: 'Filter added.' },
removed: { id: 'filters.removed', defaultMessage: 'Filter deleted.' },
});
export const fetchFilters = () => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch({
type: FILTERS_FETCH_REQUEST,
skipLoading: true,
});
api(getState)
.get('/api/v1/filters')
.then(({ data }) => dispatch({
type: FILTERS_FETCH_SUCCESS,
filters: data,
skipLoading: true,
}))
.catch(err => dispatch({
type: FILTERS_FETCH_FAIL,
err,
skipLoading: true,
skipAlert: true,
}));
};
export function createFilter(intl, phrase, expires_at, context, whole_word, irreversible) {
return (dispatch, getState) => {
dispatch({ type: FILTERS_CREATE_REQUEST });
return api(getState).post('/api/v1/filters', {
phrase,
context,
irreversible,
whole_word,
expires_at,
}).then(response => {
dispatch({ type: FILTERS_CREATE_SUCCESS, filter: response.data });
dispatch(snackbar.success(intl.formatMessage(messages.added)));
}).catch(error => {
dispatch({ type: FILTERS_CREATE_FAIL, error });
});
};
}
export function deleteFilter(intl, id) {
return (dispatch, getState) => {
dispatch({ type: FILTERS_DELETE_REQUEST });
return api(getState).delete('/api/v1/filters/' + id).then(response => {
dispatch({ type: FILTERS_DELETE_SUCCESS, filter: response.data });
dispatch(snackbar.success(intl.formatMessage(messages.removed)));
}).catch(error => {
dispatch({ type: FILTERS_DELETE_FAIL, error });
});
};
}

93
app/soapbox/actions/filters.ts Normal file
View File

@ -0,0 +1,93 @@
import { defineMessages } from 'react-intl';
import snackbar from 'soapbox/actions/snackbar';
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import type { AppDispatch, RootState } from 'soapbox/store';
const FILTERS_FETCH_REQUEST = 'FILTERS_FETCH_REQUEST';
const FILTERS_FETCH_SUCCESS = 'FILTERS_FETCH_SUCCESS';
const FILTERS_FETCH_FAIL = 'FILTERS_FETCH_FAIL';
const FILTERS_CREATE_REQUEST = 'FILTERS_CREATE_REQUEST';
const FILTERS_CREATE_SUCCESS = 'FILTERS_CREATE_SUCCESS';
const FILTERS_CREATE_FAIL = 'FILTERS_CREATE_FAIL';
const FILTERS_DELETE_REQUEST = 'FILTERS_DELETE_REQUEST';
const FILTERS_DELETE_SUCCESS = 'FILTERS_DELETE_SUCCESS';
const FILTERS_DELETE_FAIL = 'FILTERS_DELETE_FAIL';
const messages = defineMessages({
added: { id: 'filters.added', defaultMessage: 'Filter added.' },
removed: { id: 'filters.removed', defaultMessage: 'Filter deleted.' },
});
const fetchFilters = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch({
type: FILTERS_FETCH_REQUEST,
skipLoading: true,
});
api(getState)
.get('/api/v1/filters')
.then(({ data }) => dispatch({
type: FILTERS_FETCH_SUCCESS,
filters: data,
skipLoading: true,
}))
.catch(err => dispatch({
type: FILTERS_FETCH_FAIL,
err,
skipLoading: true,
skipAlert: true,
}));
};
const createFilter = (phrase: string, expires_at: string, context: Array<string>, whole_word: boolean, irreversible: boolean) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: FILTERS_CREATE_REQUEST });
return api(getState).post('/api/v1/filters', {
phrase,
context,
irreversible,
whole_word,
expires_at,
}).then(response => {
dispatch({ type: FILTERS_CREATE_SUCCESS, filter: response.data });
dispatch(snackbar.success(messages.added));
}).catch(error => {
dispatch({ type: FILTERS_CREATE_FAIL, error });
});
};
const deleteFilter = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: FILTERS_DELETE_REQUEST });
return api(getState).delete(`/api/v1/filters/${id}`).then(response => {
dispatch({ type: FILTERS_DELETE_SUCCESS, filter: response.data });
dispatch(snackbar.success(messages.removed));
}).catch(error => {
dispatch({ type: FILTERS_DELETE_FAIL, error });
});
};
export {
FILTERS_FETCH_REQUEST,
FILTERS_FETCH_SUCCESS,
FILTERS_FETCH_FAIL,
FILTERS_CREATE_REQUEST,
FILTERS_CREATE_SUCCESS,
FILTERS_CREATE_FAIL,
FILTERS_DELETE_REQUEST,
FILTERS_DELETE_SUCCESS,
FILTERS_DELETE_FAIL,
fetchFilters,
createFilter,
deleteFilter,
};

111
app/soapbox/actions/group_editor.js
View File

@ -1,111 +0,0 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
export const GROUP_CREATE_REQUEST = 'GROUP_CREATE_REQUEST';
export const GROUP_CREATE_SUCCESS = 'GROUP_CREATE_SUCCESS';
export const GROUP_CREATE_FAIL = 'GROUP_CREATE_FAIL';
export const GROUP_UPDATE_REQUEST = 'GROUP_UPDATE_REQUEST';
export const GROUP_UPDATE_SUCCESS = 'GROUP_UPDATE_SUCCESS';
export const GROUP_UPDATE_FAIL = 'GROUP_UPDATE_FAIL';
export const GROUP_EDITOR_VALUE_CHANGE = 'GROUP_EDITOR_VALUE_CHANGE';
export const GROUP_EDITOR_RESET = 'GROUP_EDITOR_RESET';
export const GROUP_EDITOR_SETUP = 'GROUP_EDITOR_SETUP';
export const submit = (routerHistory) => (dispatch, getState) => {
const groupId = getState().getIn(['group_editor', 'groupId']);
const title = getState().getIn(['group_editor', 'title']);
const description = getState().getIn(['group_editor', 'description']);
const coverImage = getState().getIn(['group_editor', 'coverImage']);
if (groupId === null) {
dispatch(create(title, description, coverImage, routerHistory));
} else {
dispatch(update(groupId, title, description, coverImage, routerHistory));
}
};
export const create = (title, description, coverImage, routerHistory) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(createRequest());
const formData = new FormData();
formData.append('title', title);
formData.append('description', description);
if (coverImage !== null) {
formData.append('cover_image', coverImage);
}
api(getState).post('/api/v1/groups', formData, { headers: { 'Content-Type': 'multipart/form-data' } }).then(({ data }) => {
dispatch(createSuccess(data));
routerHistory.push(`/groups/${data.id}`);
}).catch(err => dispatch(createFail(err)));
};
export const createRequest = id => ({
type: GROUP_CREATE_REQUEST,
id,
});
export const createSuccess = group => ({
type: GROUP_CREATE_SUCCESS,
group,
});
export const createFail = error => ({
type: GROUP_CREATE_FAIL,
error,
});
export const update = (groupId, title, description, coverImage, routerHistory) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(updateRequest());
const formData = new FormData();
formData.append('title', title);
formData.append('description', description);
if (coverImage !== null) {
formData.append('cover_image', coverImage);
}
api(getState).put(`/api/v1/groups/${groupId}`, formData, { headers: { 'Content-Type': 'multipart/form-data' } }).then(({ data }) => {
dispatch(updateSuccess(data));
routerHistory.push(`/groups/${data.id}`);
}).catch(err => dispatch(updateFail(err)));
};
export const updateRequest = id => ({
type: GROUP_UPDATE_REQUEST,
id,
});
export const updateSuccess = group => ({
type: GROUP_UPDATE_SUCCESS,
group,
});
export const updateFail = error => ({
type: GROUP_UPDATE_FAIL,
error,
});
export const changeValue = (field, value) => ({
type: GROUP_EDITOR_VALUE_CHANGE,
field,
value,
});
export const reset = () => ({
type: GROUP_EDITOR_RESET,
});
export const setUp = (group) => ({
type: GROUP_EDITOR_SETUP,
group,
});

143
app/soapbox/actions/group_editor.ts Normal file
View File

@ -0,0 +1,143 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import type { AxiosError } from 'axios';
import type { History } from 'history';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const GROUP_CREATE_REQUEST = 'GROUP_CREATE_REQUEST';
const GROUP_CREATE_SUCCESS = 'GROUP_CREATE_SUCCESS';
const GROUP_CREATE_FAIL = 'GROUP_CREATE_FAIL';
const GROUP_UPDATE_REQUEST = 'GROUP_UPDATE_REQUEST';
const GROUP_UPDATE_SUCCESS = 'GROUP_UPDATE_SUCCESS';
const GROUP_UPDATE_FAIL = 'GROUP_UPDATE_FAIL';
const GROUP_EDITOR_VALUE_CHANGE = 'GROUP_EDITOR_VALUE_CHANGE';
const GROUP_EDITOR_RESET = 'GROUP_EDITOR_RESET';
const GROUP_EDITOR_SETUP = 'GROUP_EDITOR_SETUP';
const submit = (routerHistory: History) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const groupId = getState().group_editor.get('groupId') as string;
const title = getState().group_editor.get('title') as string;
const description = getState().group_editor.get('description') as string;
const coverImage = getState().group_editor.get('coverImage') as any;
if (groupId === null) {
dispatch(create(title, description, coverImage, routerHistory));
} else {
dispatch(update(groupId, title, description, coverImage, routerHistory));
}
};
const create = (title: string, description: string, coverImage: File, routerHistory: History) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(createRequest());
const formData = new FormData();
formData.append('title', title);
formData.append('description', description);
if (coverImage !== null) {
formData.append('cover_image', coverImage);
}
api(getState).post('/api/v1/groups', formData, { headers: { 'Content-Type': 'multipart/form-data' } }).then(({ data }) => {
dispatch(createSuccess(data));
routerHistory.push(`/groups/${data.id}`);
}).catch(err => dispatch(createFail(err)));
};
const createRequest = (id?: string) => ({
type: GROUP_CREATE_REQUEST,
id,
});
const createSuccess = (group: APIEntity) => ({
type: GROUP_CREATE_SUCCESS,
group,
});
const createFail = (error: AxiosError) => ({
type: GROUP_CREATE_FAIL,
error,
});
const update = (groupId: string, title: string, description: string, coverImage: File, routerHistory: History) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(updateRequest(groupId));
const formData = new FormData();
formData.append('title', title);
formData.append('description', description);
if (coverImage !== null) {
formData.append('cover_image', coverImage);
}
api(getState).put(`/api/v1/groups/${groupId}`, formData, { headers: { 'Content-Type': 'multipart/form-data' } }).then(({ data }) => {
dispatch(updateSuccess(data));
routerHistory.push(`/groups/${data.id}`);
}).catch(err => dispatch(updateFail(err)));
};
const updateRequest = (id: string) => ({
type: GROUP_UPDATE_REQUEST,
id,
});
const updateSuccess = (group: APIEntity) => ({
type: GROUP_UPDATE_SUCCESS,
group,
});
const updateFail = (error: AxiosError) => ({
type: GROUP_UPDATE_FAIL,
error,
});
const changeValue = (field: string, value: string | File) => ({
type: GROUP_EDITOR_VALUE_CHANGE,
field,
value,
});
const reset = () => ({
type: GROUP_EDITOR_RESET,
});
const setUp = (group: string) => ({
type: GROUP_EDITOR_SETUP,
group,
});
export {
GROUP_CREATE_REQUEST,
GROUP_CREATE_SUCCESS,
GROUP_CREATE_FAIL,
GROUP_UPDATE_REQUEST,
GROUP_UPDATE_SUCCESS,
GROUP_UPDATE_FAIL,
GROUP_EDITOR_VALUE_CHANGE,
GROUP_EDITOR_RESET,
GROUP_EDITOR_SETUP,
submit,
create,
createRequest,
createSuccess,
createFail,
update,
updateRequest,
updateSuccess,
updateFail,
changeValue,
reset,
setUp,
};

526
app/soapbox/actions/groups.js
View File

@ -1,526 +0,0 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api, { getLinks } from '../api';
import { fetchRelationships } from './accounts';
import { importFetchedAccounts } from './importer';
export const GROUP_FETCH_REQUEST = 'GROUP_FETCH_REQUEST';
export const GROUP_FETCH_SUCCESS = 'GROUP_FETCH_SUCCESS';
export const GROUP_FETCH_FAIL = 'GROUP_FETCH_FAIL';
export const GROUP_RELATIONSHIPS_FETCH_REQUEST = 'GROUP_RELATIONSHIPS_FETCH_REQUEST';
export const GROUP_RELATIONSHIPS_FETCH_SUCCESS = 'GROUP_RELATIONSHIPS_FETCH_SUCCESS';
export const GROUP_RELATIONSHIPS_FETCH_FAIL = 'GROUP_RELATIONSHIPS_FETCH_FAIL';
export const GROUPS_FETCH_REQUEST = 'GROUPS_FETCH_REQUEST';
export const GROUPS_FETCH_SUCCESS = 'GROUPS_FETCH_SUCCESS';
export const GROUPS_FETCH_FAIL = 'GROUPS_FETCH_FAIL';
export const GROUP_JOIN_REQUEST = 'GROUP_JOIN_REQUEST';
export const GROUP_JOIN_SUCCESS = 'GROUP_JOIN_SUCCESS';
export const GROUP_JOIN_FAIL = 'GROUP_JOIN_FAIL';
export const GROUP_LEAVE_REQUEST = 'GROUP_LEAVE_REQUEST';
export const GROUP_LEAVE_SUCCESS = 'GROUP_LEAVE_SUCCESS';
export const GROUP_LEAVE_FAIL = 'GROUP_LEAVE_FAIL';
export const GROUP_MEMBERS_FETCH_REQUEST = 'GROUP_MEMBERS_FETCH_REQUEST';
export const GROUP_MEMBERS_FETCH_SUCCESS = 'GROUP_MEMBERS_FETCH_SUCCESS';
export const GROUP_MEMBERS_FETCH_FAIL = 'GROUP_MEMBERS_FETCH_FAIL';
export const GROUP_MEMBERS_EXPAND_REQUEST = 'GROUP_MEMBERS_EXPAND_REQUEST';
export const GROUP_MEMBERS_EXPAND_SUCCESS = 'GROUP_MEMBERS_EXPAND_SUCCESS';
export const GROUP_MEMBERS_EXPAND_FAIL = 'GROUP_MEMBERS_EXPAND_FAIL';
export const GROUP_REMOVED_ACCOUNTS_FETCH_REQUEST = 'GROUP_REMOVED_ACCOUNTS_FETCH_REQUEST';
export const GROUP_REMOVED_ACCOUNTS_FETCH_SUCCESS = 'GROUP_REMOVED_ACCOUNTS_FETCH_SUCCESS';
export const GROUP_REMOVED_ACCOUNTS_FETCH_FAIL = 'GROUP_REMOVED_ACCOUNTS_FETCH_FAIL';
export const GROUP_REMOVED_ACCOUNTS_EXPAND_REQUEST = 'GROUP_REMOVED_ACCOUNTS_EXPAND_REQUEST';
export const GROUP_REMOVED_ACCOUNTS_EXPAND_SUCCESS = 'GROUP_REMOVED_ACCOUNTS_EXPAND_SUCCESS';
export const GROUP_REMOVED_ACCOUNTS_EXPAND_FAIL = 'GROUP_REMOVED_ACCOUNTS_EXPAND_FAIL';
export const GROUP_REMOVED_ACCOUNTS_REMOVE_REQUEST = 'GROUP_REMOVED_ACCOUNTS_REMOVE_REQUEST';
export const GROUP_REMOVED_ACCOUNTS_REMOVE_SUCCESS = 'GROUP_REMOVED_ACCOUNTS_REMOVE_SUCCESS';
export const GROUP_REMOVED_ACCOUNTS_REMOVE_FAIL = 'GROUP_REMOVED_ACCOUNTS_REMOVE_FAIL';
export const GROUP_REMOVED_ACCOUNTS_CREATE_REQUEST = 'GROUP_REMOVED_ACCOUNTS_CREATE_REQUEST';
export const GROUP_REMOVED_ACCOUNTS_CREATE_SUCCESS = 'GROUP_REMOVED_ACCOUNTS_CREATE_SUCCESS';
export const GROUP_REMOVED_ACCOUNTS_CREATE_FAIL = 'GROUP_REMOVED_ACCOUNTS_CREATE_FAIL';
export const GROUP_REMOVE_STATUS_REQUEST = 'GROUP_REMOVE_STATUS_REQUEST';
export const GROUP_REMOVE_STATUS_SUCCESS = 'GROUP_REMOVE_STATUS_SUCCESS';
export const GROUP_REMOVE_STATUS_FAIL = 'GROUP_REMOVE_STATUS_FAIL';
export const fetchGroup = id => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchGroupRelationships([id]));
if (getState().getIn(['groups', id])) {
return;
}
dispatch(fetchGroupRequest(id));
api(getState).get(`/api/v1/groups/${id}`)
.then(({ data }) => dispatch(fetchGroupSuccess(data)))
.catch(err => dispatch(fetchGroupFail(id, err)));
};
export const fetchGroupRequest = id => ({
type: GROUP_FETCH_REQUEST,
id,
});
export const fetchGroupSuccess = group => ({
type: GROUP_FETCH_SUCCESS,
group,
});
export const fetchGroupFail = (id, error) => ({
type: GROUP_FETCH_FAIL,
id,
error,
});
export function fetchGroupRelationships(groupIds) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const loadedRelationships = getState().get('group_relationships');
const newGroupIds = groupIds.filter(id => loadedRelationships.get(id, null) === null);
if (newGroupIds.length === 0) {
return;
}
dispatch(fetchGroupRelationshipsRequest(newGroupIds));
api(getState).get(`/api/v1/groups/${newGroupIds[0]}/relationships?${newGroupIds.map(id => `id[]=${id}`).join('&')}`).then(response => {
dispatch(fetchGroupRelationshipsSuccess(response.data));
}).catch(error => {
dispatch(fetchGroupRelationshipsFail(error));
});
};
}
export function fetchGroupRelationshipsRequest(ids) {
return {
type: GROUP_RELATIONSHIPS_FETCH_REQUEST,
ids,
skipLoading: true,
};
}
export function fetchGroupRelationshipsSuccess(relationships) {
return {
type: GROUP_RELATIONSHIPS_FETCH_SUCCESS,
relationships,
skipLoading: true,
};
}
export function fetchGroupRelationshipsFail(error) {
return {
type: GROUP_RELATIONSHIPS_FETCH_FAIL,
error,
skipLoading: true,
};
}
export const fetchGroups = (tab) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchGroupsRequest());
api(getState).get('/api/v1/groups?tab=' + tab)
.then(({ data }) => {
dispatch(fetchGroupsSuccess(data, tab));
dispatch(fetchGroupRelationships(data.map(item => item.id)));
})
.catch(err => dispatch(fetchGroupsFail(err)));
};
export const fetchGroupsRequest = () => ({
type: GROUPS_FETCH_REQUEST,
});
export const fetchGroupsSuccess = (groups, tab) => ({
type: GROUPS_FETCH_SUCCESS,
groups,
tab,
});
export const fetchGroupsFail = error => ({
type: GROUPS_FETCH_FAIL,
error,
});
export function joinGroup(id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(joinGroupRequest(id));
api(getState).post(`/api/v1/groups/${id}/accounts`).then(response => {
dispatch(joinGroupSuccess(response.data));
}).catch(error => {
dispatch(joinGroupFail(id, error));
});
};
}
export function leaveGroup(id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(leaveGroupRequest(id));
api(getState).delete(`/api/v1/groups/${id}/accounts`).then(response => {
dispatch(leaveGroupSuccess(response.data));
}).catch(error => {
dispatch(leaveGroupFail(id, error));
});
};
}
export function joinGroupRequest(id) {
return {
type: GROUP_JOIN_REQUEST,
id,
};
}
export function joinGroupSuccess(relationship) {
return {
type: GROUP_JOIN_SUCCESS,
relationship,
};
}
export function joinGroupFail(error) {
return {
type: GROUP_JOIN_FAIL,
error,
};
}
export function leaveGroupRequest(id) {
return {
type: GROUP_LEAVE_REQUEST,
id,
};
}
export function leaveGroupSuccess(relationship) {
return {
type: GROUP_LEAVE_SUCCESS,
relationship,
};
}
export function leaveGroupFail(error) {
return {
type: GROUP_LEAVE_FAIL,
error,
};
}
export function fetchMembers(id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchMembersRequest(id));
api(getState).get(`/api/v1/groups/${id}/accounts`).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data));
dispatch(fetchMembersSuccess(id, response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map(item => item.id)));
}).catch(error => {
dispatch(fetchMembersFail(id, error));
});
};
}
export function fetchMembersRequest(id) {
return {
type: GROUP_MEMBERS_FETCH_REQUEST,
id,
};
}
export function fetchMembersSuccess(id, accounts, next) {
return {
type: GROUP_MEMBERS_FETCH_SUCCESS,
id,
accounts,
next,
};
}
export function fetchMembersFail(id, error) {
return {
type: GROUP_MEMBERS_FETCH_FAIL,
id,
error,
};
}
export function expandMembers(id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const url = getState().getIn(['user_lists', 'groups', id, 'next']);
if (url === null) {
return;
}
dispatch(expandMembersRequest(id));
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data));
dispatch(expandMembersSuccess(id, response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map(item => item.id)));
}).catch(error => {
dispatch(expandMembersFail(id, error));
});
};
}
export function expandMembersRequest(id) {
return {
type: GROUP_MEMBERS_EXPAND_REQUEST,
id,
};
}
export function expandMembersSuccess(id, accounts, next) {
return {
type: GROUP_MEMBERS_EXPAND_SUCCESS,
id,
accounts,
next,
};
}
export function expandMembersFail(id, error) {
return {
type: GROUP_MEMBERS_EXPAND_FAIL,
id,
error,
};
}
export function fetchRemovedAccounts(id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchRemovedAccountsRequest(id));
api(getState).get(`/api/v1/groups/${id}/removed_accounts`).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data));
dispatch(fetchRemovedAccountsSuccess(id, response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map(item => item.id)));
}).catch(error => {
dispatch(fetchRemovedAccountsFail(id, error));
});
};
}
export function fetchRemovedAccountsRequest(id) {
return {
type: GROUP_REMOVED_ACCOUNTS_FETCH_REQUEST,
id,
};
}
export function fetchRemovedAccountsSuccess(id, accounts, next) {
return {
type: GROUP_REMOVED_ACCOUNTS_FETCH_SUCCESS,
id,
accounts,
next,
};
}
export function fetchRemovedAccountsFail(id, error) {
return {
type: GROUP_REMOVED_ACCOUNTS_FETCH_FAIL,
id,
error,
};
}
export function expandRemovedAccounts(id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const url = getState().getIn(['user_lists', 'groups_removed_accounts', id, 'next']);
if (url === null) {
return;
}
dispatch(expandRemovedAccountsRequest(id));
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data));
dispatch(expandRemovedAccountsSuccess(id, response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map(item => item.id)));
}).catch(error => {
dispatch(expandRemovedAccountsFail(id, error));
});
};
}
export function expandRemovedAccountsRequest(id) {
return {
type: GROUP_REMOVED_ACCOUNTS_EXPAND_REQUEST,
id,
};
}
export function expandRemovedAccountsSuccess(id, accounts, next) {
return {
type: GROUP_REMOVED_ACCOUNTS_EXPAND_SUCCESS,
id,
accounts,
next,
};
}
export function expandRemovedAccountsFail(id, error) {
return {
type: GROUP_REMOVED_ACCOUNTS_EXPAND_FAIL,
id,
error,
};
}
export function removeRemovedAccount(groupId, id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(removeRemovedAccountRequest(groupId, id));
api(getState).delete(`/api/v1/groups/${groupId}/removed_accounts?account_id=${id}`).then(response => {
dispatch(removeRemovedAccountSuccess(groupId, id));
}).catch(error => {
dispatch(removeRemovedAccountFail(groupId, id, error));
});
};
}
export function removeRemovedAccountRequest(groupId, id) {
return {
type: GROUP_REMOVED_ACCOUNTS_REMOVE_REQUEST,
groupId,
id,
};
}
export function removeRemovedAccountSuccess(groupId, id) {
return {
type: GROUP_REMOVED_ACCOUNTS_REMOVE_SUCCESS,
groupId,
id,
};
}
export function removeRemovedAccountFail(groupId, id, error) {
return {
type: GROUP_REMOVED_ACCOUNTS_REMOVE_FAIL,
groupId,
id,
error,
};
}
export function createRemovedAccount(groupId, id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(createRemovedAccountRequest(groupId, id));
api(getState).post(`/api/v1/groups/${groupId}/removed_accounts?account_id=${id}`).then(response => {
dispatch(createRemovedAccountSuccess(groupId, id));
}).catch(error => {
dispatch(createRemovedAccountFail(groupId, id, error));
});
};
}
export function createRemovedAccountRequest(groupId, id) {
return {
type: GROUP_REMOVED_ACCOUNTS_CREATE_REQUEST,
groupId,
id,
};
}
export function createRemovedAccountSuccess(groupId, id) {
return {
type: GROUP_REMOVED_ACCOUNTS_CREATE_SUCCESS,
groupId,
id,
};
}
export function createRemovedAccountFail(groupId, id, error) {
return {
type: GROUP_REMOVED_ACCOUNTS_CREATE_FAIL,
groupId,
id,
error,
};
}
export function groupRemoveStatus(groupId, id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(groupRemoveStatusRequest(groupId, id));
api(getState).delete(`/api/v1/groups/${groupId}/statuses/${id}`).then(response => {
dispatch(groupRemoveStatusSuccess(groupId, id));
}).catch(error => {
dispatch(groupRemoveStatusFail(groupId, id, error));
});
};
}
export function groupRemoveStatusRequest(groupId, id) {
return {
type: GROUP_REMOVE_STATUS_REQUEST,
groupId,
id,
};
}
export function groupRemoveStatusSuccess(groupId, id) {
return {
type: GROUP_REMOVE_STATUS_SUCCESS,
groupId,
id,
};
}
export function groupRemoveStatusFail(groupId, id, error) {
return {
type: GROUP_REMOVE_STATUS_FAIL,
groupId,
id,
error,
};
}

550
app/soapbox/actions/groups.ts Normal file
View File

@ -0,0 +1,550 @@
import { AxiosError } from 'axios';
import { isLoggedIn } from 'soapbox/utils/auth';
import api, { getLinks } from '../api';
import { fetchRelationships } from './accounts';
import { importFetchedAccounts } from './importer';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const GROUP_FETCH_REQUEST = 'GROUP_FETCH_REQUEST';
const GROUP_FETCH_SUCCESS = 'GROUP_FETCH_SUCCESS';
const GROUP_FETCH_FAIL = 'GROUP_FETCH_FAIL';
const GROUP_RELATIONSHIPS_FETCH_REQUEST = 'GROUP_RELATIONSHIPS_FETCH_REQUEST';
const GROUP_RELATIONSHIPS_FETCH_SUCCESS = 'GROUP_RELATIONSHIPS_FETCH_SUCCESS';
const GROUP_RELATIONSHIPS_FETCH_FAIL = 'GROUP_RELATIONSHIPS_FETCH_FAIL';
const GROUPS_FETCH_REQUEST = 'GROUPS_FETCH_REQUEST';
const GROUPS_FETCH_SUCCESS = 'GROUPS_FETCH_SUCCESS';
const GROUPS_FETCH_FAIL = 'GROUPS_FETCH_FAIL';
const GROUP_JOIN_REQUEST = 'GROUP_JOIN_REQUEST';
const GROUP_JOIN_SUCCESS = 'GROUP_JOIN_SUCCESS';
const GROUP_JOIN_FAIL = 'GROUP_JOIN_FAIL';
const GROUP_LEAVE_REQUEST = 'GROUP_LEAVE_REQUEST';
const GROUP_LEAVE_SUCCESS = 'GROUP_LEAVE_SUCCESS';
const GROUP_LEAVE_FAIL = 'GROUP_LEAVE_FAIL';
const GROUP_MEMBERS_FETCH_REQUEST = 'GROUP_MEMBERS_FETCH_REQUEST';
const GROUP_MEMBERS_FETCH_SUCCESS = 'GROUP_MEMBERS_FETCH_SUCCESS';
const GROUP_MEMBERS_FETCH_FAIL = 'GROUP_MEMBERS_FETCH_FAIL';
const GROUP_MEMBERS_EXPAND_REQUEST = 'GROUP_MEMBERS_EXPAND_REQUEST';
const GROUP_MEMBERS_EXPAND_SUCCESS = 'GROUP_MEMBERS_EXPAND_SUCCESS';
const GROUP_MEMBERS_EXPAND_FAIL = 'GROUP_MEMBERS_EXPAND_FAIL';
const GROUP_REMOVED_ACCOUNTS_FETCH_REQUEST = 'GROUP_REMOVED_ACCOUNTS_FETCH_REQUEST';
const GROUP_REMOVED_ACCOUNTS_FETCH_SUCCESS = 'GROUP_REMOVED_ACCOUNTS_FETCH_SUCCESS';
const GROUP_REMOVED_ACCOUNTS_FETCH_FAIL = 'GROUP_REMOVED_ACCOUNTS_FETCH_FAIL';
const GROUP_REMOVED_ACCOUNTS_EXPAND_REQUEST = 'GROUP_REMOVED_ACCOUNTS_EXPAND_REQUEST';
const GROUP_REMOVED_ACCOUNTS_EXPAND_SUCCESS = 'GROUP_REMOVED_ACCOUNTS_EXPAND_SUCCESS';
const GROUP_REMOVED_ACCOUNTS_EXPAND_FAIL = 'GROUP_REMOVED_ACCOUNTS_EXPAND_FAIL';
const GROUP_REMOVED_ACCOUNTS_REMOVE_REQUEST = 'GROUP_REMOVED_ACCOUNTS_REMOVE_REQUEST';
const GROUP_REMOVED_ACCOUNTS_REMOVE_SUCCESS = 'GROUP_REMOVED_ACCOUNTS_REMOVE_SUCCESS';
const GROUP_REMOVED_ACCOUNTS_REMOVE_FAIL = 'GROUP_REMOVED_ACCOUNTS_REMOVE_FAIL';
const GROUP_REMOVED_ACCOUNTS_CREATE_REQUEST = 'GROUP_REMOVED_ACCOUNTS_CREATE_REQUEST';
const GROUP_REMOVED_ACCOUNTS_CREATE_SUCCESS = 'GROUP_REMOVED_ACCOUNTS_CREATE_SUCCESS';
const GROUP_REMOVED_ACCOUNTS_CREATE_FAIL = 'GROUP_REMOVED_ACCOUNTS_CREATE_FAIL';
const GROUP_REMOVE_STATUS_REQUEST = 'GROUP_REMOVE_STATUS_REQUEST';
const GROUP_REMOVE_STATUS_SUCCESS = 'GROUP_REMOVE_STATUS_SUCCESS';
const GROUP_REMOVE_STATUS_FAIL = 'GROUP_REMOVE_STATUS_FAIL';
const fetchGroup = (id: string) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchGroupRelationships([id]));
if (getState().groups.get(id)) {
return;
}
dispatch(fetchGroupRequest(id));
api(getState).get(`/api/v1/groups/${id}`)
.then(({ data }) => dispatch(fetchGroupSuccess(data)))
.catch(err => dispatch(fetchGroupFail(id, err)));
};
const fetchGroupRequest = (id: string) => ({
type: GROUP_FETCH_REQUEST,
id,
});
const fetchGroupSuccess = (group: APIEntity) => ({
type: GROUP_FETCH_SUCCESS,
group,
});
const fetchGroupFail = (id: string, error: AxiosError) => ({
type: GROUP_FETCH_FAIL,
id,
error,
});
const fetchGroupRelationships = (groupIds: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const loadedRelationships = getState().group_relationships;
const newGroupIds = groupIds.filter(id => loadedRelationships.get(id, null) === null);
if (newGroupIds.length === 0) {
return;
}
dispatch(fetchGroupRelationshipsRequest(newGroupIds));
api(getState).get(`/api/v1/groups/${newGroupIds[0]}/relationships?${newGroupIds.map(id => `id[]=${id}`).join('&')}`).then(response => {
dispatch(fetchGroupRelationshipsSuccess(response.data));
}).catch(error => {
dispatch(fetchGroupRelationshipsFail(error));
});
};
const fetchGroupRelationshipsRequest = (ids: string[]) => ({
type: GROUP_RELATIONSHIPS_FETCH_REQUEST,
ids,
skipLoading: true,
});
const fetchGroupRelationshipsSuccess = (relationships: APIEntity[]) => ({
type: GROUP_RELATIONSHIPS_FETCH_SUCCESS,
relationships,
skipLoading: true,
});
const fetchGroupRelationshipsFail = (error: AxiosError) => ({
type: GROUP_RELATIONSHIPS_FETCH_FAIL,
error,
skipLoading: true,
});
const fetchGroups = (tab: string) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchGroupsRequest());
api(getState).get('/api/v1/groups?tab=' + tab)
.then(({ data }) => {
dispatch(fetchGroupsSuccess(data, tab));
dispatch(fetchGroupRelationships(data.map((item: APIEntity) => item.id)));
})
.catch(err => dispatch(fetchGroupsFail(err)));
};
const fetchGroupsRequest = () => ({
type: GROUPS_FETCH_REQUEST,
});
const fetchGroupsSuccess = (groups: APIEntity[], tab: string) => ({
type: GROUPS_FETCH_SUCCESS,
groups,
tab,
});
const fetchGroupsFail = (error: AxiosError) => ({
type: GROUPS_FETCH_FAIL,
error,
});
const joinGroup = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(joinGroupRequest(id));
api(getState).post(`/api/v1/groups/${id}/accounts`).then(response => {
dispatch(joinGroupSuccess(response.data));
}).catch(error => {
dispatch(joinGroupFail(id, error));
});
};
const leaveGroup = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(leaveGroupRequest(id));
api(getState).delete(`/api/v1/groups/${id}/accounts`).then(response => {
dispatch(leaveGroupSuccess(response.data));
}).catch(error => {
dispatch(leaveGroupFail(id, error));
});
};
const joinGroupRequest = (id: string) => ({
type: GROUP_JOIN_REQUEST,
id,
});
const joinGroupSuccess = (relationship: APIEntity) => ({
type: GROUP_JOIN_SUCCESS,
relationship,
});
const joinGroupFail = (id: string, error: AxiosError) => ({
type: GROUP_JOIN_FAIL,
id,
error,
});
const leaveGroupRequest = (id: string) => ({
type: GROUP_LEAVE_REQUEST,
id,
});
const leaveGroupSuccess = (relationship: APIEntity) => ({
type: GROUP_LEAVE_SUCCESS,
relationship,
});
const leaveGroupFail = (id: string, error: AxiosError) => ({
type: GROUP_LEAVE_FAIL,
id,
error,
});
const fetchMembers = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchMembersRequest(id));
api(getState).get(`/api/v1/groups/${id}/accounts`).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data));
dispatch(fetchMembersSuccess(id, response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map((item: APIEntity) => item.id)));
}).catch(error => {
dispatch(fetchMembersFail(id, error));
});
};
const fetchMembersRequest = (id: string) => ({
type: GROUP_MEMBERS_FETCH_REQUEST,
id,
});
const fetchMembersSuccess = (id: string, accounts: APIEntity[], next: string | null) => ({
type: GROUP_MEMBERS_FETCH_SUCCESS,
id,
accounts,
next,
});
const fetchMembersFail = (id: string, error: AxiosError) => ({
type: GROUP_MEMBERS_FETCH_FAIL,
id,
error,
});
const expandMembers = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const url = getState().user_lists.getIn(['groups', id, 'next']);
if (url === null) {
return;
}
dispatch(expandMembersRequest(id));
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data));
dispatch(expandMembersSuccess(id, response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map((item: APIEntity) => item.id)));
}).catch(error => {
dispatch(expandMembersFail(id, error));
});
};
const expandMembersRequest = (id: string) => ({
type: GROUP_MEMBERS_EXPAND_REQUEST,
id,
});
const expandMembersSuccess = (id: string, accounts: APIEntity[], next: string | null) => ({
type: GROUP_MEMBERS_EXPAND_SUCCESS,
id,
accounts,
next,
});
const expandMembersFail = (id: string, error: AxiosError) => ({
type: GROUP_MEMBERS_EXPAND_FAIL,
id,
error,
});
const fetchRemovedAccounts = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchRemovedAccountsRequest(id));
api(getState).get(`/api/v1/groups/${id}/removed_accounts`).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data));
dispatch(fetchRemovedAccountsSuccess(id, response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map((item: APIEntity) => item.id)));
}).catch(error => {
dispatch(fetchRemovedAccountsFail(id, error));
});
};
const fetchRemovedAccountsRequest = (id: string) => ({
type: GROUP_REMOVED_ACCOUNTS_FETCH_REQUEST,
id,
});
const fetchRemovedAccountsSuccess = (id: string, accounts: APIEntity[], next: string | null) => ({
type: GROUP_REMOVED_ACCOUNTS_FETCH_SUCCESS,
id,
accounts,
next,
});
const fetchRemovedAccountsFail = (id: string, error: AxiosError) => ({
type: GROUP_REMOVED_ACCOUNTS_FETCH_FAIL,
id,
error,
});
const expandRemovedAccounts = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const url = getState().user_lists.getIn(['groups_removed_accounts', id, 'next']);
if (url === null) {
return;
}
dispatch(expandRemovedAccountsRequest(id));
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(importFetchedAccounts(response.data));
dispatch(expandRemovedAccountsSuccess(id, response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map((item: APIEntity) => item.id)));
}).catch(error => {
dispatch(expandRemovedAccountsFail(id, error));
});
};
const expandRemovedAccountsRequest = (id: string) => ({
type: GROUP_REMOVED_ACCOUNTS_EXPAND_REQUEST,
id,
});
const expandRemovedAccountsSuccess = (id: string, accounts: APIEntity[], next: string | null) => ({
type: GROUP_REMOVED_ACCOUNTS_EXPAND_SUCCESS,
id,
accounts,
next,
});
const expandRemovedAccountsFail = (id: string, error: AxiosError) => ({
type: GROUP_REMOVED_ACCOUNTS_EXPAND_FAIL,
id,
error,
});
const removeRemovedAccount = (groupId: string, id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(removeRemovedAccountRequest(groupId, id));
api(getState).delete(`/api/v1/groups/${groupId}/removed_accounts?account_id=${id}`).then(response => {
dispatch(removeRemovedAccountSuccess(groupId, id));
}).catch(error => {
dispatch(removeRemovedAccountFail(groupId, id, error));
});
};
const removeRemovedAccountRequest = (groupId: string, id: string) => ({
type: GROUP_REMOVED_ACCOUNTS_REMOVE_REQUEST,
groupId,
id,
});
const removeRemovedAccountSuccess = (groupId: string, id: string) => ({
type: GROUP_REMOVED_ACCOUNTS_REMOVE_SUCCESS,
groupId,
id,
});
const removeRemovedAccountFail = (groupId: string, id: string, error: AxiosError) => ({
type: GROUP_REMOVED_ACCOUNTS_REMOVE_FAIL,
groupId,
id,
error,
});
const createRemovedAccount = (groupId: string, id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(createRemovedAccountRequest(groupId, id));
api(getState).post(`/api/v1/groups/${groupId}/removed_accounts?account_id=${id}`).then(response => {
dispatch(createRemovedAccountSuccess(groupId, id));
}).catch(error => {
dispatch(createRemovedAccountFail(groupId, id, error));
});
};
const createRemovedAccountRequest = (groupId: string, id: string) => ({
type: GROUP_REMOVED_ACCOUNTS_CREATE_REQUEST,
groupId,
id,
});
const createRemovedAccountSuccess = (groupId: string, id: string) => ({
type: GROUP_REMOVED_ACCOUNTS_CREATE_SUCCESS,
groupId,
id,
});
const createRemovedAccountFail = (groupId: string, id: string, error: AxiosError) => ({
type: GROUP_REMOVED_ACCOUNTS_CREATE_FAIL,
groupId,
id,
error,
});
const groupRemoveStatus = (groupId: string, id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(groupRemoveStatusRequest(groupId, id));
api(getState).delete(`/api/v1/groups/${groupId}/statuses/${id}`).then(response => {
dispatch(groupRemoveStatusSuccess(groupId, id));
}).catch(error => {
dispatch(groupRemoveStatusFail(groupId, id, error));
});
};
const groupRemoveStatusRequest = (groupId: string, id: string) => ({
type: GROUP_REMOVE_STATUS_REQUEST,
groupId,
id,
});
const groupRemoveStatusSuccess = (groupId: string, id: string) => ({
type: GROUP_REMOVE_STATUS_SUCCESS,
groupId,
id,
});
const groupRemoveStatusFail = (groupId: string, id: string, error: AxiosError) => ({
type: GROUP_REMOVE_STATUS_FAIL,
groupId,
id,
error,
});
export {
GROUP_FETCH_REQUEST,
GROUP_FETCH_SUCCESS,
GROUP_FETCH_FAIL,
GROUP_RELATIONSHIPS_FETCH_REQUEST,
GROUP_RELATIONSHIPS_FETCH_SUCCESS,
GROUP_RELATIONSHIPS_FETCH_FAIL,
GROUPS_FETCH_REQUEST,
GROUPS_FETCH_SUCCESS,
GROUPS_FETCH_FAIL,
GROUP_JOIN_REQUEST,
GROUP_JOIN_SUCCESS,
GROUP_JOIN_FAIL,
GROUP_LEAVE_REQUEST,
GROUP_LEAVE_SUCCESS,
GROUP_LEAVE_FAIL,
GROUP_MEMBERS_FETCH_REQUEST,
GROUP_MEMBERS_FETCH_SUCCESS,
GROUP_MEMBERS_FETCH_FAIL,
GROUP_MEMBERS_EXPAND_REQUEST,
GROUP_MEMBERS_EXPAND_SUCCESS,
GROUP_MEMBERS_EXPAND_FAIL,
GROUP_REMOVED_ACCOUNTS_FETCH_REQUEST,
GROUP_REMOVED_ACCOUNTS_FETCH_SUCCESS,
GROUP_REMOVED_ACCOUNTS_FETCH_FAIL,
GROUP_REMOVED_ACCOUNTS_EXPAND_REQUEST,
GROUP_REMOVED_ACCOUNTS_EXPAND_SUCCESS,
GROUP_REMOVED_ACCOUNTS_EXPAND_FAIL,
GROUP_REMOVED_ACCOUNTS_REMOVE_REQUEST,
GROUP_REMOVED_ACCOUNTS_REMOVE_SUCCESS,
GROUP_REMOVED_ACCOUNTS_REMOVE_FAIL,
GROUP_REMOVED_ACCOUNTS_CREATE_REQUEST,
GROUP_REMOVED_ACCOUNTS_CREATE_SUCCESS,
GROUP_REMOVED_ACCOUNTS_CREATE_FAIL,
GROUP_REMOVE_STATUS_REQUEST,
GROUP_REMOVE_STATUS_SUCCESS,
GROUP_REMOVE_STATUS_FAIL,
fetchGroup,
fetchGroupRequest,
fetchGroupSuccess,
fetchGroupFail,
fetchGroupRelationships,
fetchGroupRelationshipsRequest,
fetchGroupRelationshipsSuccess,
fetchGroupRelationshipsFail,
fetchGroups,
fetchGroupsRequest,
fetchGroupsSuccess,
fetchGroupsFail,
joinGroup,
leaveGroup,
joinGroupRequest,
joinGroupSuccess,
joinGroupFail,
leaveGroupRequest,
leaveGroupSuccess,
leaveGroupFail,
fetchMembers,
fetchMembersRequest,
fetchMembersSuccess,
fetchMembersFail,
expandMembers,
expandMembersRequest,
expandMembersSuccess,
expandMembersFail,
fetchRemovedAccounts,
fetchRemovedAccountsRequest,
fetchRemovedAccountsSuccess,
fetchRemovedAccountsFail,
expandRemovedAccounts,
expandRemovedAccountsRequest,
expandRemovedAccountsSuccess,
expandRemovedAccountsFail,
removeRemovedAccount,
removeRemovedAccountRequest,
removeRemovedAccountSuccess,
removeRemovedAccountFail,
createRemovedAccount,
createRemovedAccountRequest,
createRemovedAccountSuccess,
createRemovedAccountFail,
groupRemoveStatus,
groupRemoveStatusRequest,
groupRemoveStatusSuccess,
groupRemoveStatusFail,
};

38
app/soapbox/actions/history.js
View File

@ -1,38 +0,0 @@
import api from 'soapbox/api';
import { importFetchedAccounts } from './importer';
export const HISTORY_FETCH_REQUEST = 'HISTORY_FETCH_REQUEST';
export const HISTORY_FETCH_SUCCESS = 'HISTORY_FETCH_SUCCESS';
export const HISTORY_FETCH_FAIL = 'HISTORY_FETCH_FAIL';
export const fetchHistory = statusId => (dispatch, getState) => {
const loading = getState().getIn(['history', statusId, 'loading']);
if (loading) {
return;
}
dispatch(fetchHistoryRequest(statusId));
api(getState).get(`/api/v1/statuses/${statusId}/history`).then(({ data }) => {
dispatch(importFetchedAccounts(data.map(x => x.account)));
dispatch(fetchHistorySuccess(statusId, data));
}).catch(error => dispatch(fetchHistoryFail(error)));
};
export const fetchHistoryRequest = statusId => ({
type: HISTORY_FETCH_REQUEST,
statusId,
});
export const fetchHistorySuccess = (statusId, history) => ({
type: HISTORY_FETCH_SUCCESS,
statusId,
history,
});
export const fetchHistoryFail = error => ({
type: HISTORY_FETCH_FAIL,
error,
});

53
app/soapbox/actions/history.ts Normal file
View File

@ -0,0 +1,53 @@
import api from 'soapbox/api';
import { importFetchedAccounts } from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const HISTORY_FETCH_REQUEST = 'HISTORY_FETCH_REQUEST';
const HISTORY_FETCH_SUCCESS = 'HISTORY_FETCH_SUCCESS';
const HISTORY_FETCH_FAIL = 'HISTORY_FETCH_FAIL';
const fetchHistory = (statusId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const loading = getState().history.getIn([statusId, 'loading']);
if (loading) {
return;
}
dispatch(fetchHistoryRequest(statusId));
api(getState).get(`/api/v1/statuses/${statusId}/history`).then(({ data }) => {
dispatch(importFetchedAccounts(data.map((x: APIEntity) => x.account)));
dispatch(fetchHistorySuccess(statusId, data));
}).catch(error => dispatch(fetchHistoryFail(error)));
};
const fetchHistoryRequest = (statusId: string) => ({
type: HISTORY_FETCH_REQUEST,
statusId,
});
const fetchHistorySuccess = (statusId: String, history: APIEntity[]) => ({
type: HISTORY_FETCH_SUCCESS,
statusId,
history,
});
const fetchHistoryFail = (error: AxiosError) => ({
type: HISTORY_FETCH_FAIL,
error,
});
export {
HISTORY_FETCH_REQUEST,
HISTORY_FETCH_SUCCESS,
HISTORY_FETCH_FAIL,
fetchHistory,
fetchHistoryRequest,
fetchHistorySuccess,
fetchHistoryFail,
};

72
app/soapbox/actions/importer/index.js → app/soapbox/actions/importer/index.ts
View File

@ -1,46 +1,49 @@
import { getSettings } from '../settings';
export const ACCOUNT_IMPORT = 'ACCOUNT_IMPORT';
export const ACCOUNTS_IMPORT = 'ACCOUNTS_IMPORT';
export const STATUS_IMPORT = 'STATUS_IMPORT';
export const STATUSES_IMPORT = 'STATUSES_IMPORT';
export const POLLS_IMPORT = 'POLLS_IMPORT';
export const ACCOUNT_FETCH_FAIL_FOR_USERNAME_LOOKUP = 'ACCOUNT_FETCH_FAIL_FOR_USERNAME_LOOKUP';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
export function importAccount(account) {
const ACCOUNT_IMPORT = 'ACCOUNT_IMPORT';
const ACCOUNTS_IMPORT = 'ACCOUNTS_IMPORT';
const STATUS_IMPORT = 'STATUS_IMPORT';
const STATUSES_IMPORT = 'STATUSES_IMPORT';
const POLLS_IMPORT = 'POLLS_IMPORT';
const ACCOUNT_FETCH_FAIL_FOR_USERNAME_LOOKUP = 'ACCOUNT_FETCH_FAIL_FOR_USERNAME_LOOKUP';
export function importAccount(account: APIEntity) {
return { type: ACCOUNT_IMPORT, account };
}
export function importAccounts(accounts) {
export function importAccounts(accounts: APIEntity[]) {
return { type: ACCOUNTS_IMPORT, accounts };
}
export function importStatus(status, idempotencyKey) {
return (dispatch, getState) => {
export function importStatus(status: APIEntity, idempotencyKey?: string) {
return (dispatch: AppDispatch, getState: () => RootState) => {
const expandSpoilers = getSettings(getState()).get('expandSpoilers');
return dispatch({ type: STATUS_IMPORT, status, idempotencyKey, expandSpoilers });
};
}
export function importStatuses(statuses) {
return (dispatch, getState) => {
export function importStatuses(statuses: APIEntity[]) {
return (dispatch: AppDispatch, getState: () => RootState) => {
const expandSpoilers = getSettings(getState()).get('expandSpoilers');
return dispatch({ type: STATUSES_IMPORT, statuses, expandSpoilers });
};
}
export function importPolls(polls) {
export function importPolls(polls: APIEntity[]) {
return { type: POLLS_IMPORT, polls };
}
export function importFetchedAccount(account) {
export function importFetchedAccount(account: APIEntity) {
return importFetchedAccounts([account]);
}
export function importFetchedAccounts(accounts) {
const normalAccounts = [];
export function importFetchedAccounts(accounts: APIEntity[]) {
const normalAccounts: APIEntity[] = [];
function processAccount(account) {
const processAccount = (account: APIEntity) => {
if (!account.id) return;
normalAccounts.push(account);
@ -48,15 +51,15 @@ export function importFetchedAccounts(accounts) {
if (account.moved) {
processAccount(account.moved);
}
}
};
accounts.forEach(processAccount);
return importAccounts(normalAccounts);
}
export function importFetchedStatus(status, idempotencyKey) {
return (dispatch, getState) => {
export function importFetchedStatus(status: APIEntity, idempotencyKey?: string) {
return (dispatch: AppDispatch) => {
// Skip broken statuses
if (isBroken(status)) return;
@ -95,7 +98,7 @@ export function importFetchedStatus(status, idempotencyKey) {
// Sometimes Pleroma can return an empty account,
// or a repost can appear of a deleted account. Skip these statuses.
const isBroken = status => {
const isBroken = (status: APIEntity) => {
try {
// Skip empty accounts
// https://gitlab.com/soapbox-pub/soapbox-fe/-/issues/424
@ -109,13 +112,13 @@ const isBroken = status => {
}
};
export function importFetchedStatuses(statuses) {
return (dispatch, getState) => {
const accounts = [];
const normalStatuses = [];
const polls = [];
export function importFetchedStatuses(statuses: APIEntity[]) {
return (dispatch: AppDispatch, getState: () => RootState) => {
const accounts: APIEntity[] = [];
const normalStatuses: APIEntity[] = [];
const polls: APIEntity[] = [];
function processStatus(status) {
function processStatus(status: APIEntity) {
// Skip broken statuses
if (isBroken(status)) return;
@ -148,12 +151,21 @@ export function importFetchedStatuses(statuses) {
};
}
export function importFetchedPoll(poll) {
return dispatch => {
export function importFetchedPoll(poll: APIEntity) {
return (dispatch: AppDispatch) => {
dispatch(importPolls([poll]));
};
}
export function importErrorWhileFetchingAccountByUsername(username) {
export function importErrorWhileFetchingAccountByUsername(username: string) {
return { type: ACCOUNT_FETCH_FAIL_FOR_USERNAME_LOOKUP, username };
}
export {
ACCOUNT_IMPORT,
ACCOUNTS_IMPORT,
STATUS_IMPORT,
STATUSES_IMPORT,
POLLS_IMPORT,
ACCOUNT_FETCH_FAIL_FOR_USERNAME_LOOKUP,
};

527
app/soapbox/actions/interactions.js
View File

@ -1,527 +0,0 @@
import { defineMessages } from 'react-intl';
import snackbar from 'soapbox/actions/snackbar';
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import { importFetchedAccounts, importFetchedStatus } from './importer';
export const REBLOG_REQUEST = 'REBLOG_REQUEST';
export const REBLOG_SUCCESS = 'REBLOG_SUCCESS';
export const REBLOG_FAIL = 'REBLOG_FAIL';
export const FAVOURITE_REQUEST = 'FAVOURITE_REQUEST';
export const FAVOURITE_SUCCESS = 'FAVOURITE_SUCCESS';
export const FAVOURITE_FAIL = 'FAVOURITE_FAIL';
export const UNREBLOG_REQUEST = 'UNREBLOG_REQUEST';
export const UNREBLOG_SUCCESS = 'UNREBLOG_SUCCESS';
export const UNREBLOG_FAIL = 'UNREBLOG_FAIL';
export const UNFAVOURITE_REQUEST = 'UNFAVOURITE_REQUEST';
export const UNFAVOURITE_SUCCESS = 'UNFAVOURITE_SUCCESS';
export const UNFAVOURITE_FAIL = 'UNFAVOURITE_FAIL';
export const REBLOGS_FETCH_REQUEST = 'REBLOGS_FETCH_REQUEST';
export const REBLOGS_FETCH_SUCCESS = 'REBLOGS_FETCH_SUCCESS';
export const REBLOGS_FETCH_FAIL = 'REBLOGS_FETCH_FAIL';
export const FAVOURITES_FETCH_REQUEST = 'FAVOURITES_FETCH_REQUEST';
export const FAVOURITES_FETCH_SUCCESS = 'FAVOURITES_FETCH_SUCCESS';
export const FAVOURITES_FETCH_FAIL = 'FAVOURITES_FETCH_FAIL';
export const REACTIONS_FETCH_REQUEST = 'REACTIONS_FETCH_REQUEST';
export const REACTIONS_FETCH_SUCCESS = 'REACTIONS_FETCH_SUCCESS';
export const REACTIONS_FETCH_FAIL = 'REACTIONS_FETCH_FAIL';
export const PIN_REQUEST = 'PIN_REQUEST';
export const PIN_SUCCESS = 'PIN_SUCCESS';
export const PIN_FAIL = 'PIN_FAIL';
export const UNPIN_REQUEST = 'UNPIN_REQUEST';
export const UNPIN_SUCCESS = 'UNPIN_SUCCESS';
export const UNPIN_FAIL = 'UNPIN_FAIL';
export const BOOKMARK_REQUEST = 'BOOKMARK_REQUEST';
export const BOOKMARK_SUCCESS = 'BOOKMARKED_SUCCESS';
export const BOOKMARK_FAIL = 'BOOKMARKED_FAIL';
export const UNBOOKMARK_REQUEST = 'UNBOOKMARKED_REQUEST';
export const UNBOOKMARK_SUCCESS = 'UNBOOKMARKED_SUCCESS';
export const UNBOOKMARK_FAIL = 'UNBOOKMARKED_FAIL';
export const REMOTE_INTERACTION_REQUEST = 'REMOTE_INTERACTION_REQUEST';
export const REMOTE_INTERACTION_SUCCESS = 'REMOTE_INTERACTION_SUCCESS';
export const REMOTE_INTERACTION_FAIL = 'REMOTE_INTERACTION_FAIL';
const messages = defineMessages({
bookmarkAdded: { id: 'status.bookmarked', defaultMessage: 'Bookmark added.' },
bookmarkRemoved: { id: 'status.unbookmarked', defaultMessage: 'Bookmark removed.' },
view: { id: 'snackbar.view', defaultMessage: 'View' },
});
export function reblog(status) {
return function(dispatch, getState) {
if (!isLoggedIn(getState)) return;
dispatch(reblogRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/reblog`).then(function(response) {
// The reblog API method returns a new status wrapped around the original. In this case we are only
// interested in how the original is modified, hence passing it skipping the wrapper
dispatch(importFetchedStatus(response.data.reblog));
dispatch(reblogSuccess(status));
}).catch(function(error) {
dispatch(reblogFail(status, error));
});
};
}
export function unreblog(status) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(unreblogRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/unreblog`).then(response => {
dispatch(unreblogSuccess(status));
}).catch(error => {
dispatch(unreblogFail(status, error));
});
};
}
export function reblogRequest(status) {
return {
type: REBLOG_REQUEST,
status: status,
skipLoading: true,
};
}
export function reblogSuccess(status) {
return {
type: REBLOG_SUCCESS,
status: status,
skipLoading: true,
};
}
export function reblogFail(status, error) {
return {
type: REBLOG_FAIL,
status: status,
error: error,
skipLoading: true,
};
}
export function unreblogRequest(status) {
return {
type: UNREBLOG_REQUEST,
status: status,
skipLoading: true,
};
}
export function unreblogSuccess(status) {
return {
type: UNREBLOG_SUCCESS,
status: status,
skipLoading: true,
};
}
export function unreblogFail(status, error) {
return {
type: UNREBLOG_FAIL,
status: status,
error: error,
skipLoading: true,
};
}
export function favourite(status) {
return function(dispatch, getState) {
if (!isLoggedIn(getState)) return;
dispatch(favouriteRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/favourite`).then(function(response) {
dispatch(favouriteSuccess(status));
}).catch(function(error) {
dispatch(favouriteFail(status, error));
});
};
}
export function unfavourite(status) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(unfavouriteRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/unfavourite`).then(response => {
dispatch(unfavouriteSuccess(status));
}).catch(error => {
dispatch(unfavouriteFail(status, error));
});
};
}
export function favouriteRequest(status) {
return {
type: FAVOURITE_REQUEST,
status: status,
skipLoading: true,
};
}
export function favouriteSuccess(status) {
return {
type: FAVOURITE_SUCCESS,
status: status,
skipLoading: true,
};
}
export function favouriteFail(status, error) {
return {
type: FAVOURITE_FAIL,
status: status,
error: error,
skipLoading: true,
};
}
export function unfavouriteRequest(status) {
return {
type: UNFAVOURITE_REQUEST,
status: status,
skipLoading: true,
};
}
export function unfavouriteSuccess(status) {
return {
type: UNFAVOURITE_SUCCESS,
status: status,
skipLoading: true,
};
}
export function unfavouriteFail(status, error) {
return {
type: UNFAVOURITE_FAIL,
status: status,
error: error,
skipLoading: true,
};
}
export function bookmark(status) {
return function(dispatch, getState) {
dispatch(bookmarkRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/bookmark`).then(function(response) {
dispatch(importFetchedStatus(response.data));
dispatch(bookmarkSuccess(status, response.data));
dispatch(snackbar.success(messages.bookmarkAdded, messages.view, '/bookmarks'));
}).catch(function(error) {
dispatch(bookmarkFail(status, error));
});
};
}
export function unbookmark(status) {
return (dispatch, getState) => {
dispatch(unbookmarkRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/unbookmark`).then(response => {
dispatch(importFetchedStatus(response.data));
dispatch(unbookmarkSuccess(status, response.data));
dispatch(snackbar.success(messages.bookmarkRemoved));
}).catch(error => {
dispatch(unbookmarkFail(status, error));
});
};
}
export function bookmarkRequest(status) {
return {
type: BOOKMARK_REQUEST,
status: status,
};
}
export function bookmarkSuccess(status, response) {
return {
type: BOOKMARK_SUCCESS,
status: status,
response: response,
};
}
export function bookmarkFail(status, error) {
return {
type: BOOKMARK_FAIL,
status: status,
error: error,
};
}
export function unbookmarkRequest(status) {
return {
type: UNBOOKMARK_REQUEST,
status: status,
};
}
export function unbookmarkSuccess(status, response) {
return {
type: UNBOOKMARK_SUCCESS,
status: status,
response: response,
};
}
export function unbookmarkFail(status, error) {
return {
type: UNBOOKMARK_FAIL,
status: status,
error: error,
};
}
export function fetchReblogs(id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchReblogsRequest(id));
api(getState).get(`/api/v1/statuses/${id}/reblogged_by`).then(response => {
dispatch(importFetchedAccounts(response.data));
dispatch(fetchReblogsSuccess(id, response.data));
}).catch(error => {
dispatch(fetchReblogsFail(id, error));
});
};
}
export function fetchReblogsRequest(id) {
return {
type: REBLOGS_FETCH_REQUEST,
id,
};
}
export function fetchReblogsSuccess(id, accounts) {
return {
type: REBLOGS_FETCH_SUCCESS,
id,
accounts,
};
}
export function fetchReblogsFail(id, error) {
return {
type: REBLOGS_FETCH_FAIL,
error,
};
}
export function fetchFavourites(id) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchFavouritesRequest(id));
api(getState).get(`/api/v1/statuses/${id}/favourited_by`).then(response => {
dispatch(importFetchedAccounts(response.data));
dispatch(fetchFavouritesSuccess(id, response.data));
}).catch(error => {
dispatch(fetchFavouritesFail(id, error));
});
};
}
export function fetchFavouritesRequest(id) {
return {
type: FAVOURITES_FETCH_REQUEST,
id,
};
}
export function fetchFavouritesSuccess(id, accounts) {
return {
type: FAVOURITES_FETCH_SUCCESS,
id,
accounts,
};
}
export function fetchFavouritesFail(id, error) {
return {
type: FAVOURITES_FETCH_FAIL,
error,
};
}
export function fetchReactions(id) {
return (dispatch, getState) => {
dispatch(fetchReactionsRequest(id));
api(getState).get(`/api/v1/pleroma/statuses/${id}/reactions`).then(response => {
dispatch(importFetchedAccounts(response.data.map(({ accounts }) => accounts).flat()));
dispatch(fetchReactionsSuccess(id, response.data));
}).catch(error => {
dispatch(fetchReactionsFail(id, error));
});
};
}
export function fetchReactionsRequest(id) {
return {
type: REACTIONS_FETCH_REQUEST,
id,
};
}
export function fetchReactionsSuccess(id, reactions) {
return {
type: REACTIONS_FETCH_SUCCESS,
id,
reactions,
};
}
export function fetchReactionsFail(id, error) {
return {
type: REACTIONS_FETCH_FAIL,
error,
};
}
export function pin(status) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(pinRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/pin`).then(response => {
dispatch(importFetchedStatus(response.data));
dispatch(pinSuccess(status));
}).catch(error => {
dispatch(pinFail(status, error));
});
};
}
export function pinRequest(status) {
return {
type: PIN_REQUEST,
status,
skipLoading: true,
};
}
export function pinSuccess(status) {
return {
type: PIN_SUCCESS,
status,
skipLoading: true,
};
}
export function pinFail(status, error) {
return {
type: PIN_FAIL,
status,
error,
skipLoading: true,
};
}
export function unpin(status) {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(unpinRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/unpin`).then(response => {
dispatch(importFetchedStatus(response.data));
dispatch(unpinSuccess(status));
}).catch(error => {
dispatch(unpinFail(status, error));
});
};
}
export function unpinRequest(status) {
return {
type: UNPIN_REQUEST,
status,
skipLoading: true,
};
}
export function unpinSuccess(status) {
return {
type: UNPIN_SUCCESS,
status,
skipLoading: true,
};
}
export function unpinFail(status, error) {
return {
type: UNPIN_FAIL,
status,
error,
skipLoading: true,
};
}
export function remoteInteraction(ap_id, profile) {
return (dispatch, getState) => {
dispatch(remoteInteractionRequest(ap_id, profile));
return api(getState).post('/api/v1/pleroma/remote_interaction', { ap_id, profile }).then(({ data }) => {
if (data.error) throw new Error(data.error);
dispatch(remoteInteractionSuccess(ap_id, profile, data.url));
return data.url;
}).catch(error => {
dispatch(remoteInteractionFail(ap_id, profile, error));
throw error;
});
};
}
export function remoteInteractionRequest(ap_id, profile) {
return {
type: REMOTE_INTERACTION_REQUEST,
ap_id,
profile,
};
}
export function remoteInteractionSuccess(ap_id, profile, url) {
return {
type: REMOTE_INTERACTION_SUCCESS,
ap_id,
profile,
url,
};
}
export function remoteInteractionFail(ap_id, profile, error) {
return {
type: REMOTE_INTERACTION_FAIL,
ap_id,
profile,
error,
};
}

537
app/soapbox/actions/interactions.ts Normal file
View File

@ -0,0 +1,537 @@
import { defineMessages } from 'react-intl';
import snackbar from 'soapbox/actions/snackbar';
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import { importFetchedAccounts, importFetchedStatus } from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity, Status as StatusEntity } from 'soapbox/types/entities';
const REBLOG_REQUEST = 'REBLOG_REQUEST';
const REBLOG_SUCCESS = 'REBLOG_SUCCESS';
const REBLOG_FAIL = 'REBLOG_FAIL';
const FAVOURITE_REQUEST = 'FAVOURITE_REQUEST';
const FAVOURITE_SUCCESS = 'FAVOURITE_SUCCESS';
const FAVOURITE_FAIL = 'FAVOURITE_FAIL';
const UNREBLOG_REQUEST = 'UNREBLOG_REQUEST';
const UNREBLOG_SUCCESS = 'UNREBLOG_SUCCESS';
const UNREBLOG_FAIL = 'UNREBLOG_FAIL';
const UNFAVOURITE_REQUEST = 'UNFAVOURITE_REQUEST';
const UNFAVOURITE_SUCCESS = 'UNFAVOURITE_SUCCESS';
const UNFAVOURITE_FAIL = 'UNFAVOURITE_FAIL';
const REBLOGS_FETCH_REQUEST = 'REBLOGS_FETCH_REQUEST';
const REBLOGS_FETCH_SUCCESS = 'REBLOGS_FETCH_SUCCESS';
const REBLOGS_FETCH_FAIL = 'REBLOGS_FETCH_FAIL';
const FAVOURITES_FETCH_REQUEST = 'FAVOURITES_FETCH_REQUEST';
const FAVOURITES_FETCH_SUCCESS = 'FAVOURITES_FETCH_SUCCESS';
const FAVOURITES_FETCH_FAIL = 'FAVOURITES_FETCH_FAIL';
const REACTIONS_FETCH_REQUEST = 'REACTIONS_FETCH_REQUEST';
const REACTIONS_FETCH_SUCCESS = 'REACTIONS_FETCH_SUCCESS';
const REACTIONS_FETCH_FAIL = 'REACTIONS_FETCH_FAIL';
const PIN_REQUEST = 'PIN_REQUEST';
const PIN_SUCCESS = 'PIN_SUCCESS';
const PIN_FAIL = 'PIN_FAIL';
const UNPIN_REQUEST = 'UNPIN_REQUEST';
const UNPIN_SUCCESS = 'UNPIN_SUCCESS';
const UNPIN_FAIL = 'UNPIN_FAIL';
const BOOKMARK_REQUEST = 'BOOKMARK_REQUEST';
const BOOKMARK_SUCCESS = 'BOOKMARKED_SUCCESS';
const BOOKMARK_FAIL = 'BOOKMARKED_FAIL';
const UNBOOKMARK_REQUEST = 'UNBOOKMARKED_REQUEST';
const UNBOOKMARK_SUCCESS = 'UNBOOKMARKED_SUCCESS';
const UNBOOKMARK_FAIL = 'UNBOOKMARKED_FAIL';
const REMOTE_INTERACTION_REQUEST = 'REMOTE_INTERACTION_REQUEST';
const REMOTE_INTERACTION_SUCCESS = 'REMOTE_INTERACTION_SUCCESS';
const REMOTE_INTERACTION_FAIL = 'REMOTE_INTERACTION_FAIL';
const messages = defineMessages({
bookmarkAdded: { id: 'status.bookmarked', defaultMessage: 'Bookmark added.' },
bookmarkRemoved: { id: 'status.unbookmarked', defaultMessage: 'Bookmark removed.' },
view: { id: 'snackbar.view', defaultMessage: 'View' },
});
const reblog = (status: StatusEntity) =>
function(dispatch: AppDispatch, getState: () => RootState) {
if (!isLoggedIn(getState)) return;
dispatch(reblogRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/reblog`).then(function(response) {
// The reblog API method returns a new status wrapped around the original. In this case we are only
// interested in how the original is modified, hence passing it skipping the wrapper
dispatch(importFetchedStatus(response.data.reblog));
dispatch(reblogSuccess(status));
}).catch(error => {
dispatch(reblogFail(status, error));
});
};
const unreblog = (status: StatusEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(unreblogRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/unreblog`).then(() => {
dispatch(unreblogSuccess(status));
}).catch(error => {
dispatch(unreblogFail(status, error));
});
};
const reblogRequest = (status: StatusEntity) => ({
type: REBLOG_REQUEST,
status: status,
skipLoading: true,
});
const reblogSuccess = (status: StatusEntity) => ({
type: REBLOG_SUCCESS,
status: status,
skipLoading: true,
});
const reblogFail = (status: StatusEntity, error: AxiosError) => ({
type: REBLOG_FAIL,
status: status,
error: error,
skipLoading: true,
});
const unreblogRequest = (status: StatusEntity) => ({
type: UNREBLOG_REQUEST,
status: status,
skipLoading: true,
});
const unreblogSuccess = (status: StatusEntity) => ({
type: UNREBLOG_SUCCESS,
status: status,
skipLoading: true,
});
const unreblogFail = (status: StatusEntity, error: AxiosError) => ({
type: UNREBLOG_FAIL,
status: status,
error: error,
skipLoading: true,
});
const favourite = (status: StatusEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(favouriteRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/favourite`).then(function(response) {
dispatch(favouriteSuccess(status));
}).catch(function(error) {
dispatch(favouriteFail(status, error));
});
};
const unfavourite = (status: StatusEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(unfavouriteRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/unfavourite`).then(() => {
dispatch(unfavouriteSuccess(status));
}).catch(error => {
dispatch(unfavouriteFail(status, error));
});
};
const favouriteRequest = (status: StatusEntity) => ({
type: FAVOURITE_REQUEST,
status: status,
skipLoading: true,
});
const favouriteSuccess = (status: StatusEntity) => ({
type: FAVOURITE_SUCCESS,
status: status,
skipLoading: true,
});
const favouriteFail = (status: StatusEntity, error: AxiosError) => ({
type: FAVOURITE_FAIL,
status: status,
error: error,
skipLoading: true,
});
const unfavouriteRequest = (status: StatusEntity) => ({
type: UNFAVOURITE_REQUEST,
status: status,
skipLoading: true,
});
const unfavouriteSuccess = (status: StatusEntity) => ({
type: UNFAVOURITE_SUCCESS,
status: status,
skipLoading: true,
});
const unfavouriteFail = (status: StatusEntity, error: AxiosError) => ({
type: UNFAVOURITE_FAIL,
status: status,
error: error,
skipLoading: true,
});
const bookmark = (status: StatusEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(bookmarkRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/bookmark`).then(function(response) {
dispatch(importFetchedStatus(response.data));
dispatch(bookmarkSuccess(status, response.data));
dispatch(snackbar.success(messages.bookmarkAdded, messages.view, '/bookmarks'));
}).catch(function(error) {
dispatch(bookmarkFail(status, error));
});
};
const unbookmark = (status: StatusEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(unbookmarkRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/unbookmark`).then(response => {
dispatch(importFetchedStatus(response.data));
dispatch(unbookmarkSuccess(status, response.data));
dispatch(snackbar.success(messages.bookmarkRemoved));
}).catch(error => {
dispatch(unbookmarkFail(status, error));
});
};
const bookmarkRequest = (status: StatusEntity) => ({
type: BOOKMARK_REQUEST,
status: status,
});
const bookmarkSuccess = (status: StatusEntity, response: APIEntity) => ({
type: BOOKMARK_SUCCESS,
status: status,
response: response,
});
const bookmarkFail = (status: StatusEntity, error: AxiosError) => ({
type: BOOKMARK_FAIL,
status: status,
error: error,
});
const unbookmarkRequest = (status: StatusEntity) => ({
type: UNBOOKMARK_REQUEST,
status: status,
});
const unbookmarkSuccess = (status: StatusEntity, response: APIEntity) => ({
type: UNBOOKMARK_SUCCESS,
status: status,
response: response,
});
const unbookmarkFail = (status: StatusEntity, error: AxiosError) => ({
type: UNBOOKMARK_FAIL,
status: status,
error,
});
const fetchReblogs = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchReblogsRequest(id));
api(getState).get(`/api/v1/statuses/${id}/reblogged_by`).then(response => {
dispatch(importFetchedAccounts(response.data));
dispatch(fetchReblogsSuccess(id, response.data));
}).catch(error => {
dispatch(fetchReblogsFail(id, error));
});
};
const fetchReblogsRequest = (id: string) => ({
type: REBLOGS_FETCH_REQUEST,
id,
});
const fetchReblogsSuccess = (id: string, accounts: APIEntity[]) => ({
type: REBLOGS_FETCH_SUCCESS,
id,
accounts,
});
const fetchReblogsFail = (id: string, error: AxiosError) => ({
type: REBLOGS_FETCH_FAIL,
id,
error,
});
const fetchFavourites = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchFavouritesRequest(id));
api(getState).get(`/api/v1/statuses/${id}/favourited_by`).then(response => {
dispatch(importFetchedAccounts(response.data));
dispatch(fetchFavouritesSuccess(id, response.data));
}).catch(error => {
dispatch(fetchFavouritesFail(id, error));
});
};
const fetchFavouritesRequest = (id: string) => ({
type: FAVOURITES_FETCH_REQUEST,
id,
});
const fetchFavouritesSuccess = (id: string, accounts: APIEntity[]) => ({
type: FAVOURITES_FETCH_SUCCESS,
id,
accounts,
});
const fetchFavouritesFail = (id: string, error: AxiosError) => ({
type: FAVOURITES_FETCH_FAIL,
id,
error,
});
const fetchReactions = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(fetchReactionsRequest(id));
api(getState).get(`/api/v1/pleroma/statuses/${id}/reactions`).then(response => {
dispatch(importFetchedAccounts((response.data as APIEntity[]).map(({ accounts }) => accounts).flat()));
dispatch(fetchReactionsSuccess(id, response.data));
}).catch(error => {
dispatch(fetchReactionsFail(id, error));
});
};
const fetchReactionsRequest = (id: string) => ({
type: REACTIONS_FETCH_REQUEST,
id,
});
const fetchReactionsSuccess = (id: string, reactions: APIEntity[]) => ({
type: REACTIONS_FETCH_SUCCESS,
id,
reactions,
});
const fetchReactionsFail = (id: string, error: AxiosError) => ({
type: REACTIONS_FETCH_FAIL,
id,
error,
});
const pin = (status: StatusEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(pinRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/pin`).then(response => {
dispatch(importFetchedStatus(response.data));
dispatch(pinSuccess(status));
}).catch(error => {
dispatch(pinFail(status, error));
});
};
const pinRequest = (status: StatusEntity) => ({
type: PIN_REQUEST,
status,
skipLoading: true,
});
const pinSuccess = (status: StatusEntity) => ({
type: PIN_SUCCESS,
status,
skipLoading: true,
});
const pinFail = (status: StatusEntity, error: AxiosError) => ({
type: PIN_FAIL,
status,
error,
skipLoading: true,
});
const unpin = (status: StatusEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(unpinRequest(status));
api(getState).post(`/api/v1/statuses/${status.get('id')}/unpin`).then(response => {
dispatch(importFetchedStatus(response.data));
dispatch(unpinSuccess(status));
}).catch(error => {
dispatch(unpinFail(status, error));
});
};
const unpinRequest = (status: StatusEntity) => ({
type: UNPIN_REQUEST,
status,
skipLoading: true,
});
const unpinSuccess = (status: StatusEntity) => ({
type: UNPIN_SUCCESS,
status,
skipLoading: true,
});
const unpinFail = (status: StatusEntity, error: AxiosError) => ({
type: UNPIN_FAIL,
status,
error,
skipLoading: true,
});
const remoteInteraction = (ap_id: string, profile: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(remoteInteractionRequest(ap_id, profile));
return api(getState).post('/api/v1/pleroma/remote_interaction', { ap_id, profile }).then(({ data }) => {
if (data.error) throw new Error(data.error);
dispatch(remoteInteractionSuccess(ap_id, profile, data.url));
return data.url;
}).catch(error => {
dispatch(remoteInteractionFail(ap_id, profile, error));
throw error;
});
};
const remoteInteractionRequest = (ap_id: string, profile: string) => ({
type: REMOTE_INTERACTION_REQUEST,
ap_id,
profile,
});
const remoteInteractionSuccess = (ap_id: string, profile: string, url: string) => ({
type: REMOTE_INTERACTION_SUCCESS,
ap_id,
profile,
url,
});
const remoteInteractionFail = (ap_id: string, profile: string, error: AxiosError) => ({
type: REMOTE_INTERACTION_FAIL,
ap_id,
profile,
error,
});
export {
REBLOG_REQUEST,
REBLOG_SUCCESS,
REBLOG_FAIL,
FAVOURITE_REQUEST,
FAVOURITE_SUCCESS,
FAVOURITE_FAIL,
UNREBLOG_REQUEST,
UNREBLOG_SUCCESS,
UNREBLOG_FAIL,
UNFAVOURITE_REQUEST,
UNFAVOURITE_SUCCESS,
UNFAVOURITE_FAIL,
REBLOGS_FETCH_REQUEST,
REBLOGS_FETCH_SUCCESS,
REBLOGS_FETCH_FAIL,
FAVOURITES_FETCH_REQUEST,
FAVOURITES_FETCH_SUCCESS,
FAVOURITES_FETCH_FAIL,
REACTIONS_FETCH_REQUEST,
REACTIONS_FETCH_SUCCESS,
REACTIONS_FETCH_FAIL,
PIN_REQUEST,
PIN_SUCCESS,
PIN_FAIL,
UNPIN_REQUEST,
UNPIN_SUCCESS,
UNPIN_FAIL,
BOOKMARK_REQUEST,
BOOKMARK_SUCCESS,
BOOKMARK_FAIL,
UNBOOKMARK_REQUEST,
UNBOOKMARK_SUCCESS,
UNBOOKMARK_FAIL,
REMOTE_INTERACTION_REQUEST,
REMOTE_INTERACTION_SUCCESS,
REMOTE_INTERACTION_FAIL,
reblog,
unreblog,
reblogRequest,
reblogSuccess,
reblogFail,
unreblogRequest,
unreblogSuccess,
unreblogFail,
favourite,
unfavourite,
favouriteRequest,
favouriteSuccess,
favouriteFail,
unfavouriteRequest,
unfavouriteSuccess,
unfavouriteFail,
bookmark,
unbookmark,
bookmarkRequest,
bookmarkSuccess,
bookmarkFail,
unbookmarkRequest,
unbookmarkSuccess,
unbookmarkFail,
fetchReblogs,
fetchReblogsRequest,
fetchReblogsSuccess,
fetchReblogsFail,
fetchFavourites,
fetchFavouritesRequest,
fetchFavouritesSuccess,
fetchFavouritesFail,
fetchReactions,
fetchReactionsRequest,
fetchReactionsSuccess,
fetchReactionsFail,
pin,
pinRequest,
pinSuccess,
pinFail,
unpin,
unpinRequest,
unpinSuccess,
unpinFail,
remoteInteraction,
remoteInteractionRequest,
remoteInteractionSuccess,
remoteInteractionFail,
};

394
app/soapbox/actions/lists.js
View File

@ -1,394 +0,0 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import { showAlertForError } from './alerts';
import { importFetchedAccounts } from './importer';
export const LIST_FETCH_REQUEST = 'LIST_FETCH_REQUEST';
export const LIST_FETCH_SUCCESS = 'LIST_FETCH_SUCCESS';
export const LIST_FETCH_FAIL = 'LIST_FETCH_FAIL';
export const LISTS_FETCH_REQUEST = 'LISTS_FETCH_REQUEST';
export const LISTS_FETCH_SUCCESS = 'LISTS_FETCH_SUCCESS';
export const LISTS_FETCH_FAIL = 'LISTS_FETCH_FAIL';
export const LIST_EDITOR_TITLE_CHANGE = 'LIST_EDITOR_TITLE_CHANGE';
export const LIST_EDITOR_RESET = 'LIST_EDITOR_RESET';
export const LIST_EDITOR_SETUP = 'LIST_EDITOR_SETUP';
export const LIST_CREATE_REQUEST = 'LIST_CREATE_REQUEST';
export const LIST_CREATE_SUCCESS = 'LIST_CREATE_SUCCESS';
export const LIST_CREATE_FAIL = 'LIST_CREATE_FAIL';
export const LIST_UPDATE_REQUEST = 'LIST_UPDATE_REQUEST';
export const LIST_UPDATE_SUCCESS = 'LIST_UPDATE_SUCCESS';
export const LIST_UPDATE_FAIL = 'LIST_UPDATE_FAIL';
export const LIST_DELETE_REQUEST = 'LIST_DELETE_REQUEST';
export const LIST_DELETE_SUCCESS = 'LIST_DELETE_SUCCESS';
export const LIST_DELETE_FAIL = 'LIST_DELETE_FAIL';
export const LIST_ACCOUNTS_FETCH_REQUEST = 'LIST_ACCOUNTS_FETCH_REQUEST';
export const LIST_ACCOUNTS_FETCH_SUCCESS = 'LIST_ACCOUNTS_FETCH_SUCCESS';
export const LIST_ACCOUNTS_FETCH_FAIL = 'LIST_ACCOUNTS_FETCH_FAIL';
export const LIST_EDITOR_SUGGESTIONS_CHANGE = 'LIST_EDITOR_SUGGESTIONS_CHANGE';
export const LIST_EDITOR_SUGGESTIONS_READY = 'LIST_EDITOR_SUGGESTIONS_READY';
export const LIST_EDITOR_SUGGESTIONS_CLEAR = 'LIST_EDITOR_SUGGESTIONS_CLEAR';
export const LIST_EDITOR_ADD_REQUEST = 'LIST_EDITOR_ADD_REQUEST';
export const LIST_EDITOR_ADD_SUCCESS = 'LIST_EDITOR_ADD_SUCCESS';
export const LIST_EDITOR_ADD_FAIL = 'LIST_EDITOR_ADD_FAIL';
export const LIST_EDITOR_REMOVE_REQUEST = 'LIST_EDITOR_REMOVE_REQUEST';
export const LIST_EDITOR_REMOVE_SUCCESS = 'LIST_EDITOR_REMOVE_SUCCESS';
export const LIST_EDITOR_REMOVE_FAIL = 'LIST_EDITOR_REMOVE_FAIL';
export const LIST_ADDER_RESET = 'LIST_ADDER_RESET';
export const LIST_ADDER_SETUP = 'LIST_ADDER_SETUP';
export const LIST_ADDER_LISTS_FETCH_REQUEST = 'LIST_ADDER_LISTS_FETCH_REQUEST';
export const LIST_ADDER_LISTS_FETCH_SUCCESS = 'LIST_ADDER_LISTS_FETCH_SUCCESS';
export const LIST_ADDER_LISTS_FETCH_FAIL = 'LIST_ADDER_LISTS_FETCH_FAIL';
export const fetchList = id => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
if (getState().getIn(['lists', id])) {
return;
}
dispatch(fetchListRequest(id));
api(getState).get(`/api/v1/lists/${id}`)
.then(({ data }) => dispatch(fetchListSuccess(data)))
.catch(err => dispatch(fetchListFail(id, err)));
};
export const fetchListRequest = id => ({
type: LIST_FETCH_REQUEST,
id,
});
export const fetchListSuccess = list => ({
type: LIST_FETCH_SUCCESS,
list,
});
export const fetchListFail = (id, error) => ({
type: LIST_FETCH_FAIL,
id,
error,
});
export const fetchLists = () => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchListsRequest());
api(getState).get('/api/v1/lists')
.then(({ data }) => dispatch(fetchListsSuccess(data)))
.catch(err => dispatch(fetchListsFail(err)));
};
export const fetchListsRequest = () => ({
type: LISTS_FETCH_REQUEST,
});
export const fetchListsSuccess = lists => ({
type: LISTS_FETCH_SUCCESS,
lists,
});
export const fetchListsFail = error => ({
type: LISTS_FETCH_FAIL,
error,
});
export const submitListEditor = shouldReset => (dispatch, getState) => {
const listId = getState().getIn(['listEditor', 'listId']);
const title = getState().getIn(['listEditor', 'title']);
if (listId === null) {
dispatch(createList(title, shouldReset));
} else {
dispatch(updateList(listId, title, shouldReset));
}
};
export const setupListEditor = listId => (dispatch, getState) => {
dispatch({
type: LIST_EDITOR_SETUP,
list: getState().getIn(['lists', listId]),
});
dispatch(fetchListAccounts(listId));
};
export const changeListEditorTitle = value => ({
type: LIST_EDITOR_TITLE_CHANGE,
value,
});
export const createList = (title, shouldReset) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(createListRequest());
api(getState).post('/api/v1/lists', { title }).then(({ data }) => {
dispatch(createListSuccess(data));
if (shouldReset) {
dispatch(resetListEditor());
}
}).catch(err => dispatch(createListFail(err)));
};
export const createListRequest = () => ({
type: LIST_CREATE_REQUEST,
});
export const createListSuccess = list => ({
type: LIST_CREATE_SUCCESS,
list,
});
export const createListFail = error => ({
type: LIST_CREATE_FAIL,
error,
});
export const updateList = (id, title, shouldReset) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(updateListRequest(id));
api(getState).put(`/api/v1/lists/${id}`, { title }).then(({ data }) => {
dispatch(updateListSuccess(data));
if (shouldReset) {
dispatch(resetListEditor());
}
}).catch(err => dispatch(updateListFail(id, err)));
};
export const updateListRequest = id => ({
type: LIST_UPDATE_REQUEST,
id,
});
export const updateListSuccess = list => ({
type: LIST_UPDATE_SUCCESS,
list,
});
export const updateListFail = (id, error) => ({
type: LIST_UPDATE_FAIL,
id,
error,
});
export const resetListEditor = () => ({
type: LIST_EDITOR_RESET,
});
export const deleteList = id => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(deleteListRequest(id));
api(getState).delete(`/api/v1/lists/${id}`)
.then(() => dispatch(deleteListSuccess(id)))
.catch(err => dispatch(deleteListFail(id, err)));
};
export const deleteListRequest = id => ({
type: LIST_DELETE_REQUEST,
id,
});
export const deleteListSuccess = id => ({
type: LIST_DELETE_SUCCESS,
id,
});
export const deleteListFail = (id, error) => ({
type: LIST_DELETE_FAIL,
id,
error,
});
export const fetchListAccounts = listId => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchListAccountsRequest(listId));
api(getState).get(`/api/v1/lists/${listId}/accounts`, { params: { limit: 0 } }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(fetchListAccountsSuccess(listId, data));
}).catch(err => dispatch(fetchListAccountsFail(listId, err)));
};
export const fetchListAccountsRequest = id => ({
type: LIST_ACCOUNTS_FETCH_REQUEST,
id,
});
export const fetchListAccountsSuccess = (id, accounts, next) => ({
type: LIST_ACCOUNTS_FETCH_SUCCESS,
id,
accounts,
next,
});
export const fetchListAccountsFail = (id, error) => ({
type: LIST_ACCOUNTS_FETCH_FAIL,
id,
error,
});
export const fetchListSuggestions = q => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const params = {
q,
resolve: false,
limit: 4,
following: true,
};
api(getState).get('/api/v1/accounts/search', { params }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(fetchListSuggestionsReady(q, data));
}).catch(error => dispatch(showAlertForError(error)));
};
export const fetchListSuggestionsReady = (query, accounts) => ({
type: LIST_EDITOR_SUGGESTIONS_READY,
query,
accounts,
});
export const clearListSuggestions = () => ({
type: LIST_EDITOR_SUGGESTIONS_CLEAR,
});
export const changeListSuggestions = value => ({
type: LIST_EDITOR_SUGGESTIONS_CHANGE,
value,
});
export const addToListEditor = accountId => (dispatch, getState) => {
dispatch(addToList(getState().getIn(['listEditor', 'listId']), accountId));
};
export const addToList = (listId, accountId) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(addToListRequest(listId, accountId));
api(getState).post(`/api/v1/lists/${listId}/accounts`, { account_ids: [accountId] })
.then(() => dispatch(addToListSuccess(listId, accountId)))
.catch(err => dispatch(addToListFail(listId, accountId, err)));
};
export const addToListRequest = (listId, accountId) => ({
type: LIST_EDITOR_ADD_REQUEST,
listId,
accountId,
});
export const addToListSuccess = (listId, accountId) => ({
type: LIST_EDITOR_ADD_SUCCESS,
listId,
accountId,
});
export const addToListFail = (listId, accountId, error) => ({
type: LIST_EDITOR_ADD_FAIL,
listId,
accountId,
error,
});
export const removeFromListEditor = accountId => (dispatch, getState) => {
dispatch(removeFromList(getState().getIn(['listEditor', 'listId']), accountId));
};
export const removeFromList = (listId, accountId) => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(removeFromListRequest(listId, accountId));
api(getState).delete(`/api/v1/lists/${listId}/accounts`, { params: { account_ids: [accountId] } })
.then(() => dispatch(removeFromListSuccess(listId, accountId)))
.catch(err => dispatch(removeFromListFail(listId, accountId, err)));
};
export const removeFromListRequest = (listId, accountId) => ({
type: LIST_EDITOR_REMOVE_REQUEST,
listId,
accountId,
});
export const removeFromListSuccess = (listId, accountId) => ({
type: LIST_EDITOR_REMOVE_SUCCESS,
listId,
accountId,
});
export const removeFromListFail = (listId, accountId, error) => ({
type: LIST_EDITOR_REMOVE_FAIL,
listId,
accountId,
error,
});
export const resetListAdder = () => ({
type: LIST_ADDER_RESET,
});
export const setupListAdder = accountId => (dispatch, getState) => {
dispatch({
type: LIST_ADDER_SETUP,
account: getState().getIn(['accounts', accountId]),
});
dispatch(fetchLists());
dispatch(fetchAccountLists(accountId));
};
export const fetchAccountLists = accountId => (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchAccountListsRequest(accountId));
api(getState).get(`/api/v1/accounts/${accountId}/lists`)
.then(({ data }) => dispatch(fetchAccountListsSuccess(accountId, data)))
.catch(err => dispatch(fetchAccountListsFail(accountId, err)));
};
export const fetchAccountListsRequest = id => ({
type: LIST_ADDER_LISTS_FETCH_REQUEST,
id,
});
export const fetchAccountListsSuccess = (id, lists) => ({
type: LIST_ADDER_LISTS_FETCH_SUCCESS,
id,
lists,
});
export const fetchAccountListsFail = (id, err) => ({
type: LIST_ADDER_LISTS_FETCH_FAIL,
id,
err,
});
export const addToListAdder = listId => (dispatch, getState) => {
dispatch(addToList(listId, getState().getIn(['listAdder', 'accountId'])));
};
export const removeFromListAdder = listId => (dispatch, getState) => {
dispatch(removeFromList(listId, getState().getIn(['listAdder', 'accountId'])));
};

486
app/soapbox/actions/lists.ts Normal file
View File

@ -0,0 +1,486 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import { showAlertForError } from './alerts';
import { importFetchedAccounts } from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const LIST_FETCH_REQUEST = 'LIST_FETCH_REQUEST';
const LIST_FETCH_SUCCESS = 'LIST_FETCH_SUCCESS';
const LIST_FETCH_FAIL = 'LIST_FETCH_FAIL';
const LISTS_FETCH_REQUEST = 'LISTS_FETCH_REQUEST';
const LISTS_FETCH_SUCCESS = 'LISTS_FETCH_SUCCESS';
const LISTS_FETCH_FAIL = 'LISTS_FETCH_FAIL';
const LIST_EDITOR_TITLE_CHANGE = 'LIST_EDITOR_TITLE_CHANGE';
const LIST_EDITOR_RESET = 'LIST_EDITOR_RESET';
const LIST_EDITOR_SETUP = 'LIST_EDITOR_SETUP';
const LIST_CREATE_REQUEST = 'LIST_CREATE_REQUEST';
const LIST_CREATE_SUCCESS = 'LIST_CREATE_SUCCESS';
const LIST_CREATE_FAIL = 'LIST_CREATE_FAIL';
const LIST_UPDATE_REQUEST = 'LIST_UPDATE_REQUEST';
const LIST_UPDATE_SUCCESS = 'LIST_UPDATE_SUCCESS';
const LIST_UPDATE_FAIL = 'LIST_UPDATE_FAIL';
const LIST_DELETE_REQUEST = 'LIST_DELETE_REQUEST';
const LIST_DELETE_SUCCESS = 'LIST_DELETE_SUCCESS';
const LIST_DELETE_FAIL = 'LIST_DELETE_FAIL';
const LIST_ACCOUNTS_FETCH_REQUEST = 'LIST_ACCOUNTS_FETCH_REQUEST';
const LIST_ACCOUNTS_FETCH_SUCCESS = 'LIST_ACCOUNTS_FETCH_SUCCESS';
const LIST_ACCOUNTS_FETCH_FAIL = 'LIST_ACCOUNTS_FETCH_FAIL';
const LIST_EDITOR_SUGGESTIONS_CHANGE = 'LIST_EDITOR_SUGGESTIONS_CHANGE';
const LIST_EDITOR_SUGGESTIONS_READY = 'LIST_EDITOR_SUGGESTIONS_READY';
const LIST_EDITOR_SUGGESTIONS_CLEAR = 'LIST_EDITOR_SUGGESTIONS_CLEAR';
const LIST_EDITOR_ADD_REQUEST = 'LIST_EDITOR_ADD_REQUEST';
const LIST_EDITOR_ADD_SUCCESS = 'LIST_EDITOR_ADD_SUCCESS';
const LIST_EDITOR_ADD_FAIL = 'LIST_EDITOR_ADD_FAIL';
const LIST_EDITOR_REMOVE_REQUEST = 'LIST_EDITOR_REMOVE_REQUEST';
const LIST_EDITOR_REMOVE_SUCCESS = 'LIST_EDITOR_REMOVE_SUCCESS';
const LIST_EDITOR_REMOVE_FAIL = 'LIST_EDITOR_REMOVE_FAIL';
const LIST_ADDER_RESET = 'LIST_ADDER_RESET';
const LIST_ADDER_SETUP = 'LIST_ADDER_SETUP';
const LIST_ADDER_LISTS_FETCH_REQUEST = 'LIST_ADDER_LISTS_FETCH_REQUEST';
const LIST_ADDER_LISTS_FETCH_SUCCESS = 'LIST_ADDER_LISTS_FETCH_SUCCESS';
const LIST_ADDER_LISTS_FETCH_FAIL = 'LIST_ADDER_LISTS_FETCH_FAIL';
const fetchList = (id: string | number) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
if (getState().lists.get(String(id))) {
return;
}
dispatch(fetchListRequest(id));
api(getState).get(`/api/v1/lists/${id}`)
.then(({ data }) => dispatch(fetchListSuccess(data)))
.catch(err => dispatch(fetchListFail(id, err)));
};
const fetchListRequest = (id: string | number) => ({
type: LIST_FETCH_REQUEST,
id,
});
const fetchListSuccess = (list: APIEntity) => ({
type: LIST_FETCH_SUCCESS,
list,
});
const fetchListFail = (id: string | number, error: AxiosError) => ({
type: LIST_FETCH_FAIL,
id,
error,
});
const fetchLists = () => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchListsRequest());
api(getState).get('/api/v1/lists')
.then(({ data }) => dispatch(fetchListsSuccess(data)))
.catch(err => dispatch(fetchListsFail(err)));
};
const fetchListsRequest = () => ({
type: LISTS_FETCH_REQUEST,
});
const fetchListsSuccess = (lists: APIEntity[]) => ({
type: LISTS_FETCH_SUCCESS,
lists,
});
const fetchListsFail = (error: AxiosError) => ({
type: LISTS_FETCH_FAIL,
error,
});
const submitListEditor = (shouldReset?: boolean) => (dispatch: AppDispatch, getState: () => RootState) => {
const listId = getState().listEditor.listId!;
const title = getState().listEditor.title;
if (listId === null) {
dispatch(createList(title, shouldReset));
} else {
dispatch(updateList(listId, title, shouldReset));
}
};
const setupListEditor = (listId: string | number) => (dispatch: AppDispatch, getState: () => RootState) => {
dispatch({
type: LIST_EDITOR_SETUP,
list: getState().lists.get(String(listId)),
});
dispatch(fetchListAccounts(listId));
};
const changeListEditorTitle = (value: string) => ({
type: LIST_EDITOR_TITLE_CHANGE,
value,
});
const createList = (title: string, shouldReset?: boolean) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(createListRequest());
api(getState).post('/api/v1/lists', { title }).then(({ data }) => {
dispatch(createListSuccess(data));
if (shouldReset) {
dispatch(resetListEditor());
}
}).catch(err => dispatch(createListFail(err)));
};
const createListRequest = () => ({
type: LIST_CREATE_REQUEST,
});
const createListSuccess = (list: APIEntity) => ({
type: LIST_CREATE_SUCCESS,
list,
});
const createListFail = (error: AxiosError) => ({
type: LIST_CREATE_FAIL,
error,
});
const updateList = (id: string | number, title: string, shouldReset?: boolean) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(updateListRequest(id));
api(getState).put(`/api/v1/lists/${id}`, { title }).then(({ data }) => {
dispatch(updateListSuccess(data));
if (shouldReset) {
dispatch(resetListEditor());
}
}).catch(err => dispatch(updateListFail(id, err)));
};
const updateListRequest = (id: string | number) => ({
type: LIST_UPDATE_REQUEST,
id,
});
const updateListSuccess = (list: APIEntity) => ({
type: LIST_UPDATE_SUCCESS,
list,
});
const updateListFail = (id: string | number, error: AxiosError) => ({
type: LIST_UPDATE_FAIL,
id,
error,
});
const resetListEditor = () => ({
type: LIST_EDITOR_RESET,
});
const deleteList = (id: string | number) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(deleteListRequest(id));
api(getState).delete(`/api/v1/lists/${id}`)
.then(() => dispatch(deleteListSuccess(id)))
.catch(err => dispatch(deleteListFail(id, err)));
};
const deleteListRequest = (id: string | number) => ({
type: LIST_DELETE_REQUEST,
id,
});
const deleteListSuccess = (id: string | number) => ({
type: LIST_DELETE_SUCCESS,
id,
});
const deleteListFail = (id: string | number, error: AxiosError) => ({
type: LIST_DELETE_FAIL,
id,
error,
});
const fetchListAccounts = (listId: string | number) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchListAccountsRequest(listId));
api(getState).get(`/api/v1/lists/${listId}/accounts`, { params: { limit: 0 } }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(fetchListAccountsSuccess(listId, data, null));
}).catch(err => dispatch(fetchListAccountsFail(listId, err)));
};
const fetchListAccountsRequest = (id: string | number) => ({
type: LIST_ACCOUNTS_FETCH_REQUEST,
id,
});
const fetchListAccountsSuccess = (id: string | number, accounts: APIEntity[], next: string | null) => ({
type: LIST_ACCOUNTS_FETCH_SUCCESS,
id,
accounts,
next,
});
const fetchListAccountsFail = (id: string | number, error: AxiosError) => ({
type: LIST_ACCOUNTS_FETCH_FAIL,
id,
error,
});
const fetchListSuggestions = (q: string) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const params = {
q,
resolve: false,
limit: 4,
following: true,
};
api(getState).get('/api/v1/accounts/search', { params }).then(({ data }) => {
dispatch(importFetchedAccounts(data));
dispatch(fetchListSuggestionsReady(q, data));
}).catch(error => dispatch(showAlertForError(error)));
};
const fetchListSuggestionsReady = (query: string, accounts: APIEntity[]) => ({
type: LIST_EDITOR_SUGGESTIONS_READY,
query,
accounts,
});
const clearListSuggestions = () => ({
type: LIST_EDITOR_SUGGESTIONS_CLEAR,
});
const changeListSuggestions = (value: string) => ({
type: LIST_EDITOR_SUGGESTIONS_CHANGE,
value,
});
const addToListEditor = (accountId: string) => (dispatch: AppDispatch, getState: () => RootState) => {
dispatch(addToList(getState().listEditor.listId!, accountId));
};
const addToList = (listId: string | number, accountId: string) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(addToListRequest(listId, accountId));
api(getState).post(`/api/v1/lists/${listId}/accounts`, { account_ids: [accountId] })
.then(() => dispatch(addToListSuccess(listId, accountId)))
.catch(err => dispatch(addToListFail(listId, accountId, err)));
};
const addToListRequest = (listId: string | number, accountId: string) => ({
type: LIST_EDITOR_ADD_REQUEST,
listId,
accountId,
});
const addToListSuccess = (listId: string | number, accountId: string) => ({
type: LIST_EDITOR_ADD_SUCCESS,
listId,
accountId,
});
const addToListFail = (listId: string | number, accountId: string, error: APIEntity) => ({
type: LIST_EDITOR_ADD_FAIL,
listId,
accountId,
error,
});
const removeFromListEditor = (accountId: string) => (dispatch: AppDispatch, getState: () => RootState) => {
dispatch(removeFromList(getState().listEditor.listId!, accountId));
};
const removeFromList = (listId: string | number, accountId: string) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(removeFromListRequest(listId, accountId));
api(getState).delete(`/api/v1/lists/${listId}/accounts`, { params: { account_ids: [accountId] } })
.then(() => dispatch(removeFromListSuccess(listId, accountId)))
.catch(err => dispatch(removeFromListFail(listId, accountId, err)));
};
const removeFromListRequest = (listId: string | number, accountId: string) => ({
type: LIST_EDITOR_REMOVE_REQUEST,
listId,
accountId,
});
const removeFromListSuccess = (listId: string | number, accountId: string) => ({
type: LIST_EDITOR_REMOVE_SUCCESS,
listId,
accountId,
});
const removeFromListFail = (listId: string | number, accountId: string, error: AxiosError) => ({
type: LIST_EDITOR_REMOVE_FAIL,
listId,
accountId,
error,
});
const resetListAdder = () => ({
type: LIST_ADDER_RESET,
});
const setupListAdder = (accountId: string) => (dispatch: AppDispatch, getState: () => RootState) => {
dispatch({
type: LIST_ADDER_SETUP,
account: getState().accounts.get(accountId),
});
dispatch(fetchLists());
dispatch(fetchAccountLists(accountId));
};
const fetchAccountLists = (accountId: string) => (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch(fetchAccountListsRequest(accountId));
api(getState).get(`/api/v1/accounts/${accountId}/lists`)
.then(({ data }) => dispatch(fetchAccountListsSuccess(accountId, data)))
.catch(err => dispatch(fetchAccountListsFail(accountId, err)));
};
const fetchAccountListsRequest = (id: string) => ({
type: LIST_ADDER_LISTS_FETCH_REQUEST,
id,
});
const fetchAccountListsSuccess = (id: string, lists: APIEntity[]) => ({
type: LIST_ADDER_LISTS_FETCH_SUCCESS,
id,
lists,
});
const fetchAccountListsFail = (id: string, err: AxiosError) => ({
type: LIST_ADDER_LISTS_FETCH_FAIL,
id,
err,
});
const addToListAdder = (listId: string | number) => (dispatch: AppDispatch, getState: () => RootState) => {
dispatch(addToList(listId, getState().listAdder.accountId!));
};
const removeFromListAdder = (listId: string | number) => (dispatch: AppDispatch, getState: () => RootState) => {
dispatch(removeFromList(listId, getState().listAdder.accountId!));
};
export {
LIST_FETCH_REQUEST,
LIST_FETCH_SUCCESS,
LIST_FETCH_FAIL,
LISTS_FETCH_REQUEST,
LISTS_FETCH_SUCCESS,
LISTS_FETCH_FAIL,
LIST_EDITOR_TITLE_CHANGE,
LIST_EDITOR_RESET,
LIST_EDITOR_SETUP,
LIST_CREATE_REQUEST,
LIST_CREATE_SUCCESS,
LIST_CREATE_FAIL,
LIST_UPDATE_REQUEST,
LIST_UPDATE_SUCCESS,
LIST_UPDATE_FAIL,
LIST_DELETE_REQUEST,
LIST_DELETE_SUCCESS,
LIST_DELETE_FAIL,
LIST_ACCOUNTS_FETCH_REQUEST,
LIST_ACCOUNTS_FETCH_SUCCESS,
LIST_ACCOUNTS_FETCH_FAIL,
LIST_EDITOR_SUGGESTIONS_CHANGE,
LIST_EDITOR_SUGGESTIONS_READY,
LIST_EDITOR_SUGGESTIONS_CLEAR,
LIST_EDITOR_ADD_REQUEST,
LIST_EDITOR_ADD_SUCCESS,
LIST_EDITOR_ADD_FAIL,
LIST_EDITOR_REMOVE_REQUEST,
LIST_EDITOR_REMOVE_SUCCESS,
LIST_EDITOR_REMOVE_FAIL,
LIST_ADDER_RESET,
LIST_ADDER_SETUP,
LIST_ADDER_LISTS_FETCH_REQUEST,
LIST_ADDER_LISTS_FETCH_SUCCESS,
LIST_ADDER_LISTS_FETCH_FAIL,
fetchList,
fetchListRequest,
fetchListSuccess,
fetchListFail,
fetchLists,
fetchListsRequest,
fetchListsSuccess,
fetchListsFail,
submitListEditor,
setupListEditor,
changeListEditorTitle,
createList,
createListRequest,
createListSuccess,
createListFail,
updateList,
updateListRequest,
updateListSuccess,
updateListFail,
resetListEditor,
deleteList,
deleteListRequest,
deleteListSuccess,
deleteListFail,
fetchListAccounts,
fetchListAccountsRequest,
fetchListAccountsSuccess,
fetchListAccountsFail,
fetchListSuggestions,
fetchListSuggestionsReady,
clearListSuggestions,
changeListSuggestions,
addToListEditor,
addToList,
addToListRequest,
addToListSuccess,
addToListFail,
removeFromListEditor,
removeFromList,
removeFromListRequest,
removeFromListSuccess,
removeFromListFail,
resetListAdder,
setupListAdder,
fetchAccountLists,
fetchAccountListsRequest,
fetchAccountListsSuccess,
fetchAccountListsFail,
addToListAdder,
removeFromListAdder,
};

33
app/soapbox/actions/markers.js
View File

@ -1,33 +0,0 @@
import api from '../api';
export const MARKER_FETCH_REQUEST = 'MARKER_FETCH_REQUEST';
export const MARKER_FETCH_SUCCESS = 'MARKER_FETCH_SUCCESS';
export const MARKER_FETCH_FAIL = 'MARKER_FETCH_FAIL';
export const MARKER_SAVE_REQUEST = 'MARKER_SAVE_REQUEST';
export const MARKER_SAVE_SUCCESS = 'MARKER_SAVE_SUCCESS';
export const MARKER_SAVE_FAIL = 'MARKER_SAVE_FAIL';
export function fetchMarker(timeline) {
return (dispatch, getState) => {
dispatch({ type: MARKER_FETCH_REQUEST });
return api(getState).get('/api/v1/markers', {
params: { timeline },
}).then(({ data: marker }) => {
dispatch({ type: MARKER_FETCH_SUCCESS, marker });
}).catch(error => {
dispatch({ type: MARKER_FETCH_FAIL, error });
});
};
}
export function saveMarker(marker) {
return (dispatch, getState) => {
dispatch({ type: MARKER_SAVE_REQUEST, marker });
return api(getState).post('/api/v1/markers', marker).then(({ data: marker }) => {
dispatch({ type: MARKER_SAVE_SUCCESS, marker });
}).catch(error => {
dispatch({ type: MARKER_SAVE_FAIL, error });
});
};
}

45
app/soapbox/actions/markers.ts Normal file
View File

@ -0,0 +1,45 @@
import api from '../api';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const MARKER_FETCH_REQUEST = 'MARKER_FETCH_REQUEST';
const MARKER_FETCH_SUCCESS = 'MARKER_FETCH_SUCCESS';
const MARKER_FETCH_FAIL = 'MARKER_FETCH_FAIL';
const MARKER_SAVE_REQUEST = 'MARKER_SAVE_REQUEST';
const MARKER_SAVE_SUCCESS = 'MARKER_SAVE_SUCCESS';
const MARKER_SAVE_FAIL = 'MARKER_SAVE_FAIL';
const fetchMarker = (timeline: Array<string>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: MARKER_FETCH_REQUEST });
return api(getState).get('/api/v1/markers', {
params: { timeline },
}).then(({ data: marker }) => {
dispatch({ type: MARKER_FETCH_SUCCESS, marker });
}).catch(error => {
dispatch({ type: MARKER_FETCH_FAIL, error });
});
};
const saveMarker = (marker: APIEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: MARKER_SAVE_REQUEST, marker });
return api(getState).post('/api/v1/markers', marker).then(({ data: marker }) => {
dispatch({ type: MARKER_SAVE_SUCCESS, marker });
}).catch(error => {
dispatch({ type: MARKER_SAVE_FAIL, error });
});
};
export {
MARKER_FETCH_REQUEST,
MARKER_FETCH_SUCCESS,
MARKER_FETCH_FAIL,
MARKER_SAVE_REQUEST,
MARKER_SAVE_SUCCESS,
MARKER_SAVE_FAIL,
fetchMarker,
saveMarker,
};

123
app/soapbox/actions/me.js
View File

@ -1,123 +0,0 @@
import KVStore from 'soapbox/storage/kv_store';
import { getAuthUserId, getAuthUserUrl } from 'soapbox/utils/auth';
import api from '../api';
import { loadCredentials } from './auth';
import { importFetchedAccount } from './importer';
export const ME_FETCH_REQUEST = 'ME_FETCH_REQUEST';
export const ME_FETCH_SUCCESS = 'ME_FETCH_SUCCESS';
export const ME_FETCH_FAIL = 'ME_FETCH_FAIL';
export const ME_FETCH_SKIP = 'ME_FETCH_SKIP';
export const ME_PATCH_REQUEST = 'ME_PATCH_REQUEST';
export const ME_PATCH_SUCCESS = 'ME_PATCH_SUCCESS';
export const ME_PATCH_FAIL = 'ME_PATCH_FAIL';
const noOp = () => new Promise(f => f());
const getMeId = state => state.get('me') || getAuthUserId(state);
const getMeUrl = state => {
const accountId = getMeId(state);
return state.getIn(['accounts', accountId, 'url']) || getAuthUserUrl(state);
};
const getMeToken = state => {
// Fallback for upgrading IDs to URLs
const accountUrl = getMeUrl(state) || state.getIn(['auth', 'me']);
return state.getIn(['auth', 'users', accountUrl, 'access_token']);
};
export function fetchMe() {
return (dispatch, getState) => {
const state = getState();
const token = getMeToken(state);
const accountUrl = getMeUrl(state);
if (!token) {
dispatch({ type: ME_FETCH_SKIP }); return noOp();
}
dispatch(fetchMeRequest());
return dispatch(loadCredentials(token, accountUrl)).catch(error => {
dispatch(fetchMeFail(error));
});
};
}
/** Update the auth account in IndexedDB for Mastodon, etc. */
const persistAuthAccount = (account, params) => {
if (account && account.url) {
if (!account.pleroma) account.pleroma = {};
if (!account.pleroma.settings_store) {
account.pleroma.settings_store = params.pleroma_settings_store || {};
}
KVStore.setItem(`authAccount:${account.url}`, account).catch(console.error);
}
};
export function patchMe(params) {
return (dispatch, getState) => {
dispatch(patchMeRequest());
return api(getState)
.patch('/api/v1/accounts/update_credentials', params)
.then(response => {
persistAuthAccount(response.data, params);
dispatch(patchMeSuccess(response.data));
}).catch(error => {
dispatch(patchMeFail(error));
throw error;
});
};
}
export function fetchMeRequest() {
return {
type: ME_FETCH_REQUEST,
};
}
export function fetchMeSuccess(me) {
return (dispatch, getState) => {
dispatch({
type: ME_FETCH_SUCCESS,
me,
});
};
}
export function fetchMeFail(error) {
return {
type: ME_FETCH_FAIL,
error,
skipAlert: true,
};
}
export function patchMeRequest() {
return {
type: ME_PATCH_REQUEST,
};
}
export function patchMeSuccess(me) {
return (dispatch, getState) => {
dispatch(importFetchedAccount(me));
dispatch({
type: ME_PATCH_SUCCESS,
me,
});
};
}
export function patchMeFail(error) {
return {
type: ME_PATCH_FAIL,
error,
skipAlert: true,
};
}

133
app/soapbox/actions/me.ts Normal file
View File

@ -0,0 +1,133 @@
import KVStore from 'soapbox/storage/kv_store';
import { getAuthUserId, getAuthUserUrl } from 'soapbox/utils/auth';
import api from '../api';
import { loadCredentials } from './auth';
import { importFetchedAccount } from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const ME_FETCH_REQUEST = 'ME_FETCH_REQUEST';
const ME_FETCH_SUCCESS = 'ME_FETCH_SUCCESS';
const ME_FETCH_FAIL = 'ME_FETCH_FAIL';
const ME_FETCH_SKIP = 'ME_FETCH_SKIP';
const ME_PATCH_REQUEST = 'ME_PATCH_REQUEST';
const ME_PATCH_SUCCESS = 'ME_PATCH_SUCCESS';
const ME_PATCH_FAIL = 'ME_PATCH_FAIL';
const noOp = () => new Promise(f => f(undefined));
const getMeId = (state: RootState) => state.me || getAuthUserId(state);
const getMeUrl = (state: RootState) => {
const accountId = getMeId(state);
return state.accounts.get(accountId)?.url || getAuthUserUrl(state);
};
const getMeToken = (state: RootState) => {
// Fallback for upgrading IDs to URLs
const accountUrl = getMeUrl(state) || state.auth.get('me');
return state.auth.getIn(['users', accountUrl, 'access_token']);
};
const fetchMe = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const token = getMeToken(state);
const accountUrl = getMeUrl(state);
if (!token) {
dispatch({ type: ME_FETCH_SKIP }); return noOp();
}
dispatch(fetchMeRequest());
return dispatch(loadCredentials(token, accountUrl)).catch(error => {
dispatch(fetchMeFail(error));
});
};
/** Update the auth account in IndexedDB for Mastodon, etc. */
const persistAuthAccount = (account: APIEntity, params: Record<string, any>) => {
if (account && account.url) {
if (!account.pleroma) account.pleroma = {};
if (!account.pleroma.settings_store) {
account.pleroma.settings_store = params.pleroma_settings_store || {};
}
KVStore.setItem(`authAccount:${account.url}`, account).catch(console.error);
}
};
const patchMe = (params: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(patchMeRequest());
return api(getState)
.patch('/api/v1/accounts/update_credentials', params)
.then(response => {
persistAuthAccount(response.data, params);
dispatch(patchMeSuccess(response.data));
}).catch(error => {
dispatch(patchMeFail(error));
throw error;
});
};
const fetchMeRequest = () => ({
type: ME_FETCH_REQUEST,
});
const fetchMeSuccess = (me: APIEntity) =>
(dispatch: AppDispatch) => {
dispatch({
type: ME_FETCH_SUCCESS,
me,
});
};
const fetchMeFail = (error: APIEntity) => ({
type: ME_FETCH_FAIL,
error,
skipAlert: true,
});
const patchMeRequest = () => ({
type: ME_PATCH_REQUEST,
});
const patchMeSuccess = (me: APIEntity) =>
(dispatch: AppDispatch) => {
dispatch(importFetchedAccount(me));
dispatch({
type: ME_PATCH_SUCCESS,
me,
});
};
const patchMeFail = (error: AxiosError) => ({
type: ME_PATCH_FAIL,
error,
skipAlert: true,
});
export {
ME_FETCH_REQUEST,
ME_FETCH_SUCCESS,
ME_FETCH_FAIL,
ME_FETCH_SKIP,
ME_PATCH_REQUEST,
ME_PATCH_SUCCESS,
ME_PATCH_FAIL,
fetchMe,
patchMe,
fetchMeRequest,
fetchMeSuccess,
fetchMeFail,
patchMeRequest,
patchMeSuccess,
patchMeFail,
};

47
app/soapbox/actions/media.js
View File

@ -1,47 +0,0 @@
import { getFeatures } from 'soapbox/utils/features';
import api from '../api';
const noOp = (e) => {};
export function fetchMedia(mediaId) {
return (dispatch, getState) => {
return api(getState).get(`/api/v1/media/${mediaId}`);
};
}
export function updateMedia(mediaId, params) {
return (dispatch, getState) => {
return api(getState).put(`/api/v1/media/${mediaId}`, params);
};
}
export function uploadMediaV1(data, onUploadProgress = noOp) {
return (dispatch, getState) => {
return api(getState).post('/api/v1/media', data, {
onUploadProgress: onUploadProgress,
});
};
}
export function uploadMediaV2(data, onUploadProgress = noOp) {
return (dispatch, getState) => {
return api(getState).post('/api/v2/media', data, {
onUploadProgress: onUploadProgress,
});
};
}
export function uploadMedia(data, onUploadProgress = noOp) {
return (dispatch, getState) => {
const state = getState();
const instance = state.get('instance');
const features = getFeatures(instance);
if (features.mediaV2) {
return dispatch(uploadMediaV2(data, onUploadProgress));
} else {
return dispatch(uploadMediaV1(data, onUploadProgress));
}
};
}

52
app/soapbox/actions/media.ts Normal file
View File

@ -0,0 +1,52 @@
import { getFeatures } from 'soapbox/utils/features';
import api from '../api';
import type { AppDispatch, RootState } from 'soapbox/store';
const noOp = (e: any) => {};
const fetchMedia = (mediaId: string) =>
(dispatch: any, getState: () => RootState) => {
return api(getState).get(`/api/v1/media/${mediaId}`);
};
const updateMedia = (mediaId: string, params: Record<string, any>) =>
(dispatch: any, getState: () => RootState) => {
return api(getState).put(`/api/v1/media/${mediaId}`, params);
};
const uploadMediaV1 = (data: FormData, onUploadProgress = noOp) =>
(dispatch: any, getState: () => RootState) =>
api(getState).post('/api/v1/media', data, {
onUploadProgress: onUploadProgress,
});
const uploadMediaV2 = (data: FormData, onUploadProgress = noOp) =>
(dispatch: any, getState: () => RootState) =>
api(getState).post('/api/v2/media', data, {
onUploadProgress: onUploadProgress,
});
const uploadMedia = (data: FormData, onUploadProgress = noOp) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const instance = state.instance;
const features = getFeatures(instance);
if (features.mediaV2) {
return dispatch(uploadMediaV2(data, onUploadProgress));
} else {
return dispatch(uploadMediaV1(data, onUploadProgress));
}
};
export {
fetchMedia,
updateMedia,
uploadMediaV1,
uploadMediaV2,
uploadMedia,
};

84
app/soapbox/actions/mfa.js
View File

@ -1,84 +0,0 @@
import api from '../api';
export const MFA_FETCH_REQUEST = 'MFA_FETCH_REQUEST';
export const MFA_FETCH_SUCCESS = 'MFA_FETCH_SUCCESS';
export const MFA_FETCH_FAIL = 'MFA_FETCH_FAIL';
export const MFA_BACKUP_CODES_FETCH_REQUEST = 'MFA_BACKUP_CODES_FETCH_REQUEST';
export const MFA_BACKUP_CODES_FETCH_SUCCESS = 'MFA_BACKUP_CODES_FETCH_SUCCESS';
export const MFA_BACKUP_CODES_FETCH_FAIL = 'MFA_BACKUP_CODES_FETCH_FAIL';
export const MFA_SETUP_REQUEST = 'MFA_SETUP_REQUEST';
export const MFA_SETUP_SUCCESS = 'MFA_SETUP_SUCCESS';
export const MFA_SETUP_FAIL = 'MFA_SETUP_FAIL';
export const MFA_CONFIRM_REQUEST = 'MFA_CONFIRM_REQUEST';
export const MFA_CONFIRM_SUCCESS = 'MFA_CONFIRM_SUCCESS';
export const MFA_CONFIRM_FAIL = 'MFA_CONFIRM_FAIL';
export const MFA_DISABLE_REQUEST = 'MFA_DISABLE_REQUEST';
export const MFA_DISABLE_SUCCESS = 'MFA_DISABLE_SUCCESS';
export const MFA_DISABLE_FAIL = 'MFA_DISABLE_FAIL';
export function fetchMfa() {
return (dispatch, getState) => {
dispatch({ type: MFA_FETCH_REQUEST });
return api(getState).get('/api/pleroma/accounts/mfa').then(({ data }) => {
dispatch({ type: MFA_FETCH_SUCCESS, data });
}).catch(error => {
dispatch({ type: MFA_FETCH_FAIL });
});
};
}
export function fetchBackupCodes() {
return (dispatch, getState) => {
dispatch({ type: MFA_BACKUP_CODES_FETCH_REQUEST });
return api(getState).get('/api/pleroma/accounts/mfa/backup_codes').then(({ data }) => {
dispatch({ type: MFA_BACKUP_CODES_FETCH_SUCCESS, data });
return data;
}).catch(error => {
dispatch({ type: MFA_BACKUP_CODES_FETCH_FAIL });
});
};
}
export function setupMfa(method) {
return (dispatch, getState) => {
dispatch({ type: MFA_SETUP_REQUEST, method });
return api(getState).get(`/api/pleroma/accounts/mfa/setup/${method}`).then(({ data }) => {
dispatch({ type: MFA_SETUP_SUCCESS, data });
return data;
}).catch(error => {
dispatch({ type: MFA_SETUP_FAIL });
throw error;
});
};
}
export function confirmMfa(method, code, password) {
return (dispatch, getState) => {
const params = { code, password };
dispatch({ type: MFA_CONFIRM_REQUEST, method, code });
return api(getState).post(`/api/pleroma/accounts/mfa/confirm/${method}`, params).then(({ data }) => {
dispatch({ type: MFA_CONFIRM_SUCCESS, method, code });
return data;
}).catch(error => {
dispatch({ type: MFA_CONFIRM_FAIL, method, code, error, skipAlert: true });
throw error;
});
};
}
export function disableMfa(method, password) {
return (dispatch, getState) => {
dispatch({ type: MFA_DISABLE_REQUEST, method });
return api(getState).delete(`/api/pleroma/accounts/mfa/${method}`, { data: { password } }).then(({ data }) => {
dispatch({ type: MFA_DISABLE_SUCCESS, method });
return data;
}).catch(error => {
dispatch({ type: MFA_DISABLE_FAIL, method, skipAlert: true });
throw error;
});
};
}

105
app/soapbox/actions/mfa.ts Normal file
View File

@ -0,0 +1,105 @@
import api from '../api';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
const MFA_FETCH_REQUEST = 'MFA_FETCH_REQUEST';
const MFA_FETCH_SUCCESS = 'MFA_FETCH_SUCCESS';
const MFA_FETCH_FAIL = 'MFA_FETCH_FAIL';
const MFA_BACKUP_CODES_FETCH_REQUEST = 'MFA_BACKUP_CODES_FETCH_REQUEST';
const MFA_BACKUP_CODES_FETCH_SUCCESS = 'MFA_BACKUP_CODES_FETCH_SUCCESS';
const MFA_BACKUP_CODES_FETCH_FAIL = 'MFA_BACKUP_CODES_FETCH_FAIL';
const MFA_SETUP_REQUEST = 'MFA_SETUP_REQUEST';
const MFA_SETUP_SUCCESS = 'MFA_SETUP_SUCCESS';
const MFA_SETUP_FAIL = 'MFA_SETUP_FAIL';
const MFA_CONFIRM_REQUEST = 'MFA_CONFIRM_REQUEST';
const MFA_CONFIRM_SUCCESS = 'MFA_CONFIRM_SUCCESS';
const MFA_CONFIRM_FAIL = 'MFA_CONFIRM_FAIL';
const MFA_DISABLE_REQUEST = 'MFA_DISABLE_REQUEST';
const MFA_DISABLE_SUCCESS = 'MFA_DISABLE_SUCCESS';
const MFA_DISABLE_FAIL = 'MFA_DISABLE_FAIL';
const fetchMfa = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: MFA_FETCH_REQUEST });
return api(getState).get('/api/pleroma/accounts/mfa').then(({ data }) => {
dispatch({ type: MFA_FETCH_SUCCESS, data });
}).catch(() => {
dispatch({ type: MFA_FETCH_FAIL });
});
};
const fetchBackupCodes = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: MFA_BACKUP_CODES_FETCH_REQUEST });
return api(getState).get('/api/pleroma/accounts/mfa/backup_codes').then(({ data }) => {
dispatch({ type: MFA_BACKUP_CODES_FETCH_SUCCESS, data });
return data;
}).catch(() => {
dispatch({ type: MFA_BACKUP_CODES_FETCH_FAIL });
});
};
const setupMfa = (method: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: MFA_SETUP_REQUEST, method });
return api(getState).get(`/api/pleroma/accounts/mfa/setup/${method}`).then(({ data }) => {
dispatch({ type: MFA_SETUP_SUCCESS, data });
return data;
}).catch((error: AxiosError) => {
dispatch({ type: MFA_SETUP_FAIL });
throw error;
});
};
const confirmMfa = (method: string, code: string, password: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const params = { code, password };
dispatch({ type: MFA_CONFIRM_REQUEST, method, code });
return api(getState).post(`/api/pleroma/accounts/mfa/confirm/${method}`, params).then(({ data }) => {
dispatch({ type: MFA_CONFIRM_SUCCESS, method, code });
return data;
}).catch((error: AxiosError) => {
dispatch({ type: MFA_CONFIRM_FAIL, method, code, error, skipAlert: true });
throw error;
});
};
const disableMfa = (method: string, password: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: MFA_DISABLE_REQUEST, method });
return api(getState).delete(`/api/pleroma/accounts/mfa/${method}`, { data: { password } }).then(({ data }) => {
dispatch({ type: MFA_DISABLE_SUCCESS, method });
return data;
}).catch((error: AxiosError) => {
dispatch({ type: MFA_DISABLE_FAIL, method, skipAlert: true });
throw error;
});
};
export {
MFA_FETCH_REQUEST,
MFA_FETCH_SUCCESS,
MFA_FETCH_FAIL,
MFA_BACKUP_CODES_FETCH_REQUEST,
MFA_BACKUP_CODES_FETCH_SUCCESS,
MFA_BACKUP_CODES_FETCH_FAIL,
MFA_SETUP_REQUEST,
MFA_SETUP_SUCCESS,
MFA_SETUP_FAIL,
MFA_CONFIRM_REQUEST,
MFA_CONFIRM_SUCCESS,
MFA_CONFIRM_FAIL,
MFA_DISABLE_REQUEST,
MFA_DISABLE_SUCCESS,
MFA_DISABLE_FAIL,
fetchMfa,
fetchBackupCodes,
setupMfa,
confirmMfa,
disableMfa,
};

20
app/soapbox/actions/mobile.js → app/soapbox/actions/mobile.ts
View File

@ -1,11 +1,13 @@
import { staticClient } from '../api';
export const FETCH_MOBILE_PAGE_REQUEST = 'FETCH_MOBILE_PAGE_REQUEST';
export const FETCH_MOBILE_PAGE_SUCCESS = 'FETCH_MOBILE_PAGE_SUCCESS';
export const FETCH_MOBILE_PAGE_FAIL = 'FETCH_MOBILE_PAGE_FAIL';
import type { AppDispatch } from 'soapbox/store';
export function fetchMobilePage(slug = 'index', locale) {
return (dispatch, getState) => {
const FETCH_MOBILE_PAGE_REQUEST = 'FETCH_MOBILE_PAGE_REQUEST';
const FETCH_MOBILE_PAGE_SUCCESS = 'FETCH_MOBILE_PAGE_SUCCESS';
const FETCH_MOBILE_PAGE_FAIL = 'FETCH_MOBILE_PAGE_FAIL';
const fetchMobilePage = (slug = 'index', locale?: string) =>
(dispatch: AppDispatch) => {
dispatch({ type: FETCH_MOBILE_PAGE_REQUEST, slug, locale });
const filename = `${slug}${locale ? `.${locale}` : ''}.html`;
return staticClient.get(`/instance/mobile/${filename}`).then(({ data: html }) => {
@ -16,4 +18,10 @@ export function fetchMobilePage(slug = 'index', locale) {
throw error;
});
};
}
export {
FETCH_MOBILE_PAGE_REQUEST,
FETCH_MOBILE_PAGE_SUCCESS,
FETCH_MOBILE_PAGE_FAIL,
fetchMobilePage,
};

63
app/soapbox/actions/moderation.js → app/soapbox/actions/moderation.tsx
View File

@ -1,5 +1,5 @@
import React from 'react';
import { defineMessages } from 'react-intl';
import { defineMessages, IntlShape } from 'react-intl';
import { fetchAccountByUsername } from 'soapbox/actions/accounts';
import { deactivateUsers, deleteUsers, deleteStatus, toggleStatusSensitivity } from 'soapbox/actions/admin';
@ -8,6 +8,8 @@ import snackbar from 'soapbox/actions/snackbar';
import AccountContainer from 'soapbox/containers/account_container';
import { isLocal } from 'soapbox/utils/accounts';
import type { AppDispatch, RootState } from 'soapbox/store';
const messages = defineMessages({
deactivateUserHeading: { id: 'confirmations.admin.deactivate_user.heading', defaultMessage: 'Deactivate @{acct}' },
deactivateUserPrompt: { id: 'confirmations.admin.deactivate_user.message', defaultMessage: 'You are about to deactivate @{acct}. Deactivating a user is a reversible action.' },
@ -35,11 +37,11 @@ const messages = defineMessages({
statusMarkedNotSensitive: { id: 'admin.statuses.status_marked_message_not_sensitive', defaultMessage: 'Post by @{acct} was marked not sensitive' },
});
export function deactivateUserModal(intl, accountId, afterConfirm = () => {}) {
return function(dispatch, getState) {
const deactivateUserModal = (intl: IntlShape, accountId: string, afterConfirm = () => {}) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const acct = state.getIn(['accounts', accountId, 'acct']);
const name = state.getIn(['accounts', accountId, 'username']);
const acct = state.accounts.get(accountId)!.acct;
const name = state.accounts.get(accountId)!.username;
dispatch(openModal('CONFIRM', {
icon: require('@tabler/icons/icons/user-off.svg'),
@ -55,15 +57,15 @@ export function deactivateUserModal(intl, accountId, afterConfirm = () => {}) {
},
}));
};
}
export function deleteUserModal(intl, accountId, afterConfirm = () => {}) {
return function(dispatch, getState) {
const deleteUserModal = (intl: IntlShape, accountId: string, afterConfirm = () => {}) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const acct = state.getIn(['accounts', accountId, 'acct']);
const name = state.getIn(['accounts', accountId, 'username']);
const favicon = state.getIn(['accounts', accountId, 'pleroma', 'favicon']);
const local = isLocal(state.getIn(['accounts', accountId]));
const account = state.accounts.get(accountId)!;
const acct = account.acct;
const name = account.username;
const favicon = account.pleroma.get('favicon');
const local = isLocal(account);
const message = (<>
<AccountContainer id={accountId} />
@ -96,13 +98,12 @@ export function deleteUserModal(intl, accountId, afterConfirm = () => {}) {
},
}));
};
}
export function rejectUserModal(intl, accountId, afterConfirm = () => {}) {
return function(dispatch, getState) {
const rejectUserModal = (intl: IntlShape, accountId: string, afterConfirm = () => {}) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const acct = state.getIn(['accounts', accountId, 'acct']);
const name = state.getIn(['accounts', accountId, 'username']);
const acct = state.accounts.get(accountId)!.acct;
const name = state.accounts.get(accountId)!.username;
dispatch(openModal('CONFIRM', {
icon: require('@tabler/icons/icons/user-off.svg'),
@ -118,13 +119,12 @@ export function rejectUserModal(intl, accountId, afterConfirm = () => {}) {
},
}));
};
}
export function toggleStatusSensitivityModal(intl, statusId, sensitive, afterConfirm = () => {}) {
return function(dispatch, getState) {
const toggleStatusSensitivityModal = (intl: IntlShape, statusId: string, sensitive: boolean, afterConfirm = () => {}) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const accountId = state.getIn(['statuses', statusId, 'account']);
const acct = state.getIn(['accounts', accountId, 'acct']);
const accountId = state.statuses.get(statusId)!.account;
const acct = state.accounts.get(accountId)!.acct;
dispatch(openModal('CONFIRM', {
icon: require('@tabler/icons/icons/alert-triangle.svg'),
@ -140,13 +140,12 @@ export function toggleStatusSensitivityModal(intl, statusId, sensitive, afterCon
},
}));
};
}
export function deleteStatusModal(intl, statusId, afterConfirm = () => {}) {
return function(dispatch, getState) {
const deleteStatusModal = (intl: IntlShape, statusId: string, afterConfirm = () => {}) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const accountId = state.getIn(['statuses', statusId, 'account']);
const acct = state.getIn(['accounts', accountId, 'acct']);
const accountId = state.statuses.get(statusId)!.account;
const acct = state.accounts.get(accountId)!.acct;
dispatch(openModal('CONFIRM', {
icon: require('@tabler/icons/icons/trash.svg'),
@ -162,4 +161,12 @@ export function deleteStatusModal(intl, statusId, afterConfirm = () => {}) {
},
}));
};
}
export {
deactivateUserModal,
deleteUserModal,
rejectUserModal,
toggleStatusSensitivityModal,
deleteStatusModal,
};

30
app/soapbox/actions/mrf.js
View File

@ -1,30 +0,0 @@
import { Set as ImmutableSet } from 'immutable';
import ConfigDB from 'soapbox/utils/config_db';
import { fetchConfig, updateConfig } from './admin';
const simplePolicyMerge = (simplePolicy, host, restrictions) => {
return simplePolicy.map((hosts, key) => {
const isRestricted = restrictions.get(key);
if (isRestricted) {
return ImmutableSet(hosts).add(host);
} else {
return ImmutableSet(hosts).delete(host);
}
});
};
export function updateMrf(host, restrictions) {
return (dispatch, getState) => {
return dispatch(fetchConfig())
.then(() => {
const configs = getState().getIn(['admin', 'configs']);
const simplePolicy = ConfigDB.toSimplePolicy(configs);
const merged = simplePolicyMerge(simplePolicy, host, restrictions);
const config = ConfigDB.fromSimplePolicy(merged);
dispatch(updateConfig(config));
});
};
}

33
app/soapbox/actions/mrf.ts Normal file
View File

@ -0,0 +1,33 @@
import { Map as ImmutableMap, Set as ImmutableSet } from 'immutable';
import ConfigDB from 'soapbox/utils/config_db';
import { fetchConfig, updateConfig } from './admin';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { Policy } from 'soapbox/utils/config_db';
const simplePolicyMerge = (simplePolicy: Policy, host: string, restrictions: ImmutableMap<string, any>) => {
return simplePolicy.map((hosts, key) => {
const isRestricted = restrictions.get(key);
if (isRestricted) {
return ImmutableSet(hosts).add(host);
} else {
return ImmutableSet(hosts).delete(host);
}
});
};
const updateMrf = (host: string, restrictions: ImmutableMap<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) =>
dispatch(fetchConfig())
.then(() => {
const configs = getState().admin.get('configs');
const simplePolicy = ConfigDB.toSimplePolicy(configs);
const merged = simplePolicyMerge(simplePolicy, host, restrictions);
const config = ConfigDB.fromSimplePolicy(merged);
return dispatch(updateConfig(config.toJS() as Array<Record<string, any>>));
});
export { updateMrf };

116
app/soapbox/actions/mutes.js
View File

@ -1,116 +0,0 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import { getNextLinkName } from 'soapbox/utils/quirks';
import api, { getLinks } from '../api';
import { fetchRelationships } from './accounts';
import { importFetchedAccounts } from './importer';
import { openModal } from './modals';
export const MUTES_FETCH_REQUEST = 'MUTES_FETCH_REQUEST';
export const MUTES_FETCH_SUCCESS = 'MUTES_FETCH_SUCCESS';
export const MUTES_FETCH_FAIL = 'MUTES_FETCH_FAIL';
export const MUTES_EXPAND_REQUEST = 'MUTES_EXPAND_REQUEST';
export const MUTES_EXPAND_SUCCESS = 'MUTES_EXPAND_SUCCESS';
export const MUTES_EXPAND_FAIL = 'MUTES_EXPAND_FAIL';
export const MUTES_INIT_MODAL = 'MUTES_INIT_MODAL';
export const MUTES_TOGGLE_HIDE_NOTIFICATIONS = 'MUTES_TOGGLE_HIDE_NOTIFICATIONS';
export function fetchMutes() {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const nextLinkName = getNextLinkName(getState);
dispatch(fetchMutesRequest());
api(getState).get('/api/v1/mutes').then(response => {
const next = getLinks(response).refs.find(link => link.rel === nextLinkName);
dispatch(importFetchedAccounts(response.data));
dispatch(fetchMutesSuccess(response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map(item => item.id)));
}).catch(error => dispatch(fetchMutesFail(error)));
};
}
export function fetchMutesRequest() {
return {
type: MUTES_FETCH_REQUEST,
};
}
export function fetchMutesSuccess(accounts, next) {
return {
type: MUTES_FETCH_SUCCESS,
accounts,
next,
};
}
export function fetchMutesFail(error) {
return {
type: MUTES_FETCH_FAIL,
error,
};
}
export function expandMutes() {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const nextLinkName = getNextLinkName(getState);
const url = getState().getIn(['user_lists', 'mutes', 'next']);
if (url === null) {
return;
}
dispatch(expandMutesRequest());
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === nextLinkName);
dispatch(importFetchedAccounts(response.data));
dispatch(expandMutesSuccess(response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map(item => item.id)));
}).catch(error => dispatch(expandMutesFail(error)));
};
}
export function expandMutesRequest() {
return {
type: MUTES_EXPAND_REQUEST,
};
}
export function expandMutesSuccess(accounts, next) {
return {
type: MUTES_EXPAND_SUCCESS,
accounts,
next,
};
}
export function expandMutesFail(error) {
return {
type: MUTES_EXPAND_FAIL,
error,
};
}
export function initMuteModal(account) {
return dispatch => {
dispatch({
type: MUTES_INIT_MODAL,
account,
});
dispatch(openModal('MUTE'));
};
}
export function toggleHideNotifications() {
return dispatch => {
dispatch({ type: MUTES_TOGGLE_HIDE_NOTIFICATIONS });
};
}

125
app/soapbox/actions/mutes.ts Normal file
View File

@ -0,0 +1,125 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import { getNextLinkName } from 'soapbox/utils/quirks';
import api, { getLinks } from '../api';
import { fetchRelationships } from './accounts';
import { importFetchedAccounts } from './importer';
import { openModal } from './modals';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity, Account as AccountEntity } from 'soapbox/types/entities';
const MUTES_FETCH_REQUEST = 'MUTES_FETCH_REQUEST';
const MUTES_FETCH_SUCCESS = 'MUTES_FETCH_SUCCESS';
const MUTES_FETCH_FAIL = 'MUTES_FETCH_FAIL';
const MUTES_EXPAND_REQUEST = 'MUTES_EXPAND_REQUEST';
const MUTES_EXPAND_SUCCESS = 'MUTES_EXPAND_SUCCESS';
const MUTES_EXPAND_FAIL = 'MUTES_EXPAND_FAIL';
const MUTES_INIT_MODAL = 'MUTES_INIT_MODAL';
const MUTES_TOGGLE_HIDE_NOTIFICATIONS = 'MUTES_TOGGLE_HIDE_NOTIFICATIONS';
const fetchMutes = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const nextLinkName = getNextLinkName(getState);
dispatch(fetchMutesRequest());
api(getState).get('/api/v1/mutes').then(response => {
const next = getLinks(response).refs.find(link => link.rel === nextLinkName);
dispatch(importFetchedAccounts(response.data));
dispatch(fetchMutesSuccess(response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map((item: APIEntity) => item.id)));
}).catch(error => dispatch(fetchMutesFail(error)));
};
const fetchMutesRequest = () => ({
type: MUTES_FETCH_REQUEST,
});
const fetchMutesSuccess = (accounts: APIEntity[], next: string | null) => ({
type: MUTES_FETCH_SUCCESS,
accounts,
next,
});
const fetchMutesFail = (error: AxiosError) => ({
type: MUTES_FETCH_FAIL,
error,
});
const expandMutes = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const nextLinkName = getNextLinkName(getState);
const url = getState().user_lists.getIn(['mutes', 'next']);
if (url === null) {
return;
}
dispatch(expandMutesRequest());
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === nextLinkName);
dispatch(importFetchedAccounts(response.data));
dispatch(expandMutesSuccess(response.data, next ? next.uri : null));
dispatch(fetchRelationships(response.data.map((item: APIEntity) => item.id)));
}).catch(error => dispatch(expandMutesFail(error)));
};
const expandMutesRequest = () => ({
type: MUTES_EXPAND_REQUEST,
});
const expandMutesSuccess = (accounts: APIEntity[], next: string | null) => ({
type: MUTES_EXPAND_SUCCESS,
accounts,
next,
});
const expandMutesFail = (error: AxiosError) => ({
type: MUTES_EXPAND_FAIL,
error,
});
const initMuteModal = (account: AccountEntity) =>
(dispatch: AppDispatch) => {
dispatch({
type: MUTES_INIT_MODAL,
account,
});
dispatch(openModal('MUTE'));
};
const toggleHideNotifications = () =>
(dispatch: AppDispatch) => {
dispatch({ type: MUTES_TOGGLE_HIDE_NOTIFICATIONS });
};
export {
MUTES_FETCH_REQUEST,
MUTES_FETCH_SUCCESS,
MUTES_FETCH_FAIL,
MUTES_EXPAND_REQUEST,
MUTES_EXPAND_SUCCESS,
MUTES_EXPAND_FAIL,
MUTES_INIT_MODAL,
MUTES_TOGGLE_HIDE_NOTIFICATIONS,
fetchMutes,
fetchMutesRequest,
fetchMutesSuccess,
fetchMutesFail,
expandMutes,
expandMutesRequest,
expandMutesSuccess,
expandMutesFail,
initMuteModal,
toggleHideNotifications,
};

184
app/soapbox/actions/notifications.js → app/soapbox/actions/notifications.ts
View File

@ -1,20 +1,18 @@
import {
List as ImmutableList,
Map as ImmutableMap,
OrderedMap as ImmutableOrderedMap,
} from 'immutable';
import IntlMessageFormat from 'intl-messageformat';
import 'intl-pluralrules';
import { defineMessages } from 'react-intl';
import api, { getLinks } from 'soapbox/api';
import { getFilters, regexFromFilters } from 'soapbox/selectors';
import { isLoggedIn } from 'soapbox/utils/auth';
import { parseVersion, PLEROMA } from 'soapbox/utils/features';
import { unescapeHTML } from 'soapbox/utils/html';
import { joinPublicPath } from 'soapbox/utils/static';
import api, { getLinks } from '../api';
import { getFilters, regexFromFilters } from '../selectors';
import { unescapeHTML } from '../utils/html';
import { fetchRelationships } from './accounts';
import {
importFetchedAccount,
@ -25,32 +23,36 @@ import {
import { saveMarker } from './markers';
import { getSettings, saveSettings } from './settings';
export const NOTIFICATIONS_UPDATE = 'NOTIFICATIONS_UPDATE';
export const NOTIFICATIONS_UPDATE_NOOP = 'NOTIFICATIONS_UPDATE_NOOP';
export const NOTIFICATIONS_UPDATE_QUEUE = 'NOTIFICATIONS_UPDATE_QUEUE';
export const NOTIFICATIONS_DEQUEUE = 'NOTIFICATIONS_DEQUEUE';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
export const NOTIFICATIONS_EXPAND_REQUEST = 'NOTIFICATIONS_EXPAND_REQUEST';
export const NOTIFICATIONS_EXPAND_SUCCESS = 'NOTIFICATIONS_EXPAND_SUCCESS';
export const NOTIFICATIONS_EXPAND_FAIL = 'NOTIFICATIONS_EXPAND_FAIL';
const NOTIFICATIONS_UPDATE = 'NOTIFICATIONS_UPDATE';
const NOTIFICATIONS_UPDATE_NOOP = 'NOTIFICATIONS_UPDATE_NOOP';
const NOTIFICATIONS_UPDATE_QUEUE = 'NOTIFICATIONS_UPDATE_QUEUE';
const NOTIFICATIONS_DEQUEUE = 'NOTIFICATIONS_DEQUEUE';
export const NOTIFICATIONS_FILTER_SET = 'NOTIFICATIONS_FILTER_SET';
const NOTIFICATIONS_EXPAND_REQUEST = 'NOTIFICATIONS_EXPAND_REQUEST';
const NOTIFICATIONS_EXPAND_SUCCESS = 'NOTIFICATIONS_EXPAND_SUCCESS';
const NOTIFICATIONS_EXPAND_FAIL = 'NOTIFICATIONS_EXPAND_FAIL';
export const NOTIFICATIONS_CLEAR = 'NOTIFICATIONS_CLEAR';
export const NOTIFICATIONS_SCROLL_TOP = 'NOTIFICATIONS_SCROLL_TOP';
const NOTIFICATIONS_FILTER_SET = 'NOTIFICATIONS_FILTER_SET';
export const NOTIFICATIONS_MARK_READ_REQUEST = 'NOTIFICATIONS_MARK_READ_REQUEST';
export const NOTIFICATIONS_MARK_READ_SUCCESS = 'NOTIFICATIONS_MARK_READ_SUCCESS';
export const NOTIFICATIONS_MARK_READ_FAIL = 'NOTIFICATIONS_MARK_READ_FAIL';
const NOTIFICATIONS_CLEAR = 'NOTIFICATIONS_CLEAR';
const NOTIFICATIONS_SCROLL_TOP = 'NOTIFICATIONS_SCROLL_TOP';
export const MAX_QUEUED_NOTIFICATIONS = 40;
const NOTIFICATIONS_MARK_READ_REQUEST = 'NOTIFICATIONS_MARK_READ_REQUEST';
const NOTIFICATIONS_MARK_READ_SUCCESS = 'NOTIFICATIONS_MARK_READ_SUCCESS';
const NOTIFICATIONS_MARK_READ_FAIL = 'NOTIFICATIONS_MARK_READ_FAIL';
const MAX_QUEUED_NOTIFICATIONS = 40;
defineMessages({
mention: { id: 'notification.mention', defaultMessage: '{name} mentioned you' },
group: { id: 'notifications.group', defaultMessage: '{count} notifications' },
});
const fetchRelatedRelationships = (dispatch, notifications) => {
const fetchRelatedRelationships = (dispatch: AppDispatch, notifications: APIEntity[]) => {
const accountIds = notifications.filter(item => item.type === 'follow').map(item => item.account.id);
if (accountIds.length > 0) {
@ -58,8 +60,8 @@ const fetchRelatedRelationships = (dispatch, notifications) => {
}
};
export function updateNotifications(notification, intlMessages, intlLocale) {
return (dispatch, getState) => {
const updateNotifications = (notification: APIEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const showInColumn = getSettings(getState()).getIn(['notifications', 'shows', notification.type], true);
if (notification.account) {
@ -84,17 +86,16 @@ export function updateNotifications(notification, intlMessages, intlLocale) {
fetchRelatedRelationships(dispatch, [notification]);
}
};
}
export function updateNotificationsQueue(notification, intlMessages, intlLocale, curPath) {
return (dispatch, getState) => {
const updateNotificationsQueue = (notification: APIEntity, intlMessages: Record<string, string>, intlLocale: string, curPath: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (notification.type === 'pleroma:chat_mention') return; // Drop chat notifications, handle them per-chat
const showAlert = getSettings(getState()).getIn(['notifications', 'alerts', notification.type]);
const filters = getFilters(getState(), { contextType: 'notifications' });
const playSound = getSettings(getState()).getIn(['notifications', 'sounds', notification.type]);
let filtered = false;
let filtered: boolean | null = false;
const isOnNotificationsPage = curPath === '/notifications';
@ -140,21 +141,20 @@ export function updateNotificationsQueue(notification, intlMessages, intlLocale,
intlLocale,
});
} else {
dispatch(updateNotifications(notification, intlMessages, intlLocale));
dispatch(updateNotifications(notification));
}
};
}
export function dequeueNotifications() {
return (dispatch, getState) => {
const queuedNotifications = getState().getIn(['notifications', 'queuedNotifications'], ImmutableOrderedMap());
const totalQueuedNotificationsCount = getState().getIn(['notifications', 'totalQueuedNotificationsCount'], 0);
const dequeueNotifications = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const queuedNotifications = getState().notifications.get('queuedNotifications');
const totalQueuedNotificationsCount = getState().notifications.get('totalQueuedNotificationsCount');
if (totalQueuedNotificationsCount === 0) {
return;
} else if (totalQueuedNotificationsCount > 0 && totalQueuedNotificationsCount <= MAX_QUEUED_NOTIFICATIONS) {
queuedNotifications.forEach(block => {
dispatch(updateNotifications(block.notification, block.intlMessages, block.intlLocale));
queuedNotifications.forEach((block: APIEntity) => {
dispatch(updateNotifications(block.notification));
});
} else {
dispatch(expandNotifications());
@ -165,23 +165,22 @@ export function dequeueNotifications() {
});
dispatch(markReadNotifications());
};
}
const excludeTypesFromSettings = getState => getSettings(getState()).getIn(['notifications', 'shows']).filter(enabled => !enabled).keySeq().toJS();
const excludeTypesFromSettings = (getState: () => RootState) => (getSettings(getState()).getIn(['notifications', 'shows']) as ImmutableMap<string, boolean>).filter(enabled => !enabled).keySeq().toJS();
const excludeTypesFromFilter = filter => {
const excludeTypesFromFilter = (filter: string) => {
const allTypes = ImmutableList(['follow', 'follow_request', 'favourite', 'reblog', 'mention', 'status', 'poll', 'move', 'pleroma:emoji_reaction']);
return allTypes.filterNot(item => item === filter).toJS();
};
const noOp = () => {};
export function expandNotifications({ maxId } = {}, done = noOp) {
return (dispatch, getState) => {
const expandNotifications = ({ maxId }: Record<string, any> = {}, done = noOp) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return dispatch(noOp);
const activeFilter = getSettings(getState()).getIn(['notifications', 'quickFilter', 'active']);
const notifications = getState().get('notifications');
const activeFilter = getSettings(getState()).getIn(['notifications', 'quickFilter', 'active']) as string;
const notifications = getState().notifications;
const isLoadingMore = !!maxId;
if (notifications.get('isLoading')) {
@ -189,7 +188,7 @@ export function expandNotifications({ maxId } = {}, done = noOp) {
return dispatch(noOp);
}
const params = {
const params: Record<string, any> = {
max_id: maxId,
exclude_types: activeFilter === 'all'
? excludeTypesFromSettings(getState)
@ -205,7 +204,7 @@ export function expandNotifications({ maxId } = {}, done = noOp) {
return api(getState).get('/api/v1/notifications', { params }).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
const entries = response.data.reduce((acc, item) => {
const entries = (response.data as APIEntity[]).reduce((acc, item) => {
if (item.account?.id) {
acc.accounts[item.account.id] = item.account;
}
@ -233,34 +232,27 @@ export function expandNotifications({ maxId } = {}, done = noOp) {
done();
});
};
}
export function expandNotificationsRequest(isLoadingMore) {
return {
type: NOTIFICATIONS_EXPAND_REQUEST,
skipLoading: !isLoadingMore,
};
}
const expandNotificationsRequest = (isLoadingMore: boolean) => ({
type: NOTIFICATIONS_EXPAND_REQUEST,
skipLoading: !isLoadingMore,
});
export function expandNotificationsSuccess(notifications, next, isLoadingMore) {
return {
type: NOTIFICATIONS_EXPAND_SUCCESS,
notifications,
next,
skipLoading: !isLoadingMore,
};
}
const expandNotificationsSuccess = (notifications: APIEntity[], next: string | null, isLoadingMore: boolean) => ({
type: NOTIFICATIONS_EXPAND_SUCCESS,
notifications,
next,
skipLoading: !isLoadingMore,
});
export function expandNotificationsFail(error, isLoadingMore) {
return {
type: NOTIFICATIONS_EXPAND_FAIL,
error,
skipLoading: !isLoadingMore,
};
}
const expandNotificationsFail = (error: AxiosError, isLoadingMore: boolean) => ({
type: NOTIFICATIONS_EXPAND_FAIL,
error,
skipLoading: !isLoadingMore,
});
export function clearNotifications() {
return (dispatch, getState) => {
const clearNotifications = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch({
@ -269,20 +261,18 @@ export function clearNotifications() {
api(getState).post('/api/v1/notifications/clear');
};
}
export function scrollTopNotifications(top) {
return (dispatch, getState) => {
const scrollTopNotifications = (top: boolean) =>
(dispatch: AppDispatch) => {
dispatch({
type: NOTIFICATIONS_SCROLL_TOP,
top,
});
dispatch(markReadNotifications());
};
}
export function setFilter(filterType) {
return dispatch => {
const setFilter = (filterType: string) =>
(dispatch: AppDispatch) => {
dispatch({
type: NOTIFICATIONS_FILTER_SET,
path: ['notifications', 'quickFilter', 'active'],
@ -291,25 +281,23 @@ export function setFilter(filterType) {
dispatch(expandNotifications());
dispatch(saveSettings());
};
}
// Of course Markers don't work properly in Pleroma.
// https://git.pleroma.social/pleroma/pleroma/-/issues/2769
export function markReadPleroma(max_id) {
return (dispatch, getState) => {
const markReadPleroma = (max_id: string | number) =>
(dispatch: AppDispatch, getState: () => RootState) => {
return api(getState).post('/api/v1/pleroma/notifications/read', { max_id });
};
}
export function markReadNotifications() {
return (dispatch, getState) => {
const markReadNotifications = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const state = getState();
const instance = state.get('instance');
const topNotificationId = state.getIn(['notifications', 'items'], ImmutableOrderedMap()).first(ImmutableMap()).get('id');
const lastReadId = state.getIn(['notifications', 'lastRead']);
const v = parseVersion(instance.get('version'));
const instance = state.instance;
const topNotificationId = state.notifications.get('items').first(ImmutableMap()).get('id');
const lastReadId = state.notifications.get('lastRead');
const v = parseVersion(instance.version);
if (!(topNotificationId && topNotificationId > lastReadId)) return;
@ -325,4 +313,32 @@ export function markReadNotifications() {
dispatch(markReadPleroma(topNotificationId));
}
};
}
export {
NOTIFICATIONS_UPDATE,
NOTIFICATIONS_UPDATE_NOOP,
NOTIFICATIONS_UPDATE_QUEUE,
NOTIFICATIONS_DEQUEUE,
NOTIFICATIONS_EXPAND_REQUEST,
NOTIFICATIONS_EXPAND_SUCCESS,
NOTIFICATIONS_EXPAND_FAIL,
NOTIFICATIONS_FILTER_SET,
NOTIFICATIONS_CLEAR,
NOTIFICATIONS_SCROLL_TOP,
NOTIFICATIONS_MARK_READ_REQUEST,
NOTIFICATIONS_MARK_READ_SUCCESS,
NOTIFICATIONS_MARK_READ_FAIL,
MAX_QUEUED_NOTIFICATIONS,
updateNotifications,
updateNotificationsQueue,
dequeueNotifications,
expandNotifications,
expandNotificationsRequest,
expandNotificationsSuccess,
expandNotificationsFail,
clearNotifications,
scrollTopNotifications,
setFilter,
markReadPleroma,
markReadNotifications,
};

62
app/soapbox/actions/patron.js
View File

@ -1,62 +0,0 @@
import api from '../api';
export const PATRON_INSTANCE_FETCH_REQUEST = 'PATRON_INSTANCE_FETCH_REQUEST';
export const PATRON_INSTANCE_FETCH_SUCCESS = 'PATRON_INSTANCE_FETCH_SUCCESS';
export const PATRON_INSTANCE_FETCH_FAIL = 'PATRON_INSTANCE_FETCH_FAIL';
export const PATRON_ACCOUNT_FETCH_REQUEST = 'PATRON_ACCOUNT_FETCH_REQUEST';
export const PATRON_ACCOUNT_FETCH_SUCCESS = 'PATRON_ACCOUNT_FETCH_SUCCESS';
export const PATRON_ACCOUNT_FETCH_FAIL = 'PATRON_ACCOUNT_FETCH_FAIL';
export function fetchPatronInstance() {
return (dispatch, getState) => {
dispatch({ type: PATRON_INSTANCE_FETCH_REQUEST });
api(getState).get('/api/patron/v1/instance').then(response => {
dispatch(importFetchedInstance(response.data));
}).catch(error => {
dispatch(fetchInstanceFail(error));
});
};
}
export function fetchPatronAccount(apId) {
return (dispatch, getState) => {
apId = encodeURIComponent(apId);
dispatch({ type: PATRON_ACCOUNT_FETCH_REQUEST });
api(getState).get(`/api/patron/v1/accounts/${apId}`).then(response => {
dispatch(importFetchedAccount(response.data));
}).catch(error => {
dispatch(fetchAccountFail(error));
});
};
}
function importFetchedInstance(instance) {
return {
type: PATRON_INSTANCE_FETCH_SUCCESS,
instance,
};
}
function fetchInstanceFail(error) {
return {
type: PATRON_INSTANCE_FETCH_FAIL,
error,
skipAlert: true,
};
}
function importFetchedAccount(account) {
return {
type: PATRON_ACCOUNT_FETCH_SUCCESS,
account,
};
}
function fetchAccountFail(error) {
return {
type: PATRON_ACCOUNT_FETCH_FAIL,
error,
skipAlert: true,
};
}

71
app/soapbox/actions/patron.ts Normal file
View File

@ -0,0 +1,71 @@
import api from '../api';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const PATRON_INSTANCE_FETCH_REQUEST = 'PATRON_INSTANCE_FETCH_REQUEST';
const PATRON_INSTANCE_FETCH_SUCCESS = 'PATRON_INSTANCE_FETCH_SUCCESS';
const PATRON_INSTANCE_FETCH_FAIL = 'PATRON_INSTANCE_FETCH_FAIL';
const PATRON_ACCOUNT_FETCH_REQUEST = 'PATRON_ACCOUNT_FETCH_REQUEST';
const PATRON_ACCOUNT_FETCH_SUCCESS = 'PATRON_ACCOUNT_FETCH_SUCCESS';
const PATRON_ACCOUNT_FETCH_FAIL = 'PATRON_ACCOUNT_FETCH_FAIL';
const fetchPatronInstance = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: PATRON_INSTANCE_FETCH_REQUEST });
return api(getState).get('/api/patron/v1/instance').then(response => {
dispatch(importFetchedInstance(response.data));
}).catch(error => {
dispatch(fetchInstanceFail(error));
});
};
const fetchPatronAccount = (apId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
apId = encodeURIComponent(apId);
dispatch({ type: PATRON_ACCOUNT_FETCH_REQUEST });
api(getState).get(`/api/patron/v1/accounts/${apId}`).then(response => {
dispatch(importFetchedAccount(response.data));
}).catch(error => {
dispatch(fetchAccountFail(error));
});
};
const importFetchedInstance = (instance: APIEntity) => ({
type: PATRON_INSTANCE_FETCH_SUCCESS,
instance,
});
const fetchInstanceFail = (error: AxiosError) => ({
type: PATRON_INSTANCE_FETCH_FAIL,
error,
skipAlert: true,
});
const importFetchedAccount = (account: APIEntity) => ({
type: PATRON_ACCOUNT_FETCH_SUCCESS,
account,
});
const fetchAccountFail = (error: AxiosError) => ({
type: PATRON_ACCOUNT_FETCH_FAIL,
error,
skipAlert: true,
});
export {
PATRON_INSTANCE_FETCH_REQUEST,
PATRON_INSTANCE_FETCH_SUCCESS,
PATRON_INSTANCE_FETCH_FAIL,
PATRON_ACCOUNT_FETCH_REQUEST,
PATRON_ACCOUNT_FETCH_SUCCESS,
PATRON_ACCOUNT_FETCH_FAIL,
fetchPatronInstance,
fetchPatronAccount,
importFetchedInstance,
fetchInstanceFail,
importFetchedAccount,
fetchAccountFail,
};

46
app/soapbox/actions/pin_statuses.js
View File

@ -1,46 +0,0 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import { importFetchedStatuses } from './importer';
export const PINNED_STATUSES_FETCH_REQUEST = 'PINNED_STATUSES_FETCH_REQUEST';
export const PINNED_STATUSES_FETCH_SUCCESS = 'PINNED_STATUSES_FETCH_SUCCESS';
export const PINNED_STATUSES_FETCH_FAIL = 'PINNED_STATUSES_FETCH_FAIL';
export function fetchPinnedStatuses() {
return (dispatch, getState) => {
if (!isLoggedIn(getState)) return;
const me = getState().get('me');
dispatch(fetchPinnedStatusesRequest());
api(getState).get(`/api/v1/accounts/${me}/statuses`, { params: { pinned: true } }).then(response => {
dispatch(importFetchedStatuses(response.data));
dispatch(fetchPinnedStatusesSuccess(response.data, null));
}).catch(error => {
dispatch(fetchPinnedStatusesFail(error));
});
};
}
export function fetchPinnedStatusesRequest() {
return {
type: PINNED_STATUSES_FETCH_REQUEST,
};
}
export function fetchPinnedStatusesSuccess(statuses, next) {
return {
type: PINNED_STATUSES_FETCH_SUCCESS,
statuses,
next,
};
}
export function fetchPinnedStatusesFail(error) {
return {
type: PINNED_STATUSES_FETCH_FAIL,
error,
};
}

53
app/soapbox/actions/pin_statuses.ts Normal file
View File

@ -0,0 +1,53 @@
import { isLoggedIn } from 'soapbox/utils/auth';
import api from '../api';
import { importFetchedStatuses } from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const PINNED_STATUSES_FETCH_REQUEST = 'PINNED_STATUSES_FETCH_REQUEST';
const PINNED_STATUSES_FETCH_SUCCESS = 'PINNED_STATUSES_FETCH_SUCCESS';
const PINNED_STATUSES_FETCH_FAIL = 'PINNED_STATUSES_FETCH_FAIL';
const fetchPinnedStatuses = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const me = getState().me;
dispatch(fetchPinnedStatusesRequest());
api(getState).get(`/api/v1/accounts/${me}/statuses`, { params: { pinned: true } }).then(response => {
dispatch(importFetchedStatuses(response.data));
dispatch(fetchPinnedStatusesSuccess(response.data, null));
}).catch(error => {
dispatch(fetchPinnedStatusesFail(error));
});
};
const fetchPinnedStatusesRequest = () => ({
type: PINNED_STATUSES_FETCH_REQUEST,
});
const fetchPinnedStatusesSuccess = (statuses: APIEntity[], next: string | null) => ({
type: PINNED_STATUSES_FETCH_SUCCESS,
statuses,
next,
});
const fetchPinnedStatusesFail = (error: AxiosError) => ({
type: PINNED_STATUSES_FETCH_FAIL,
error,
});
export {
PINNED_STATUSES_FETCH_REQUEST,
PINNED_STATUSES_FETCH_SUCCESS,
PINNED_STATUSES_FETCH_FAIL,
fetchPinnedStatuses,
fetchPinnedStatusesRequest,
fetchPinnedStatusesSuccess,
fetchPinnedStatusesFail,
};

61
app/soapbox/actions/polls.js
View File

@ -1,61 +0,0 @@
import api from '../api';
import { importFetchedPoll } from './importer';
export const POLL_VOTE_REQUEST = 'POLL_VOTE_REQUEST';
export const POLL_VOTE_SUCCESS = 'POLL_VOTE_SUCCESS';
export const POLL_VOTE_FAIL = 'POLL_VOTE_FAIL';
export const POLL_FETCH_REQUEST = 'POLL_FETCH_REQUEST';
export const POLL_FETCH_SUCCESS = 'POLL_FETCH_SUCCESS';
export const POLL_FETCH_FAIL = 'POLL_FETCH_FAIL';
export const vote = (pollId, choices) => (dispatch, getState) => {
dispatch(voteRequest());
api(getState).post(`/api/v1/polls/${pollId}/votes`, { choices })
.then(({ data }) => {
dispatch(importFetchedPoll(data));
dispatch(voteSuccess(data));
})
.catch(err => dispatch(voteFail(err)));
};
export const fetchPoll = pollId => (dispatch, getState) => {
dispatch(fetchPollRequest());
api(getState).get(`/api/v1/polls/${pollId}`)
.then(({ data }) => {
dispatch(importFetchedPoll(data));
dispatch(fetchPollSuccess(data));
})
.catch(err => dispatch(fetchPollFail(err)));
};
export const voteRequest = () => ({
type: POLL_VOTE_REQUEST,
});
export const voteSuccess = poll => ({
type: POLL_VOTE_SUCCESS,
poll,
});
export const voteFail = error => ({
type: POLL_VOTE_FAIL,
error,
});
export const fetchPollRequest = () => ({
type: POLL_FETCH_REQUEST,
});
export const fetchPollSuccess = poll => ({
type: POLL_FETCH_SUCCESS,
poll,
});
export const fetchPollFail = error => ({
type: POLL_FETCH_FAIL,
error,
});

84
app/soapbox/actions/polls.ts Normal file
View File

@ -0,0 +1,84 @@
import api from '../api';
import { importFetchedPoll } from './importer';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const POLL_VOTE_REQUEST = 'POLL_VOTE_REQUEST';
const POLL_VOTE_SUCCESS = 'POLL_VOTE_SUCCESS';
const POLL_VOTE_FAIL = 'POLL_VOTE_FAIL';
const POLL_FETCH_REQUEST = 'POLL_FETCH_REQUEST';
const POLL_FETCH_SUCCESS = 'POLL_FETCH_SUCCESS';
const POLL_FETCH_FAIL = 'POLL_FETCH_FAIL';
const vote = (pollId: string, choices: string[]) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(voteRequest());
api(getState).post(`/api/v1/polls/${pollId}/votes`, { choices })
.then(({ data }) => {
dispatch(importFetchedPoll(data));
dispatch(voteSuccess(data));
})
.catch(err => dispatch(voteFail(err)));
};
const fetchPoll = (pollId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(fetchPollRequest());
api(getState).get(`/api/v1/polls/${pollId}`)
.then(({ data }) => {
dispatch(importFetchedPoll(data));
dispatch(fetchPollSuccess(data));
})
.catch(err => dispatch(fetchPollFail(err)));
};
const voteRequest = () => ({
type: POLL_VOTE_REQUEST,
});
const voteSuccess = (poll: APIEntity) => ({
type: POLL_VOTE_SUCCESS,
poll,
});
const voteFail = (error: AxiosError) => ({
type: POLL_VOTE_FAIL,
error,
});
const fetchPollRequest = () => ({
type: POLL_FETCH_REQUEST,
});
const fetchPollSuccess = (poll: APIEntity) => ({
type: POLL_FETCH_SUCCESS,
poll,
});
const fetchPollFail = (error: AxiosError) => ({
type: POLL_FETCH_FAIL,
error,
});
export {
POLL_VOTE_REQUEST,
POLL_VOTE_SUCCESS,
POLL_VOTE_FAIL,
POLL_FETCH_REQUEST,
POLL_FETCH_SUCCESS,
POLL_FETCH_FAIL,
vote,
fetchPoll,
voteRequest,
voteSuccess,
voteFail,
fetchPollRequest,
fetchPollSuccess,
fetchPollFail,
};

51
app/soapbox/actions/preload.js → app/soapbox/actions/preload.ts
View File

@ -3,32 +3,34 @@ import mapValues from 'lodash/mapValues';
import { verifyCredentials } from './auth';
import { importFetchedAccounts } from './importer';
export const PLEROMA_PRELOAD_IMPORT = 'PLEROMA_PRELOAD_IMPORT';
export const MASTODON_PRELOAD_IMPORT = 'MASTODON_PRELOAD_IMPORT';
import type { AppDispatch } from 'soapbox/store';
const PLEROMA_PRELOAD_IMPORT = 'PLEROMA_PRELOAD_IMPORT';
const MASTODON_PRELOAD_IMPORT = 'MASTODON_PRELOAD_IMPORT';
// https://git.pleroma.social/pleroma/pleroma-fe/-/merge_requests/1176/diffs
const decodeUTF8Base64 = data => {
const decodeUTF8Base64 = (data: string) => {
const rawData = atob(data);
const array = Uint8Array.from(rawData.split('').map((char) => char.charCodeAt(0)));
const text = new TextDecoder().decode(array);
return text;
};
const decodePleromaData = data => {
const decodePleromaData = (data: Record<string, any>) => {
return mapValues(data, base64string => JSON.parse(decodeUTF8Base64(base64string)));
};
const pleromaDecoder = json => decodePleromaData(JSON.parse(json));
const pleromaDecoder = (json: string) => decodePleromaData(JSON.parse(json));
// This will throw if it fails.
// Should be called inside a try-catch.
const decodeFromMarkup = (elementId, decoder) => {
const { textContent } = document.getElementById(elementId);
return decoder(textContent);
const decodeFromMarkup = (elementId: string, decoder: (json: string) => Record<string, any>) => {
const { textContent } = document.getElementById(elementId)!;
return decoder(textContent as string);
};
function preloadFromMarkup(elementId, decoder, action) {
return (dispatch, getState) => {
const preloadFromMarkup = (elementId: string, decoder: (json: string) => Record<string, any>, action: (data: Record<string, any>) => any) =>
(dispatch: AppDispatch) => {
try {
const data = decodeFromMarkup(elementId, decoder);
dispatch(action(data));
@ -36,24 +38,20 @@ function preloadFromMarkup(elementId, decoder, action) {
// Do nothing
}
};
}
export function preload() {
return (dispatch, getState) => {
const preload = () =>
(dispatch: AppDispatch) => {
dispatch(preloadFromMarkup('initial-results', pleromaDecoder, preloadPleroma));
dispatch(preloadFromMarkup('initial-state', JSON.parse, preloadMastodon));
};
}
export function preloadPleroma(data) {
return {
type: PLEROMA_PRELOAD_IMPORT,
data,
};
}
const preloadPleroma = (data: Record<string, any>) => ({
type: PLEROMA_PRELOAD_IMPORT,
data,
});
export function preloadMastodon(data) {
return (dispatch, getState) => {
const preloadMastodon = (data: Record<string, any>) =>
(dispatch: AppDispatch) => {
const { me, access_token } = data.meta;
const { url } = data.accounts[me];
@ -61,4 +59,11 @@ export function preloadMastodon(data) {
dispatch(verifyCredentials(access_token, url));
dispatch({ type: MASTODON_PRELOAD_IMPORT, data });
};
}
export {
PLEROMA_PRELOAD_IMPORT,
MASTODON_PRELOAD_IMPORT,
preload,
preloadPleroma,
preloadMastodon,
};

24
app/soapbox/actions/profile_hover_card.js
View File

@ -1,24 +0,0 @@
export const PROFILE_HOVER_CARD_OPEN = 'PROFILE_HOVER_CARD_OPEN';
export const PROFILE_HOVER_CARD_UPDATE = 'PROFILE_HOVER_CARD_UPDATE';
export const PROFILE_HOVER_CARD_CLOSE = 'PROFILE_HOVER_CARD_CLOSE';
export function openProfileHoverCard(ref, accountId) {
return {
type: PROFILE_HOVER_CARD_OPEN,
ref,
accountId,
};
}
export function updateProfileHoverCard() {
return {
type: PROFILE_HOVER_CARD_UPDATE,
};
}
export function closeProfileHoverCard(force = false) {
return {
type: PROFILE_HOVER_CARD_CLOSE,
force,
};
}

27
app/soapbox/actions/profile_hover_card.ts Normal file
View File

@ -0,0 +1,27 @@
const PROFILE_HOVER_CARD_OPEN = 'PROFILE_HOVER_CARD_OPEN';
const PROFILE_HOVER_CARD_UPDATE = 'PROFILE_HOVER_CARD_UPDATE';
const PROFILE_HOVER_CARD_CLOSE = 'PROFILE_HOVER_CARD_CLOSE';
const openProfileHoverCard = (ref: React.MutableRefObject<HTMLDivElement>, accountId: string) => ({
type: PROFILE_HOVER_CARD_OPEN,
ref,
accountId,
});
const updateProfileHoverCard = () => ({
type: PROFILE_HOVER_CARD_UPDATE,
});
const closeProfileHoverCard = (force = false) => ({
type: PROFILE_HOVER_CARD_CLOSE,
force,
});
export {
PROFILE_HOVER_CARD_OPEN,
PROFILE_HOVER_CARD_UPDATE,
PROFILE_HOVER_CARD_CLOSE,
openProfileHoverCard,
updateProfileHoverCard,
closeProfileHoverCard,
};

10
app/soapbox/actions/push_notifications/index.js → app/soapbox/actions/push_notifications/index.ts
View File

@ -7,17 +7,19 @@ import {
setAlerts,
} from './setter';
import type { AppDispatch } from 'soapbox/store';
export {
SET_BROWSER_SUPPORT,
SET_SUBSCRIPTION,
CLEAR_SUBSCRIPTION,
SET_ALERTS,
register,
changeAlerts,
};
export function changeAlerts(path, value) {
return dispatch => {
const changeAlerts = (path: Array<string>, value: any) =>
(dispatch: AppDispatch) => {
dispatch(setAlerts(path, value));
dispatch(saveSettings());
dispatch(saveSettings() as any);
};
}

70
app/soapbox/actions/push_notifications/registerer.js → app/soapbox/actions/push_notifications/registerer.ts
View File

@ -1,12 +1,15 @@
import { createPushSubsription, updatePushSubscription } from 'soapbox/actions/push_subscriptions';
import { createPushSubscription, updatePushSubscription } from 'soapbox/actions/push_subscriptions';
import { pushNotificationsSetting } from 'soapbox/settings';
import { getVapidKey } from 'soapbox/utils/auth';
import { decode as decodeBase64 } from 'soapbox/utils/base64';
import { setBrowserSupport, setSubscription, clearSubscription } from './setter';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { Me } from 'soapbox/types/soapbox';
// Taken from https://www.npmjs.com/package/web-push
const urlBase64ToUint8Array = (base64String) => {
const urlBase64ToUint8Array = (base64String: string) => {
const padding = '='.repeat((4 - base64String.length % 4) % 4);
const base64 = (base64String + padding)
.replace(/\-/g, '+')
@ -17,22 +20,25 @@ const urlBase64ToUint8Array = (base64String) => {
const getRegistration = () => navigator.serviceWorker.ready;
const getPushSubscription = (registration) =>
const getPushSubscription = (registration: ServiceWorkerRegistration) =>
registration.pushManager.getSubscription()
.then(subscription => ({ registration, subscription }));
const subscribe = (registration, getState) =>
const subscribe = (registration: ServiceWorkerRegistration, getState: () => RootState) =>
registration.pushManager.subscribe({
userVisibleOnly: true,
applicationServerKey: urlBase64ToUint8Array(getVapidKey(getState())),
});
const unsubscribe = ({ registration, subscription }) =>
subscription ? subscription.unsubscribe().then(() => registration) : registration;
const unsubscribe = ({ registration, subscription }: {
registration: ServiceWorkerRegistration,
subscription: PushSubscription | null,
}) =>
subscription ? subscription.unsubscribe().then(() => registration) : new Promise<ServiceWorkerRegistration>(r => r(registration));
const sendSubscriptionToBackend = (subscription, me) => {
return (dispatch, getState) => {
const alerts = getState().getIn(['push_notifications', 'alerts']).toJS();
const sendSubscriptionToBackend = (subscription: PushSubscription, me: Me) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const alerts = getState().push_notifications.get('alerts').toJS();
const params = { subscription, data: { alerts } };
if (me) {
@ -42,16 +48,15 @@ const sendSubscriptionToBackend = (subscription, me) => {
}
}
return dispatch(createPushSubsription(params));
return dispatch(createPushSubscription(params) as any);
};
};
// Last one checks for payload support: https://web-push-book.gauntface.com/chapter-06/01-non-standards-browsers/#no-payload
const supportsPushNotifications = ('serviceWorker' in navigator && 'PushManager' in window && 'getKey' in PushSubscription.prototype);
export function register() {
return (dispatch, getState) => {
const me = getState().get('me');
const register = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const me = getState().me;
const vapidKey = getVapidKey(getState());
dispatch(setBrowserSupport(supportsPushNotifications));
@ -68,35 +73,39 @@ export function register() {
getRegistration()
.then(getPushSubscription)
.then(({ registration, subscription }) => {
// @ts-ignore
.then(({ registration, subscription }: {
registration: ServiceWorkerRegistration,
subscription: PushSubscription | null,
}) => {
if (subscription !== null) {
// We have a subscription, check if it is still valid
const currentServerKey = (new Uint8Array(subscription.options.applicationServerKey)).toString();
const currentServerKey = (new Uint8Array(subscription.options.applicationServerKey!)).toString();
const subscriptionServerKey = urlBase64ToUint8Array(vapidKey).toString();
const serverEndpoint = getState().getIn(['push_notifications', 'subscription', 'endpoint']);
const serverEndpoint = getState().push_notifications.getIn(['subscription', 'endpoint']);
// If the VAPID public key did not change and the endpoint corresponds
// to the endpoint saved in the backend, the subscription is valid
if (subscriptionServerKey === currentServerKey && subscription.endpoint === serverEndpoint) {
return subscription;
return { subscription };
} else {
// Something went wrong, try to subscribe again
return unsubscribe({ registration, subscription }).then(registration => {
return unsubscribe({ registration, subscription }).then((registration: ServiceWorkerRegistration) => {
return subscribe(registration, getState);
}).then(
subscription => dispatch(sendSubscriptionToBackend(subscription, me)));
(subscription: PushSubscription) => dispatch(sendSubscriptionToBackend(subscription, me) as any));
}
}
// No subscription, try to subscribe
return subscribe(registration, getState)
.then(subscription => dispatch(sendSubscriptionToBackend(subscription, me)));
.then(subscription => dispatch(sendSubscriptionToBackend(subscription, me) as any));
})
.then(subscription => {
.then(({ subscription }: { subscription: PushSubscription | Record<string, any> }) => {
// If we got a PushSubscription (and not a subscription object from the backend)
// it means that the backend subscription is valid (and was set during hydration)
if (!(subscription instanceof PushSubscription)) {
dispatch(setSubscription(subscription));
dispatch(setSubscription(subscription as PushSubscription));
if (me) {
pushNotificationsSetting.set(me, { alerts: subscription.alerts });
}
@ -123,14 +132,13 @@ export function register() {
})
.catch(console.warn);
};
}
export function saveSettings() {
return (dispatch, getState) => {
const state = getState().get('push_notifications');
const saveSettings = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState().push_notifications;
const alerts = state.get('alerts');
const data = { alerts };
const me = getState().get('me');
const me = getState().me;
return dispatch(updatePushSubscription({ data })).then(() => {
if (me) {
@ -138,4 +146,8 @@ export function saveSettings() {
}
}).catch(console.warn);
};
}
export {
register,
saveSettings,
};

34
app/soapbox/actions/push_notifications/setter.js
View File

@ -1,34 +0,0 @@
export const SET_BROWSER_SUPPORT = 'PUSH_NOTIFICATIONS_SET_BROWSER_SUPPORT';
export const SET_SUBSCRIPTION = 'PUSH_NOTIFICATIONS_SET_SUBSCRIPTION';
export const CLEAR_SUBSCRIPTION = 'PUSH_NOTIFICATIONS_CLEAR_SUBSCRIPTION';
export const SET_ALERTS = 'PUSH_NOTIFICATIONS_SET_ALERTS';
export function setBrowserSupport(value) {
return {
type: SET_BROWSER_SUPPORT,
value,
};
}
export function setSubscription(subscription) {
return {
type: SET_SUBSCRIPTION,
subscription,
};
}
export function clearSubscription() {
return {
type: CLEAR_SUBSCRIPTION,
};
}
export function setAlerts(path, value) {
return dispatch => {
dispatch({
type: SET_ALERTS,
path,
value,
});
};
}

39
app/soapbox/actions/push_notifications/setter.ts Normal file
View File

@ -0,0 +1,39 @@
import type { AnyAction } from 'redux';
const SET_BROWSER_SUPPORT = 'PUSH_NOTIFICATIONS_SET_BROWSER_SUPPORT';
const SET_SUBSCRIPTION = 'PUSH_NOTIFICATIONS_SET_SUBSCRIPTION';
const CLEAR_SUBSCRIPTION = 'PUSH_NOTIFICATIONS_CLEAR_SUBSCRIPTION';
const SET_ALERTS = 'PUSH_NOTIFICATIONS_SET_ALERTS';
const setBrowserSupport = (value: boolean) => ({
type: SET_BROWSER_SUPPORT,
value,
});
const setSubscription = (subscription: PushSubscription) => ({
type: SET_SUBSCRIPTION,
subscription,
});
const clearSubscription = () => ({
type: CLEAR_SUBSCRIPTION,
});
const setAlerts = (path: Array<string>, value: any) =>
(dispatch: React.Dispatch<AnyAction>) =>
dispatch({
type: SET_ALERTS,
path,
value,
});
export {
SET_BROWSER_SUPPORT,
SET_SUBSCRIPTION,
CLEAR_SUBSCRIPTION,
SET_ALERTS,
setBrowserSupport,
setSubscription,
clearSubscription,
setAlerts,
};

62
app/soapbox/actions/push_subscriptions.js
View File

@ -1,62 +0,0 @@
import api from '../api';
export const PUSH_SUBSCRIPTION_CREATE_REQUEST = 'PUSH_SUBSCRIPTION_CREATE_REQUEST';
export const PUSH_SUBSCRIPTION_CREATE_SUCCESS = 'PUSH_SUBSCRIPTION_CREATE_SUCCESS';
export const PUSH_SUBSCRIPTION_CREATE_FAIL = 'PUSH_SUBSCRIPTION_CREATE_FAIL';
export const PUSH_SUBSCRIPTION_FETCH_REQUEST = 'PUSH_SUBSCRIPTION_FETCH_REQUEST';
export const PUSH_SUBSCRIPTION_FETCH_SUCCESS = 'PUSH_SUBSCRIPTION_FETCH_SUCCESS';
export const PUSH_SUBSCRIPTION_FETCH_FAIL = 'PUSH_SUBSCRIPTION_FETCH_FAIL';
export const PUSH_SUBSCRIPTION_UPDATE_REQUEST = 'PUSH_SUBSCRIPTION_UPDATE_REQUEST';
export const PUSH_SUBSCRIPTION_UPDATE_SUCCESS = 'PUSH_SUBSCRIPTION_UPDATE_SUCCESS';
export const PUSH_SUBSCRIPTION_UPDATE_FAIL = 'PUSH_SUBSCRIPTION_UPDATE_FAIL';
export const PUSH_SUBSCRIPTION_DELETE_REQUEST = 'PUSH_SUBSCRIPTION_DELETE_REQUEST';
export const PUSH_SUBSCRIPTION_DELETE_SUCCESS = 'PUSH_SUBSCRIPTION_DELETE_SUCCESS';
export const PUSH_SUBSCRIPTION_DELETE_FAIL = 'PUSH_SUBSCRIPTION_DELETE_FAIL';
export function createPushSubsription(params) {
return (dispatch, getState) => {
dispatch({ type: PUSH_SUBSCRIPTION_CREATE_REQUEST, params });
return api(getState).post('/api/v1/push/subscription', params).then(({ data: subscription }) => {
dispatch({ type: PUSH_SUBSCRIPTION_CREATE_SUCCESS, params, subscription });
return subscription;
}).catch(error => {
dispatch({ type: PUSH_SUBSCRIPTION_CREATE_FAIL, params, error });
});
};
}
export function fetchPushSubsription() {
return (dispatch, getState) => {
dispatch({ type: PUSH_SUBSCRIPTION_FETCH_REQUEST });
return api(getState).get('/api/v1/push/subscription').then(({ data: subscription }) => {
dispatch({ type: PUSH_SUBSCRIPTION_FETCH_SUCCESS, subscription });
}).catch(error => {
dispatch({ type: PUSH_SUBSCRIPTION_FETCH_FAIL, error });
});
};
}
export function updatePushSubscription(params) {
return (dispatch, getState) => {
dispatch({ type: PUSH_SUBSCRIPTION_UPDATE_REQUEST, params });
return api(getState).put('/api/v1/push/subscription', params).then(({ data: subscription }) => {
dispatch({ type: PUSH_SUBSCRIPTION_UPDATE_SUCCESS, params, subscription });
}).catch(error => {
dispatch({ type: PUSH_SUBSCRIPTION_UPDATE_FAIL, params, error });
});
};
}
export function deletePushSubsription() {
return (dispatch, getState) => {
dispatch({ type: PUSH_SUBSCRIPTION_DELETE_REQUEST });
return api(getState).delete('/api/v1/push/subscription').then(() => {
dispatch({ type: PUSH_SUBSCRIPTION_DELETE_SUCCESS });
}).catch(error => {
dispatch({ type: PUSH_SUBSCRIPTION_DELETE_FAIL, error });
});
};
}

78
app/soapbox/actions/push_subscriptions.ts Normal file
View File

@ -0,0 +1,78 @@
import api from '../api';
const PUSH_SUBSCRIPTION_CREATE_REQUEST = 'PUSH_SUBSCRIPTION_CREATE_REQUEST';
const PUSH_SUBSCRIPTION_CREATE_SUCCESS = 'PUSH_SUBSCRIPTION_CREATE_SUCCESS';
const PUSH_SUBSCRIPTION_CREATE_FAIL = 'PUSH_SUBSCRIPTION_CREATE_FAIL';
const PUSH_SUBSCRIPTION_FETCH_REQUEST = 'PUSH_SUBSCRIPTION_FETCH_REQUEST';
const PUSH_SUBSCRIPTION_FETCH_SUCCESS = 'PUSH_SUBSCRIPTION_FETCH_SUCCESS';
const PUSH_SUBSCRIPTION_FETCH_FAIL = 'PUSH_SUBSCRIPTION_FETCH_FAIL';
const PUSH_SUBSCRIPTION_UPDATE_REQUEST = 'PUSH_SUBSCRIPTION_UPDATE_REQUEST';
const PUSH_SUBSCRIPTION_UPDATE_SUCCESS = 'PUSH_SUBSCRIPTION_UPDATE_SUCCESS';
const PUSH_SUBSCRIPTION_UPDATE_FAIL = 'PUSH_SUBSCRIPTION_UPDATE_FAIL';
const PUSH_SUBSCRIPTION_DELETE_REQUEST = 'PUSH_SUBSCRIPTION_DELETE_REQUEST';
const PUSH_SUBSCRIPTION_DELETE_SUCCESS = 'PUSH_SUBSCRIPTION_DELETE_SUCCESS';
const PUSH_SUBSCRIPTION_DELETE_FAIL = 'PUSH_SUBSCRIPTION_DELETE_FAIL';
import type { AppDispatch, RootState } from 'soapbox/store';
const createPushSubscription = (params: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: PUSH_SUBSCRIPTION_CREATE_REQUEST, params });
return api(getState).post('/api/v1/push/subscription', params).then(({ data: subscription }) =>
dispatch({ type: PUSH_SUBSCRIPTION_CREATE_SUCCESS, params, subscription }),
).catch(error =>
dispatch({ type: PUSH_SUBSCRIPTION_CREATE_FAIL, params, error }),
);
};
const fetchPushSubscription = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: PUSH_SUBSCRIPTION_FETCH_REQUEST });
return api(getState).get('/api/v1/push/subscription').then(({ data: subscription }) =>
dispatch({ type: PUSH_SUBSCRIPTION_FETCH_SUCCESS, subscription }),
).catch(error =>
dispatch({ type: PUSH_SUBSCRIPTION_FETCH_FAIL, error }),
);
};
const updatePushSubscription = (params: Record<string, any>) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: PUSH_SUBSCRIPTION_UPDATE_REQUEST, params });
return api(getState).put('/api/v1/push/subscription', params).then(({ data: subscription }) =>
dispatch({ type: PUSH_SUBSCRIPTION_UPDATE_SUCCESS, params, subscription }),
).catch(error =>
dispatch({ type: PUSH_SUBSCRIPTION_UPDATE_FAIL, params, error }),
);
};
const deletePushSubscription = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: PUSH_SUBSCRIPTION_DELETE_REQUEST });
return api(getState).delete('/api/v1/push/subscription').then(() =>
dispatch({ type: PUSH_SUBSCRIPTION_DELETE_SUCCESS }),
).catch(error =>
dispatch({ type: PUSH_SUBSCRIPTION_DELETE_FAIL, error }),
);
};
export {
PUSH_SUBSCRIPTION_CREATE_REQUEST,
PUSH_SUBSCRIPTION_CREATE_SUCCESS,
PUSH_SUBSCRIPTION_CREATE_FAIL,
PUSH_SUBSCRIPTION_FETCH_REQUEST,
PUSH_SUBSCRIPTION_FETCH_SUCCESS,
PUSH_SUBSCRIPTION_FETCH_FAIL,
PUSH_SUBSCRIPTION_UPDATE_REQUEST,
PUSH_SUBSCRIPTION_UPDATE_SUCCESS,
PUSH_SUBSCRIPTION_UPDATE_FAIL,
PUSH_SUBSCRIPTION_DELETE_REQUEST,
PUSH_SUBSCRIPTION_DELETE_SUCCESS,
PUSH_SUBSCRIPTION_DELETE_FAIL,
createPushSubscription,
fetchPushSubscription,
updatePushSubscription,
deletePushSubscription,
};

24
app/soapbox/actions/remote_timeline.js
View File

@ -1,24 +0,0 @@
import { getSettings, changeSetting } from 'soapbox/actions/settings';
const getPinnedHosts = state => {
const settings = getSettings(state);
return settings.getIn(['remote_timeline', 'pinnedHosts']);
};
export function pinHost(host) {
return (dispatch, getState) => {
const state = getState();
const pinnedHosts = getPinnedHosts(state);
return dispatch(changeSetting(['remote_timeline', 'pinnedHosts'], pinnedHosts.push(host)));
};
}
export function unpinHost(host) {
return (dispatch, getState) => {
const state = getState();
const pinnedHosts = getPinnedHosts(state);
return dispatch(changeSetting(['remote_timeline', 'pinnedHosts'], pinnedHosts.filter((value) => value !== host)));
};
}

30
app/soapbox/actions/remote_timeline.ts Normal file
View File

@ -0,0 +1,30 @@
import { getSettings, changeSetting } from 'soapbox/actions/settings';
import type { OrderedSet as ImmutableOrderedSet } from 'immutable';
import type { AppDispatch, RootState } from 'soapbox/store';
const getPinnedHosts = (state: RootState) => {
const settings = getSettings(state);
return settings.getIn(['remote_timeline', 'pinnedHosts']) as ImmutableOrderedSet<string>;
};
const pinHost = (host: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const pinnedHosts = getPinnedHosts(state);
return dispatch(changeSetting(['remote_timeline', 'pinnedHosts'], pinnedHosts.add(host)));
};
const unpinHost = (host: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const pinnedHosts = getPinnedHosts(state);
return dispatch(changeSetting(['remote_timeline', 'pinnedHosts'], pinnedHosts.remove(host)));
};
export {
pinHost,
unpinHost,
};

116
app/soapbox/actions/reports.js
View File

@ -1,116 +0,0 @@
import api from '../api';
import { openModal } from './modals';
export const REPORT_INIT = 'REPORT_INIT';
export const REPORT_CANCEL = 'REPORT_CANCEL';
export const REPORT_SUBMIT_REQUEST = 'REPORT_SUBMIT_REQUEST';
export const REPORT_SUBMIT_SUCCESS = 'REPORT_SUBMIT_SUCCESS';
export const REPORT_SUBMIT_FAIL = 'REPORT_SUBMIT_FAIL';
export const REPORT_STATUS_TOGGLE = 'REPORT_STATUS_TOGGLE';
export const REPORT_COMMENT_CHANGE = 'REPORT_COMMENT_CHANGE';
export const REPORT_FORWARD_CHANGE = 'REPORT_FORWARD_CHANGE';
export const REPORT_BLOCK_CHANGE = 'REPORT_BLOCK_CHANGE';
export const REPORT_RULE_CHANGE = 'REPORT_RULE_CHANGE';
export function initReport(account, status) {
return dispatch => {
dispatch({
type: REPORT_INIT,
account,
status,
});
dispatch(openModal('REPORT'));
};
}
export function initReportById(accountId) {
return (dispatch, getState) => {
dispatch({
type: REPORT_INIT,
account: getState().getIn(['accounts', accountId]),
});
dispatch(openModal('REPORT'));
};
}
export function cancelReport() {
return {
type: REPORT_CANCEL,
};
}
export function toggleStatusReport(statusId, checked) {
return {
type: REPORT_STATUS_TOGGLE,
statusId,
checked,
};
}
export function submitReport() {
return (dispatch, getState) => {
dispatch(submitReportRequest());
const { reports } = getState();
return api(getState).post('/api/v1/reports', {
account_id: reports.getIn(['new', 'account_id']),
status_ids: reports.getIn(['new', 'status_ids']),
rule_ids: reports.getIn(['new', 'rule_ids']),
comment: reports.getIn(['new', 'comment']),
forward: reports.getIn(['new', 'forward']),
});
};
}
export function submitReportRequest() {
return {
type: REPORT_SUBMIT_REQUEST,
};
}
export function submitReportSuccess() {
return {
type: REPORT_SUBMIT_SUCCESS,
};
}
export function submitReportFail(error) {
return {
type: REPORT_SUBMIT_FAIL,
error,
};
}
export function changeReportComment(comment) {
return {
type: REPORT_COMMENT_CHANGE,
comment,
};
}
export function changeReportForward(forward) {
return {
type: REPORT_FORWARD_CHANGE,
forward,
};
}
export function changeReportBlock(block) {
return {
type: REPORT_BLOCK_CHANGE,
block,
};
}
export function changeReportRule(ruleId) {
return {
type: REPORT_RULE_CHANGE,
rule_id: ruleId,
};
}

124
app/soapbox/actions/reports.ts Normal file
View File

@ -0,0 +1,124 @@
import api from '../api';
import { openModal } from './modals';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { Account, Status } from 'soapbox/types/entities';
const REPORT_INIT = 'REPORT_INIT';
const REPORT_CANCEL = 'REPORT_CANCEL';
const REPORT_SUBMIT_REQUEST = 'REPORT_SUBMIT_REQUEST';
const REPORT_SUBMIT_SUCCESS = 'REPORT_SUBMIT_SUCCESS';
const REPORT_SUBMIT_FAIL = 'REPORT_SUBMIT_FAIL';
const REPORT_STATUS_TOGGLE = 'REPORT_STATUS_TOGGLE';
const REPORT_COMMENT_CHANGE = 'REPORT_COMMENT_CHANGE';
const REPORT_FORWARD_CHANGE = 'REPORT_FORWARD_CHANGE';
const REPORT_BLOCK_CHANGE = 'REPORT_BLOCK_CHANGE';
const REPORT_RULE_CHANGE = 'REPORT_RULE_CHANGE';
const initReport = (account: Account, status: Status) =>
(dispatch: AppDispatch) => {
dispatch({
type: REPORT_INIT,
account,
status,
});
return dispatch(openModal('REPORT'));
};
const initReportById = (accountId: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({
type: REPORT_INIT,
account: getState().accounts.get(accountId),
});
dispatch(openModal('REPORT'));
};
const cancelReport = () => ({
type: REPORT_CANCEL,
});
const toggleStatusReport = (statusId: string, checked: boolean) => ({
type: REPORT_STATUS_TOGGLE,
statusId,
checked,
});
const submitReport = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch(submitReportRequest());
const { reports } = getState();
return api(getState).post('/api/v1/reports', {
account_id: reports.getIn(['new', 'account_id']),
status_ids: reports.getIn(['new', 'status_ids']),
rule_ids: reports.getIn(['new', 'rule_ids']),
comment: reports.getIn(['new', 'comment']),
forward: reports.getIn(['new', 'forward']),
});
};
const submitReportRequest = () => ({
type: REPORT_SUBMIT_REQUEST,
});
const submitReportSuccess = () => ({
type: REPORT_SUBMIT_SUCCESS,
});
const submitReportFail = (error: AxiosError) => ({
type: REPORT_SUBMIT_FAIL,
error,
});
const changeReportComment = (comment: string) => ({
type: REPORT_COMMENT_CHANGE,
comment,
});
const changeReportForward = (forward: boolean) => ({
type: REPORT_FORWARD_CHANGE,
forward,
});
const changeReportBlock = (block: boolean) => ({
type: REPORT_BLOCK_CHANGE,
block,
});
const changeReportRule = (ruleId: string) => ({
type: REPORT_RULE_CHANGE,
rule_id: ruleId,
});
export {
REPORT_INIT,
REPORT_CANCEL,
REPORT_SUBMIT_REQUEST,
REPORT_SUBMIT_SUCCESS,
REPORT_SUBMIT_FAIL,
REPORT_STATUS_TOGGLE,
REPORT_COMMENT_CHANGE,
REPORT_FORWARD_CHANGE,
REPORT_BLOCK_CHANGE,
REPORT_RULE_CHANGE,
initReport,
initReportById,
cancelReport,
toggleStatusReport,
submitReport,
submitReportRequest,
submitReportSuccess,
submitReportFail,
changeReportComment,
changeReportForward,
changeReportBlock,
changeReportRule,
};

3
app/soapbox/actions/rules.ts
View File

@ -1,6 +1,7 @@
import api from '../api';
import type { Rule } from 'soapbox/reducers/rules';
import type { RootState } from 'soapbox/store';
const RULES_FETCH_REQUEST = 'RULES_FETCH_REQUEST';
const RULES_FETCH_SUCCESS = 'RULES_FETCH_SUCCESS';
@ -16,7 +17,7 @@ type RulesFetchRequestSuccessAction = {
export type RulesActions = RulesFetchRequestAction | RulesFetchRequestSuccessAction
const fetchRules = () => (dispatch: React.Dispatch<RulesActions>, getState: any) => {
const fetchRules = () => (dispatch: React.Dispatch<RulesActions>, getState: () => RootState) => {
dispatch({ type: RULES_FETCH_REQUEST });
return api(getState)

102
app/soapbox/actions/scheduled_statuses.js
View File

@ -1,102 +0,0 @@
import api, { getLinks } from '../api';
export const SCHEDULED_STATUSES_FETCH_REQUEST = 'SCHEDULED_STATUSES_FETCH_REQUEST';
export const SCHEDULED_STATUSES_FETCH_SUCCESS = 'SCHEDULED_STATUSES_FETCH_SUCCESS';
export const SCHEDULED_STATUSES_FETCH_FAIL = 'SCHEDULED_STATUSES_FETCH_FAIL';
export const SCHEDULED_STATUSES_EXPAND_REQUEST = 'SCHEDULED_STATUSES_EXPAND_REQUEST';
export const SCHEDULED_STATUSES_EXPAND_SUCCESS = 'SCHEDULED_STATUSES_EXPAND_SUCCESS';
export const SCHEDULED_STATUSES_EXPAND_FAIL = 'SCHEDULED_STATUSES_EXPAND_FAIL';
export const SCHEDULED_STATUS_CANCEL_REQUEST = 'SCHEDULED_STATUS_CANCEL_REQUEST';
export const SCHEDULED_STATUS_CANCEL_SUCCESS = 'SCHEDULED_STATUS_CANCEL_SUCCESS';
export const SCHEDULED_STATUS_CANCEL_FAIL = 'SCHEDULED_STATUS_CANCEL_FAIL';
export function fetchScheduledStatuses() {
return (dispatch, getState) => {
if (getState().getIn(['status_lists', 'scheduled_statuses', 'isLoading'])) {
return;
}
dispatch(fetchScheduledStatusesRequest());
api(getState).get('/api/v1/scheduled_statuses').then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(fetchScheduledStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(fetchScheduledStatusesFail(error));
});
};
}
export function cancelScheduledStatus(id) {
return (dispatch, getState) => {
dispatch({ type: SCHEDULED_STATUS_CANCEL_REQUEST, id });
api(getState).delete(`/api/v1/scheduled_statuses/${id}`).then(({ data }) => {
dispatch({ type: SCHEDULED_STATUS_CANCEL_SUCCESS, id, data });
}).catch(error => {
dispatch({ type: SCHEDULED_STATUS_CANCEL_FAIL, id, error });
});
};
}
export function fetchScheduledStatusesRequest() {
return {
type: SCHEDULED_STATUSES_FETCH_REQUEST,
};
}
export function fetchScheduledStatusesSuccess(statuses, next) {
return {
type: SCHEDULED_STATUSES_FETCH_SUCCESS,
statuses,
next,
};
}
export function fetchScheduledStatusesFail(error) {
return {
type: SCHEDULED_STATUSES_FETCH_FAIL,
error,
};
}
export function expandScheduledStatuses() {
return (dispatch, getState) => {
const url = getState().getIn(['status_lists', 'scheduled_statuses', 'next'], null);
if (url === null || getState().getIn(['status_lists', 'scheduled_statuses', 'isLoading'])) {
return;
}
dispatch(expandScheduledStatusesRequest());
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(expandScheduledStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(expandScheduledStatusesFail(error));
});
};
}
export function expandScheduledStatusesRequest() {
return {
type: SCHEDULED_STATUSES_EXPAND_REQUEST,
};
}
export function expandScheduledStatusesSuccess(statuses, next) {
return {
type: SCHEDULED_STATUSES_EXPAND_SUCCESS,
statuses,
next,
};
}
export function expandScheduledStatusesFail(error) {
return {
type: SCHEDULED_STATUSES_EXPAND_FAIL,
error,
};
}

112
app/soapbox/actions/scheduled_statuses.ts Normal file
View File

@ -0,0 +1,112 @@
import api, { getLinks } from '../api';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const SCHEDULED_STATUSES_FETCH_REQUEST = 'SCHEDULED_STATUSES_FETCH_REQUEST';
const SCHEDULED_STATUSES_FETCH_SUCCESS = 'SCHEDULED_STATUSES_FETCH_SUCCESS';
const SCHEDULED_STATUSES_FETCH_FAIL = 'SCHEDULED_STATUSES_FETCH_FAIL';
const SCHEDULED_STATUSES_EXPAND_REQUEST = 'SCHEDULED_STATUSES_EXPAND_REQUEST';
const SCHEDULED_STATUSES_EXPAND_SUCCESS = 'SCHEDULED_STATUSES_EXPAND_SUCCESS';
const SCHEDULED_STATUSES_EXPAND_FAIL = 'SCHEDULED_STATUSES_EXPAND_FAIL';
const SCHEDULED_STATUS_CANCEL_REQUEST = 'SCHEDULED_STATUS_CANCEL_REQUEST';
const SCHEDULED_STATUS_CANCEL_SUCCESS = 'SCHEDULED_STATUS_CANCEL_SUCCESS';
const SCHEDULED_STATUS_CANCEL_FAIL = 'SCHEDULED_STATUS_CANCEL_FAIL';
const fetchScheduledStatuses = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (getState().status_lists.get('scheduled_statuses')?.isLoading) {
return;
}
dispatch(fetchScheduledStatusesRequest());
api(getState).get('/api/v1/scheduled_statuses').then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(fetchScheduledStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(fetchScheduledStatusesFail(error));
});
};
const cancelScheduledStatus = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: SCHEDULED_STATUS_CANCEL_REQUEST, id });
api(getState).delete(`/api/v1/scheduled_statuses/${id}`).then(({ data }) => {
dispatch({ type: SCHEDULED_STATUS_CANCEL_SUCCESS, id, data });
}).catch(error => {
dispatch({ type: SCHEDULED_STATUS_CANCEL_FAIL, id, error });
});
};
const fetchScheduledStatusesRequest = () => ({
type: SCHEDULED_STATUSES_FETCH_REQUEST,
});
const fetchScheduledStatusesSuccess = (statuses: APIEntity[], next: string | null) => ({
type: SCHEDULED_STATUSES_FETCH_SUCCESS,
statuses,
next,
});
const fetchScheduledStatusesFail = (error: AxiosError) => ({
type: SCHEDULED_STATUSES_FETCH_FAIL,
error,
});
const expandScheduledStatuses = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const url = getState().status_lists.get('scheduled_statuses')?.next || null;
if (url === null || getState().status_lists.get('scheduled_statuses')?.isLoading) {
return;
}
dispatch(expandScheduledStatusesRequest());
api(getState).get(url).then(response => {
const next = getLinks(response).refs.find(link => link.rel === 'next');
dispatch(expandScheduledStatusesSuccess(response.data, next ? next.uri : null));
}).catch(error => {
dispatch(expandScheduledStatusesFail(error));
});
};
const expandScheduledStatusesRequest = () => ({
type: SCHEDULED_STATUSES_EXPAND_REQUEST,
});
const expandScheduledStatusesSuccess = (statuses: APIEntity[], next: string | null) => ({
type: SCHEDULED_STATUSES_EXPAND_SUCCESS,
statuses,
next,
});
const expandScheduledStatusesFail = (error: AxiosError) => ({
type: SCHEDULED_STATUSES_EXPAND_FAIL,
error,
});
export {
SCHEDULED_STATUSES_FETCH_REQUEST,
SCHEDULED_STATUSES_FETCH_SUCCESS,
SCHEDULED_STATUSES_FETCH_FAIL,
SCHEDULED_STATUSES_EXPAND_REQUEST,
SCHEDULED_STATUSES_EXPAND_SUCCESS,
SCHEDULED_STATUSES_EXPAND_FAIL,
SCHEDULED_STATUS_CANCEL_REQUEST,
SCHEDULED_STATUS_CANCEL_SUCCESS,
SCHEDULED_STATUS_CANCEL_FAIL,
fetchScheduledStatuses,
cancelScheduledStatus,
fetchScheduledStatusesRequest,
fetchScheduledStatusesSuccess,
fetchScheduledStatusesFail,
expandScheduledStatuses,
expandScheduledStatusesRequest,
expandScheduledStatusesSuccess,
expandScheduledStatusesFail,
};

158
app/soapbox/actions/search.js
View File

@ -1,158 +0,0 @@
import api from '../api';
import { fetchRelationships } from './accounts';
import { importFetchedAccounts, importFetchedStatuses } from './importer';
export const SEARCH_CHANGE = 'SEARCH_CHANGE';
export const SEARCH_CLEAR = 'SEARCH_CLEAR';
export const SEARCH_SHOW = 'SEARCH_SHOW';
export const SEARCH_FETCH_REQUEST = 'SEARCH_FETCH_REQUEST';
export const SEARCH_FETCH_SUCCESS = 'SEARCH_FETCH_SUCCESS';
export const SEARCH_FETCH_FAIL = 'SEARCH_FETCH_FAIL';
export const SEARCH_FILTER_SET = 'SEARCH_FILTER_SET';
export const SEARCH_EXPAND_REQUEST = 'SEARCH_EXPAND_REQUEST';
export const SEARCH_EXPAND_SUCCESS = 'SEARCH_EXPAND_SUCCESS';
export const SEARCH_EXPAND_FAIL = 'SEARCH_EXPAND_FAIL';
export function changeSearch(value) {
return (dispatch, getState) => {
// If backspaced all the way, clear the search
if (value.length === 0) {
return dispatch(clearSearch());
} else {
return dispatch({
type: SEARCH_CHANGE,
value,
});
}
};
}
export function clearSearch() {
return {
type: SEARCH_CLEAR,
};
}
export function submitSearch(filter) {
return (dispatch, getState) => {
const value = getState().getIn(['search', 'value']);
const type = filter || getState().getIn(['search', 'filter'], 'accounts');
// An empty search doesn't return any results
if (value.length === 0) {
return;
}
dispatch(fetchSearchRequest(value));
api(getState).get('/api/v2/search', {
params: {
q: value,
resolve: true,
limit: 20,
type,
},
}).then(response => {
if (response.data.accounts) {
dispatch(importFetchedAccounts(response.data.accounts));
}
if (response.data.statuses) {
dispatch(importFetchedStatuses(response.data.statuses));
}
dispatch(fetchSearchSuccess(response.data, value, type));
dispatch(fetchRelationships(response.data.accounts.map(item => item.id)));
}).catch(error => {
dispatch(fetchSearchFail(error));
});
};
}
export function fetchSearchRequest(value) {
return {
type: SEARCH_FETCH_REQUEST,
value,
};
}
export function fetchSearchSuccess(results, searchTerm, searchType) {
return {
type: SEARCH_FETCH_SUCCESS,
results,
searchTerm,
searchType,
};
}
export function fetchSearchFail(error) {
return {
type: SEARCH_FETCH_FAIL,
error,
};
}
export function setFilter(filterType) {
return (dispatch) => {
dispatch(submitSearch(filterType));
dispatch({
type: SEARCH_FILTER_SET,
path: ['search', 'filter'],
value: filterType,
});
};
}
export const expandSearch = type => (dispatch, getState) => {
const value = getState().getIn(['search', 'value']);
const offset = getState().getIn(['search', 'results', type]).size;
dispatch(expandSearchRequest(type));
api(getState).get('/api/v2/search', {
params: {
q: value,
type,
offset,
},
}).then(({ data }) => {
if (data.accounts) {
dispatch(importFetchedAccounts(data.accounts));
}
if (data.statuses) {
dispatch(importFetchedStatuses(data.statuses));
}
dispatch(expandSearchSuccess(data, value, type));
dispatch(fetchRelationships(data.accounts.map(item => item.id)));
}).catch(error => {
dispatch(expandSearchFail(error));
});
};
export const expandSearchRequest = (searchType) => ({
type: SEARCH_EXPAND_REQUEST,
searchType,
});
export const expandSearchSuccess = (results, searchTerm, searchType) => ({
type: SEARCH_EXPAND_SUCCESS,
results,
searchTerm,
searchType,
});
export const expandSearchFail = error => ({
type: SEARCH_EXPAND_FAIL,
error,
});
export const showSearch = () => ({
type: SEARCH_SHOW,
});

177
app/soapbox/actions/search.ts Normal file
View File

@ -0,0 +1,177 @@
import api from '../api';
import { fetchRelationships } from './accounts';
import { importFetchedAccounts, importFetchedStatuses } from './importer';
import type { AxiosError } from 'axios';
import type { SearchFilter } from 'soapbox/reducers/search';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const SEARCH_CHANGE = 'SEARCH_CHANGE';
const SEARCH_CLEAR = 'SEARCH_CLEAR';
const SEARCH_SHOW = 'SEARCH_SHOW';
const SEARCH_FETCH_REQUEST = 'SEARCH_FETCH_REQUEST';
const SEARCH_FETCH_SUCCESS = 'SEARCH_FETCH_SUCCESS';
const SEARCH_FETCH_FAIL = 'SEARCH_FETCH_FAIL';
const SEARCH_FILTER_SET = 'SEARCH_FILTER_SET';
const SEARCH_EXPAND_REQUEST = 'SEARCH_EXPAND_REQUEST';
const SEARCH_EXPAND_SUCCESS = 'SEARCH_EXPAND_SUCCESS';
const SEARCH_EXPAND_FAIL = 'SEARCH_EXPAND_FAIL';
const changeSearch = (value: string) =>
(dispatch: AppDispatch) => {
// If backspaced all the way, clear the search
if (value.length === 0) {
return dispatch(clearSearch());
} else {
return dispatch({
type: SEARCH_CHANGE,
value,
});
}
};
const clearSearch = () => ({
type: SEARCH_CLEAR,
});
const submitSearch = (filter?: SearchFilter) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const value = getState().search.value;
const type = filter || getState().search.filter || 'accounts';
// An empty search doesn't return any results
if (value.length === 0) {
return;
}
dispatch(fetchSearchRequest(value));
api(getState).get('/api/v2/search', {
params: {
q: value,
resolve: true,
limit: 20,
type,
},
}).then(response => {
if (response.data.accounts) {
dispatch(importFetchedAccounts(response.data.accounts));
}
if (response.data.statuses) {
dispatch(importFetchedStatuses(response.data.statuses));
}
dispatch(fetchSearchSuccess(response.data, value, type));
dispatch(fetchRelationships(response.data.accounts.map((item: APIEntity) => item.id)));
}).catch(error => {
dispatch(fetchSearchFail(error));
});
};
const fetchSearchRequest = (value: string) => ({
type: SEARCH_FETCH_REQUEST,
value,
});
const fetchSearchSuccess = (results: APIEntity[], searchTerm: string, searchType: SearchFilter) => ({
type: SEARCH_FETCH_SUCCESS,
results,
searchTerm,
searchType,
});
const fetchSearchFail = (error: AxiosError) => ({
type: SEARCH_FETCH_FAIL,
error,
});
const setFilter = (filterType: SearchFilter) =>
(dispatch: AppDispatch) => {
dispatch(submitSearch(filterType));
dispatch({
type: SEARCH_FILTER_SET,
path: ['search', 'filter'],
value: filterType,
});
};
const expandSearch = (type: SearchFilter) => (dispatch: AppDispatch, getState: () => RootState) => {
const value = getState().search.value;
const offset = getState().search.results[type].size;
dispatch(expandSearchRequest(type));
api(getState).get('/api/v2/search', {
params: {
q: value,
type,
offset,
},
}).then(({ data }) => {
if (data.accounts) {
dispatch(importFetchedAccounts(data.accounts));
}
if (data.statuses) {
dispatch(importFetchedStatuses(data.statuses));
}
dispatch(expandSearchSuccess(data, value, type));
dispatch(fetchRelationships(data.accounts.map((item: APIEntity) => item.id)));
}).catch(error => {
dispatch(expandSearchFail(error));
});
};
const expandSearchRequest = (searchType: SearchFilter) => ({
type: SEARCH_EXPAND_REQUEST,
searchType,
});
const expandSearchSuccess = (results: APIEntity[], searchTerm: string, searchType: SearchFilter) => ({
type: SEARCH_EXPAND_SUCCESS,
results,
searchTerm,
searchType,
});
const expandSearchFail = (error: AxiosError) => ({
type: SEARCH_EXPAND_FAIL,
error,
});
const showSearch = () => ({
type: SEARCH_SHOW,
});
export {
SEARCH_CHANGE,
SEARCH_CLEAR,
SEARCH_SHOW,
SEARCH_FETCH_REQUEST,
SEARCH_FETCH_SUCCESS,
SEARCH_FETCH_FAIL,
SEARCH_FILTER_SET,
SEARCH_EXPAND_REQUEST,
SEARCH_EXPAND_SUCCESS,
SEARCH_EXPAND_FAIL,
changeSearch,
clearSearch,
submitSearch,
fetchSearchRequest,
fetchSearchSuccess,
fetchSearchFail,
setFilter,
expandSearch,
expandSearchRequest,
expandSearchSuccess,
expandSearchFail,
showSearch,
};

140
app/soapbox/actions/security.js → app/soapbox/actions/security.ts
View File

@ -12,62 +12,62 @@ import api from '../api';
import { AUTH_LOGGED_OUT, messages } from './auth';
export const FETCH_TOKENS_REQUEST = 'FETCH_TOKENS_REQUEST';
export const FETCH_TOKENS_SUCCESS = 'FETCH_TOKENS_SUCCESS';
export const FETCH_TOKENS_FAIL = 'FETCH_TOKENS_FAIL';
import type { AppDispatch, RootState } from 'soapbox/store';
export const REVOKE_TOKEN_REQUEST = 'REVOKE_TOKEN_REQUEST';
export const REVOKE_TOKEN_SUCCESS = 'REVOKE_TOKEN_SUCCESS';
export const REVOKE_TOKEN_FAIL = 'REVOKE_TOKEN_FAIL';
const FETCH_TOKENS_REQUEST = 'FETCH_TOKENS_REQUEST';
const FETCH_TOKENS_SUCCESS = 'FETCH_TOKENS_SUCCESS';
const FETCH_TOKENS_FAIL = 'FETCH_TOKENS_FAIL';
export const RESET_PASSWORD_REQUEST = 'RESET_PASSWORD_REQUEST';
export const RESET_PASSWORD_SUCCESS = 'RESET_PASSWORD_SUCCESS';
export const RESET_PASSWORD_FAIL = 'RESET_PASSWORD_FAIL';
const REVOKE_TOKEN_REQUEST = 'REVOKE_TOKEN_REQUEST';
const REVOKE_TOKEN_SUCCESS = 'REVOKE_TOKEN_SUCCESS';
const REVOKE_TOKEN_FAIL = 'REVOKE_TOKEN_FAIL';
export const RESET_PASSWORD_CONFIRM_REQUEST = 'RESET_PASSWORD_CONFIRM_REQUEST';
export const RESET_PASSWORD_CONFIRM_SUCCESS = 'RESET_PASSWORD_CONFIRM_SUCCESS';
export const RESET_PASSWORD_CONFIRM_FAIL = 'RESET_PASSWORD_CONFIRM_FAIL';
const RESET_PASSWORD_REQUEST = 'RESET_PASSWORD_REQUEST';
const RESET_PASSWORD_SUCCESS = 'RESET_PASSWORD_SUCCESS';
const RESET_PASSWORD_FAIL = 'RESET_PASSWORD_FAIL';
export const CHANGE_PASSWORD_REQUEST = 'CHANGE_PASSWORD_REQUEST';
export const CHANGE_PASSWORD_SUCCESS = 'CHANGE_PASSWORD_SUCCESS';
export const CHANGE_PASSWORD_FAIL = 'CHANGE_PASSWORD_FAIL';
const RESET_PASSWORD_CONFIRM_REQUEST = 'RESET_PASSWORD_CONFIRM_REQUEST';
const RESET_PASSWORD_CONFIRM_SUCCESS = 'RESET_PASSWORD_CONFIRM_SUCCESS';
const RESET_PASSWORD_CONFIRM_FAIL = 'RESET_PASSWORD_CONFIRM_FAIL';
export const CHANGE_EMAIL_REQUEST = 'CHANGE_EMAIL_REQUEST';
export const CHANGE_EMAIL_SUCCESS = 'CHANGE_EMAIL_SUCCESS';
export const CHANGE_EMAIL_FAIL = 'CHANGE_EMAIL_FAIL';
const CHANGE_PASSWORD_REQUEST = 'CHANGE_PASSWORD_REQUEST';
const CHANGE_PASSWORD_SUCCESS = 'CHANGE_PASSWORD_SUCCESS';
const CHANGE_PASSWORD_FAIL = 'CHANGE_PASSWORD_FAIL';
export const DELETE_ACCOUNT_REQUEST = 'DELETE_ACCOUNT_REQUEST';
export const DELETE_ACCOUNT_SUCCESS = 'DELETE_ACCOUNT_SUCCESS';
export const DELETE_ACCOUNT_FAIL = 'DELETE_ACCOUNT_FAIL';
const CHANGE_EMAIL_REQUEST = 'CHANGE_EMAIL_REQUEST';
const CHANGE_EMAIL_SUCCESS = 'CHANGE_EMAIL_SUCCESS';
const CHANGE_EMAIL_FAIL = 'CHANGE_EMAIL_FAIL';
export const MOVE_ACCOUNT_REQUEST = 'MOVE_ACCOUNT_REQUEST';
export const MOVE_ACCOUNT_SUCCESS = 'MOVE_ACCOUNT_SUCCESS';
export const MOVE_ACCOUNT_FAIL = 'MOVE_ACCOUNT_FAIL';
const DELETE_ACCOUNT_REQUEST = 'DELETE_ACCOUNT_REQUEST';
const DELETE_ACCOUNT_SUCCESS = 'DELETE_ACCOUNT_SUCCESS';
const DELETE_ACCOUNT_FAIL = 'DELETE_ACCOUNT_FAIL';
export function fetchOAuthTokens() {
return (dispatch, getState) => {
const MOVE_ACCOUNT_REQUEST = 'MOVE_ACCOUNT_REQUEST';
const MOVE_ACCOUNT_SUCCESS = 'MOVE_ACCOUNT_SUCCESS';
const MOVE_ACCOUNT_FAIL = 'MOVE_ACCOUNT_FAIL';
const fetchOAuthTokens = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: FETCH_TOKENS_REQUEST });
return api(getState).get('/api/oauth_tokens.json').then(({ data: tokens }) => {
dispatch({ type: FETCH_TOKENS_SUCCESS, tokens });
}).catch(error => {
}).catch(() => {
dispatch({ type: FETCH_TOKENS_FAIL });
});
};
}
export function revokeOAuthTokenById(id) {
return (dispatch, getState) => {
const revokeOAuthTokenById = (id: number) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: REVOKE_TOKEN_REQUEST, id });
return api(getState).delete(`/api/oauth_tokens/${id}`).then(() => {
dispatch({ type: REVOKE_TOKEN_SUCCESS, id });
}).catch(error => {
}).catch(() => {
dispatch({ type: REVOKE_TOKEN_FAIL, id });
});
};
}
export function changePassword(oldPassword, newPassword, confirmation) {
return (dispatch, getState) => {
const changePassword = (oldPassword: string, newPassword: string, confirmation: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: CHANGE_PASSWORD_REQUEST });
return api(getState).post('/api/pleroma/change_password', {
password: oldPassword,
@ -81,10 +81,9 @@ export function changePassword(oldPassword, newPassword, confirmation) {
throw error;
});
};
}
export function resetPassword(usernameOrEmail) {
return (dispatch, getState) => {
const resetPassword = (usernameOrEmail: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const state = getState();
const v = parseVersion(state.instance.version);
@ -107,10 +106,9 @@ export function resetPassword(usernameOrEmail) {
throw error;
});
};
}
export function resetPasswordConfirm(password, token) {
return (dispatch, getState) => {
const resetPasswordConfirm = (password: string, token: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const params = { password, reset_password_token: token };
dispatch({ type: RESET_PASSWORD_CONFIRM_REQUEST });
@ -121,10 +119,9 @@ export function resetPasswordConfirm(password, token) {
throw error;
});
};
}
export function changeEmail(email, password) {
return (dispatch, getState) => {
const changeEmail = (email: string, password: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: CHANGE_EMAIL_REQUEST, email });
return api(getState).post('/api/pleroma/change_email', {
email,
@ -137,16 +134,13 @@ export function changeEmail(email, password) {
throw error;
});
};
}
export function confirmChangedEmail(token) {
return (_dispatch, getState) => {
return api(getState).get(`/api/v1/truth/email/confirm?confirmation_token=${token}`);
};
}
const confirmChangedEmail = (token: string) =>
(_dispatch: AppDispatch, getState: () => RootState) =>
api(getState).get(`/api/v1/truth/email/confirm?confirmation_token=${token}`);
export function deleteAccount(intl, password) {
return (dispatch, getState) => {
const deleteAccount = (password: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const account = getLoggedInAccount(getState());
dispatch({ type: DELETE_ACCOUNT_REQUEST });
@ -156,16 +150,15 @@ export function deleteAccount(intl, password) {
if (response.data.error) throw response.data.error; // This endpoint returns HTTP 200 even on failure
dispatch({ type: DELETE_ACCOUNT_SUCCESS, response });
dispatch({ type: AUTH_LOGGED_OUT, account });
dispatch(snackbar.success(intl.formatMessage(messages.loggedOut)));
dispatch(snackbar.success(messages.loggedOut));
}).catch(error => {
dispatch({ type: DELETE_ACCOUNT_FAIL, error, skipAlert: true });
throw error;
});
};
}
export function moveAccount(targetAccount, password) {
return (dispatch, getState) => {
const moveAccount = (targetAccount: string, password: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: MOVE_ACCOUNT_REQUEST });
return api(getState).post('/api/pleroma/move_account', {
password,
@ -178,4 +171,39 @@ export function moveAccount(targetAccount, password) {
throw error;
});
};
}
export {
FETCH_TOKENS_REQUEST,
FETCH_TOKENS_SUCCESS,
FETCH_TOKENS_FAIL,
REVOKE_TOKEN_REQUEST,
REVOKE_TOKEN_SUCCESS,
REVOKE_TOKEN_FAIL,
RESET_PASSWORD_REQUEST,
RESET_PASSWORD_SUCCESS,
RESET_PASSWORD_FAIL,
RESET_PASSWORD_CONFIRM_REQUEST,
RESET_PASSWORD_CONFIRM_SUCCESS,
RESET_PASSWORD_CONFIRM_FAIL,
CHANGE_PASSWORD_REQUEST,
CHANGE_PASSWORD_SUCCESS,
CHANGE_PASSWORD_FAIL,
CHANGE_EMAIL_REQUEST,
CHANGE_EMAIL_SUCCESS,
CHANGE_EMAIL_FAIL,
DELETE_ACCOUNT_REQUEST,
DELETE_ACCOUNT_SUCCESS,
DELETE_ACCOUNT_FAIL,
MOVE_ACCOUNT_REQUEST,
MOVE_ACCOUNT_SUCCESS,
MOVE_ACCOUNT_FAIL,
fetchOAuthTokens,
revokeOAuthTokenById,
changePassword,
resetPassword,
resetPasswordConfirm,
changeEmail,
confirmChangedEmail,
deleteAccount,
moveAccount,
};

61
app/soapbox/actions/settings.js → app/soapbox/actions/settings.ts
View File

@ -9,17 +9,19 @@ import { isLoggedIn } from 'soapbox/utils/auth';
import { showAlertForError } from './alerts';
import snackbar from './snackbar';
export const SETTING_CHANGE = 'SETTING_CHANGE';
export const SETTING_SAVE = 'SETTING_SAVE';
export const SETTINGS_UPDATE = 'SETTINGS_UPDATE';
import type { AppDispatch, RootState } from 'soapbox/store';
export const FE_NAME = 'soapbox_fe';
const SETTING_CHANGE = 'SETTING_CHANGE';
const SETTING_SAVE = 'SETTING_SAVE';
const SETTINGS_UPDATE = 'SETTINGS_UPDATE';
const FE_NAME = 'soapbox_fe';
const messages = defineMessages({
saveSuccess: { id: 'settings.save.success', defaultMessage: 'Your preferences have been saved!' },
});
export const defaultSettings = ImmutableMap({
const defaultSettings = ImmutableMap({
onboarded: false,
skinTone: 1,
reduceMotion: false,
@ -166,17 +168,17 @@ export const defaultSettings = ImmutableMap({
}),
});
export const getSettings = createSelector([
state => state.getIn(['soapbox', 'defaultSettings']),
state => state.get('settings'),
const getSettings = createSelector([
(state: RootState) => state.soapbox.get('defaultSettings'),
(state: RootState) => state.settings,
], (soapboxSettings, settings) => {
return defaultSettings
.mergeDeep(soapboxSettings)
.mergeDeep(settings);
});
export function changeSettingImmediate(path, value) {
return dispatch => {
const changeSettingImmediate = (path: string[], value: any) =>
(dispatch: AppDispatch) => {
dispatch({
type: SETTING_CHANGE,
path,
@ -185,45 +187,52 @@ export function changeSettingImmediate(path, value) {
dispatch(saveSettingsImmediate());
};
}
export function changeSetting(path, value, intl) {
return dispatch => {
const changeSetting = (path: string[], value: any) =>
(dispatch: AppDispatch) => {
dispatch({
type: SETTING_CHANGE,
path,
value,
});
return dispatch(saveSettings(intl));
return dispatch(saveSettings());
};
}
export function saveSettingsImmediate(intl) {
return (dispatch, getState) => {
const saveSettingsImmediate = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
const state = getState();
if (getSettings(state).getIn(['saved'])) return;
const data = state.get('settings').delete('saved').toJS();
const data = state.settings.delete('saved').toJS();
dispatch(patchMe({
pleroma_settings_store: {
[FE_NAME]: data,
},
})).then(response => {
})).then(() => {
dispatch({ type: SETTING_SAVE });
if (intl) {
dispatch(snackbar.success(intl.formatMessage(messages.saveSuccess)));
}
dispatch(snackbar.success(messages.saveSuccess));
}).catch(error => {
dispatch(showAlertForError(error));
});
};
}
export function saveSettings(intl) {
return (dispatch, getState) => dispatch(saveSettingsImmediate(intl));
}
const saveSettings = () =>
(dispatch: AppDispatch) => dispatch(saveSettingsImmediate());
export {
SETTING_CHANGE,
SETTING_SAVE,
SETTINGS_UPDATE,
FE_NAME,
defaultSettings,
getSettings,
changeSettingImmediate,
changeSetting,
saveSettingsImmediate,
saveSettings,
};

14
app/soapbox/actions/sidebar.js
View File

@ -1,14 +0,0 @@
export const SIDEBAR_OPEN = 'SIDEBAR_OPEN';
export const SIDEBAR_CLOSE = 'SIDEBAR_CLOSE';
export function openSidebar() {
return {
type: SIDEBAR_OPEN,
};
}
export function closeSidebar() {
return {
type: SIDEBAR_CLOSE,
};
}

17
app/soapbox/actions/sidebar.ts Normal file
View File

@ -0,0 +1,17 @@
const SIDEBAR_OPEN = 'SIDEBAR_OPEN';
const SIDEBAR_CLOSE = 'SIDEBAR_CLOSE';
const openSidebar = () => ({
type: SIDEBAR_OPEN,
});
const closeSidebar = () => ({
type: SIDEBAR_CLOSE,
});
export {
SIDEBAR_OPEN,
SIDEBAR_CLOSE,
openSidebar,
closeSidebar,
};

10
app/soapbox/actions/snackbar.ts
View File

@ -9,12 +9,12 @@ type SnackbarMessage = string | MessageDescriptor
export type SnackbarAction = {
type: typeof ALERT_SHOW
message: SnackbarMessage
actionLabel?: string
actionLabel?: SnackbarMessage
actionLink?: string
severity: SnackbarActionSeverity
}
export const show = (severity: SnackbarActionSeverity, message: SnackbarMessage, actionLabel?: string, actionLink?: string): SnackbarAction => ({
export const show = (severity: SnackbarActionSeverity, message: SnackbarMessage, actionLabel?: SnackbarMessage, actionLink?: string): SnackbarAction => ({
type: ALERT_SHOW,
message,
actionLabel,
@ -22,13 +22,13 @@ export const show = (severity: SnackbarActionSeverity, message: SnackbarMessage,
severity,
});
export const info = (message: SnackbarMessage, actionLabel?: string, actionLink?: string) =>
export const info = (message: SnackbarMessage, actionLabel?: SnackbarMessage, actionLink?: string) =>
show('info', message, actionLabel, actionLink);
export const success = (message: SnackbarMessage, actionLabel?: string, actionLink?: string) =>
export const success = (message: SnackbarMessage, actionLabel?: SnackbarMessage, actionLink?: string) =>
show('success', message, actionLabel, actionLink);
export const error = (message: SnackbarMessage, actionLabel?: string, actionLink?: string) =>
export const error = (message: SnackbarMessage, actionLabel?: SnackbarMessage, actionLink?: string) =>
show('error', message, actionLabel, actionLink);
export default {

95
app/soapbox/actions/soapbox.js → app/soapbox/actions/soapbox.ts
View File

@ -8,16 +8,20 @@ import { getFeatures } from 'soapbox/utils/features';
import api, { staticClient } from '../api';
export const SOAPBOX_CONFIG_REQUEST_SUCCESS = 'SOAPBOX_CONFIG_REQUEST_SUCCESS';
export const SOAPBOX_CONFIG_REQUEST_FAIL = 'SOAPBOX_CONFIG_REQUEST_FAIL';
import type { AxiosError } from 'axios';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
export const SOAPBOX_CONFIG_REMEMBER_REQUEST = 'SOAPBOX_CONFIG_REMEMBER_REQUEST';
export const SOAPBOX_CONFIG_REMEMBER_SUCCESS = 'SOAPBOX_CONFIG_REMEMBER_SUCCESS';
export const SOAPBOX_CONFIG_REMEMBER_FAIL = 'SOAPBOX_CONFIG_REMEMBER_FAIL';
const SOAPBOX_CONFIG_REQUEST_SUCCESS = 'SOAPBOX_CONFIG_REQUEST_SUCCESS';
const SOAPBOX_CONFIG_REQUEST_FAIL = 'SOAPBOX_CONFIG_REQUEST_FAIL';
export const getSoapboxConfig = createSelector([
state => state.soapbox,
state => getFeatures(state.instance),
const SOAPBOX_CONFIG_REMEMBER_REQUEST = 'SOAPBOX_CONFIG_REMEMBER_REQUEST';
const SOAPBOX_CONFIG_REMEMBER_SUCCESS = 'SOAPBOX_CONFIG_REMEMBER_SUCCESS';
const SOAPBOX_CONFIG_REMEMBER_FAIL = 'SOAPBOX_CONFIG_REMEMBER_FAIL';
const getSoapboxConfig = createSelector([
(state: RootState) => state.soapbox,
(state: RootState) => getFeatures(state.instance),
], (soapbox, features) => {
// Do some additional normalization with the state
return normalizeSoapboxConfig(soapbox).withMutations(soapboxConfig => {
@ -35,8 +39,8 @@ export const getSoapboxConfig = createSelector([
});
});
export function rememberSoapboxConfig(host) {
return (dispatch, getState) => {
const rememberSoapboxConfig = (host: string | null) =>
(dispatch: AppDispatch) => {
dispatch({ type: SOAPBOX_CONFIG_REMEMBER_REQUEST, host });
return KVStore.getItemOrError(`soapbox_config:${host}`).then(soapboxConfig => {
dispatch({ type: SOAPBOX_CONFIG_REMEMBER_SUCCESS, host, soapboxConfig });
@ -45,19 +49,16 @@ export function rememberSoapboxConfig(host) {
dispatch({ type: SOAPBOX_CONFIG_REMEMBER_FAIL, host, error, skipAlert: true });
});
};
}
export function fetchFrontendConfigurations() {
return (dispatch, getState) => {
return api(getState)
const fetchFrontendConfigurations = () =>
(dispatch: AppDispatch, getState: () => RootState) =>
api(getState)
.get('/api/pleroma/frontend_configurations')
.then(({ data }) => data);
};
}
/** Conditionally fetches Soapbox config depending on backend features */
export function fetchSoapboxConfig(host) {
return (dispatch, getState) => {
const fetchSoapboxConfig = (host: string | null) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const features = getFeatures(getState().instance);
if (features.frontendConfigurations) {
@ -73,32 +74,28 @@ export function fetchSoapboxConfig(host) {
return dispatch(fetchSoapboxJson(host));
}
};
}
/** Tries to remember the config from browser storage before fetching it */
export function loadSoapboxConfig() {
return (dispatch, getState) => {
const loadSoapboxConfig = () =>
(dispatch: AppDispatch, getState: () => RootState) => {
const host = getHost(getState());
return dispatch(rememberSoapboxConfig(host)).then(() => {
return dispatch(fetchSoapboxConfig(host));
});
return dispatch(rememberSoapboxConfig(host)).then(() =>
dispatch(fetchSoapboxConfig(host)),
);
};
}
export function fetchSoapboxJson(host) {
return (dispatch, getState) => {
return staticClient.get('/instance/soapbox.json').then(({ data }) => {
const fetchSoapboxJson = (host: string | null) =>
(dispatch: AppDispatch) =>
staticClient.get('/instance/soapbox.json').then(({ data }) => {
if (!isObject(data)) throw 'soapbox.json failed';
dispatch(importSoapboxConfig(data, host));
return data;
}).catch(error => {
dispatch(soapboxConfigFail(error, host));
});
};
}
export function importSoapboxConfig(soapboxConfig, host) {
const importSoapboxConfig = (soapboxConfig: APIEntity, host: string | null) => {
if (!soapboxConfig.brandColor) {
soapboxConfig.brandColor = '#0482d8';
}
@ -107,18 +104,30 @@ export function importSoapboxConfig(soapboxConfig, host) {
soapboxConfig,
host,
};
}
};
export function soapboxConfigFail(error, host) {
return {
type: SOAPBOX_CONFIG_REQUEST_FAIL,
error,
skipAlert: true,
host,
};
}
const soapboxConfigFail = (error: AxiosError, host: string | null) => ({
type: SOAPBOX_CONFIG_REQUEST_FAIL,
error,
skipAlert: true,
host,
});
// https://stackoverflow.com/a/46663081
function isObject(o) {
return o instanceof Object && o.constructor === Object;
}
const isObject = (o: any) => o instanceof Object && o.constructor === Object;
export {
SOAPBOX_CONFIG_REQUEST_SUCCESS,
SOAPBOX_CONFIG_REQUEST_FAIL,
SOAPBOX_CONFIG_REMEMBER_REQUEST,
SOAPBOX_CONFIG_REMEMBER_SUCCESS,
SOAPBOX_CONFIG_REMEMBER_FAIL,
getSoapboxConfig,
rememberSoapboxConfig,
fetchFrontendConfigurations,
fetchSoapboxConfig,
loadSoapboxConfig,
fetchSoapboxJson,
importSoapboxConfig,
soapboxConfigFail,
};

171
app/soapbox/actions/statuses.js → app/soapbox/actions/statuses.ts
View File

@ -9,43 +9,46 @@ import { importFetchedStatus, importFetchedStatuses } from './importer';
import { openModal } from './modals';
import { deleteFromTimelines } from './timelines';
export const STATUS_CREATE_REQUEST = 'STATUS_CREATE_REQUEST';
export const STATUS_CREATE_SUCCESS = 'STATUS_CREATE_SUCCESS';
export const STATUS_CREATE_FAIL = 'STATUS_CREATE_FAIL';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
export const STATUS_FETCH_SOURCE_REQUEST = 'STATUS_FETCH_SOURCE_REQUEST';
export const STATUS_FETCH_SOURCE_SUCCESS = 'STATUS_FETCH_SOURCE_SUCCESS';
export const STATUS_FETCH_SOURCE_FAIL = 'STATUS_FETCH_SOURCE_FAIL';
const STATUS_CREATE_REQUEST = 'STATUS_CREATE_REQUEST';
const STATUS_CREATE_SUCCESS = 'STATUS_CREATE_SUCCESS';
const STATUS_CREATE_FAIL = 'STATUS_CREATE_FAIL';
export const STATUS_FETCH_REQUEST = 'STATUS_FETCH_REQUEST';
export const STATUS_FETCH_SUCCESS = 'STATUS_FETCH_SUCCESS';
export const STATUS_FETCH_FAIL = 'STATUS_FETCH_FAIL';
const STATUS_FETCH_SOURCE_REQUEST = 'STATUS_FETCH_SOURCE_REQUEST';
const STATUS_FETCH_SOURCE_SUCCESS = 'STATUS_FETCH_SOURCE_SUCCESS';
const STATUS_FETCH_SOURCE_FAIL = 'STATUS_FETCH_SOURCE_FAIL';
export const STATUS_DELETE_REQUEST = 'STATUS_DELETE_REQUEST';
export const STATUS_DELETE_SUCCESS = 'STATUS_DELETE_SUCCESS';
export const STATUS_DELETE_FAIL = 'STATUS_DELETE_FAIL';
const STATUS_FETCH_REQUEST = 'STATUS_FETCH_REQUEST';
const STATUS_FETCH_SUCCESS = 'STATUS_FETCH_SUCCESS';
const STATUS_FETCH_FAIL = 'STATUS_FETCH_FAIL';
export const CONTEXT_FETCH_REQUEST = 'CONTEXT_FETCH_REQUEST';
export const CONTEXT_FETCH_SUCCESS = 'CONTEXT_FETCH_SUCCESS';
export const CONTEXT_FETCH_FAIL = 'CONTEXT_FETCH_FAIL';
const STATUS_DELETE_REQUEST = 'STATUS_DELETE_REQUEST';
const STATUS_DELETE_SUCCESS = 'STATUS_DELETE_SUCCESS';
const STATUS_DELETE_FAIL = 'STATUS_DELETE_FAIL';
export const STATUS_MUTE_REQUEST = 'STATUS_MUTE_REQUEST';
export const STATUS_MUTE_SUCCESS = 'STATUS_MUTE_SUCCESS';
export const STATUS_MUTE_FAIL = 'STATUS_MUTE_FAIL';
const CONTEXT_FETCH_REQUEST = 'CONTEXT_FETCH_REQUEST';
const CONTEXT_FETCH_SUCCESS = 'CONTEXT_FETCH_SUCCESS';
const CONTEXT_FETCH_FAIL = 'CONTEXT_FETCH_FAIL';
export const STATUS_UNMUTE_REQUEST = 'STATUS_UNMUTE_REQUEST';
export const STATUS_UNMUTE_SUCCESS = 'STATUS_UNMUTE_SUCCESS';
export const STATUS_UNMUTE_FAIL = 'STATUS_UNMUTE_FAIL';
const STATUS_MUTE_REQUEST = 'STATUS_MUTE_REQUEST';
const STATUS_MUTE_SUCCESS = 'STATUS_MUTE_SUCCESS';
const STATUS_MUTE_FAIL = 'STATUS_MUTE_FAIL';
export const STATUS_REVEAL = 'STATUS_REVEAL';
export const STATUS_HIDE = 'STATUS_HIDE';
const STATUS_UNMUTE_REQUEST = 'STATUS_UNMUTE_REQUEST';
const STATUS_UNMUTE_SUCCESS = 'STATUS_UNMUTE_SUCCESS';
const STATUS_UNMUTE_FAIL = 'STATUS_UNMUTE_FAIL';
const statusExists = (getState, statusId) => {
return getState().getIn(['statuses', statusId], null) !== null;
const STATUS_REVEAL = 'STATUS_REVEAL';
const STATUS_HIDE = 'STATUS_HIDE';
const statusExists = (getState: () => RootState, statusId: string) => {
return (getState().statuses.get(statusId) || null) !== null;
};
export function createStatus(params, idempotencyKey, statusId) {
return (dispatch, getState) => {
const createStatus = (params: Record<string, any>, idempotencyKey: string, statusId: string | null) => {
return (dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: STATUS_CREATE_REQUEST, params, idempotencyKey });
return api(getState).request({
@ -85,13 +88,13 @@ export function createStatus(params, idempotencyKey, statusId) {
throw error;
});
};
}
};
export const editStatus = (id) => (dispatch, getState) => {
let status = getState().getIn(['statuses', id]);
const editStatus = (id: string) => (dispatch: AppDispatch, getState: () => RootState) => {
let status = getState().statuses.get(id)!;
if (status.get('poll')) {
status = status.set('poll', getState().getIn(['polls', status.get('poll')]));
if (status.poll) {
status = status.set('poll', getState().polls.get(status.poll) as any);
}
dispatch({ type: STATUS_FETCH_SOURCE_REQUEST });
@ -106,8 +109,8 @@ export const editStatus = (id) => (dispatch, getState) => {
});
};
export function fetchStatus(id) {
return (dispatch, getState) => {
const fetchStatus = (id: string) => {
return (dispatch: AppDispatch, getState: () => RootState) => {
const skipLoading = statusExists(getState, id);
dispatch({ type: STATUS_FETCH_REQUEST, id, skipLoading });
@ -120,16 +123,16 @@ export function fetchStatus(id) {
dispatch({ type: STATUS_FETCH_FAIL, id, error, skipLoading, skipAlert: true });
});
};
}
};
export function deleteStatus(id, routerHistory, withRedraft = false) {
return (dispatch, getState) => {
const deleteStatus = (id: string, withRedraft = false) => {
return (dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return null;
let status = getState().getIn(['statuses', id]);
let status = getState().statuses.get(id)!;
if (status.get('poll')) {
status = status.set('poll', getState().getIn(['polls', status.get('poll')]));
if (status.poll) {
status = status.set('poll', getState().polls.get(status.poll) as any);
}
dispatch({ type: STATUS_DELETE_REQUEST, params: status });
@ -149,13 +152,13 @@ export function deleteStatus(id, routerHistory, withRedraft = false) {
dispatch({ type: STATUS_DELETE_FAIL, params: status, error });
});
};
}
};
export const updateStatus = status => dispatch =>
const updateStatus = (status: APIEntity) => (dispatch: AppDispatch) =>
dispatch(importFetchedStatus(status));
export function fetchContext(id) {
return (dispatch, getState) => {
const fetchContext = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
dispatch({ type: CONTEXT_FETCH_REQUEST, id });
return api(getState).get(`/api/v1/statuses/${id}/context`).then(({ data: context }) => {
@ -180,10 +183,9 @@ export function fetchContext(id) {
dispatch({ type: CONTEXT_FETCH_FAIL, id, error, skipAlert: true });
});
};
}
export function fetchNext(statusId, next) {
return async(dispatch, getState) => {
const fetchNext = (statusId: string, next: string) =>
async(dispatch: AppDispatch, getState: () => RootState) => {
const response = await api(getState).get(next);
dispatch(importFetchedStatuses(response.data));
@ -196,26 +198,23 @@ export function fetchNext(statusId, next) {
return { next: getNextLink(response) };
};
}
export function fetchAncestors(id) {
return async(dispatch, getState) => {
const fetchAncestors = (id: string) =>
async(dispatch: AppDispatch, getState: () => RootState) => {
const response = await api(getState).get(`/api/v1/statuses/${id}/context/ancestors`);
dispatch(importFetchedStatuses(response.data));
return response;
};
}
export function fetchDescendants(id) {
return async(dispatch, getState) => {
const fetchDescendants = (id: string) =>
async(dispatch: AppDispatch, getState: () => RootState) => {
const response = await api(getState).get(`/api/v1/statuses/${id}/context/descendants`);
dispatch(importFetchedStatuses(response.data));
return response;
};
}
export function fetchStatusWithContext(id) {
return async(dispatch, getState) => {
const fetchStatusWithContext = (id: string) =>
async(dispatch: AppDispatch, getState: () => RootState) => {
const features = getFeatures(getState().instance);
if (features.paginatedContext) {
@ -242,10 +241,10 @@ export function fetchStatusWithContext(id) {
return { next: undefined };
}
};
}
export function muteStatus(id) {
return (dispatch, getState) => {
const muteStatus = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch({ type: STATUS_MUTE_REQUEST, id });
@ -255,10 +254,9 @@ export function muteStatus(id) {
dispatch({ type: STATUS_MUTE_FAIL, id, error });
});
};
}
export function unmuteStatus(id) {
return (dispatch, getState) => {
const unmuteStatus = (id: string) =>
(dispatch: AppDispatch, getState: () => RootState) => {
if (!isLoggedIn(getState)) return;
dispatch({ type: STATUS_UNMUTE_REQUEST, id });
@ -268,9 +266,8 @@ export function unmuteStatus(id) {
dispatch({ type: STATUS_UNMUTE_FAIL, id, error });
});
};
}
export function hideStatus(ids) {
const hideStatus = (ids: string[] | string) => {
if (!Array.isArray(ids)) {
ids = [ids];
}
@ -279,9 +276,9 @@ export function hideStatus(ids) {
type: STATUS_HIDE,
ids,
};
}
};
export function revealStatus(ids) {
const revealStatus = (ids: string[] | string) => {
if (!Array.isArray(ids)) {
ids = [ids];
}
@ -290,4 +287,44 @@ export function revealStatus(ids) {
type: STATUS_REVEAL,
ids,
};
}
};
export {
STATUS_CREATE_REQUEST,
STATUS_CREATE_SUCCESS,
STATUS_CREATE_FAIL,
STATUS_FETCH_SOURCE_REQUEST,
STATUS_FETCH_SOURCE_SUCCESS,
STATUS_FETCH_SOURCE_FAIL,
STATUS_FETCH_REQUEST,
STATUS_FETCH_SUCCESS,
STATUS_FETCH_FAIL,
STATUS_DELETE_REQUEST,
STATUS_DELETE_SUCCESS,
STATUS_DELETE_FAIL,
CONTEXT_FETCH_REQUEST,
CONTEXT_FETCH_SUCCESS,
CONTEXT_FETCH_FAIL,
STATUS_MUTE_REQUEST,
STATUS_MUTE_SUCCESS,
STATUS_MUTE_FAIL,
STATUS_UNMUTE_REQUEST,
STATUS_UNMUTE_SUCCESS,
STATUS_UNMUTE_FAIL,
STATUS_REVEAL,
STATUS_HIDE,
createStatus,
editStatus,
fetchStatus,
deleteStatus,
updateStatus,
fetchContext,
fetchNext,
fetchAncestors,
fetchDescendants,
fetchStatusWithContext,
muteStatus,
unmuteStatus,
hideStatus,
revealStatus,
};

112
app/soapbox/actions/streaming.js
View File

@ -1,112 +0,0 @@
import { getSettings } from 'soapbox/actions/settings';
import messages from 'soapbox/locales/messages';
import { connectStream } from '../stream';
import { updateConversations } from './conversations';
import { fetchFilters } from './filters';
import { updateNotificationsQueue, expandNotifications } from './notifications';
import { updateStatus } from './statuses';
import {
deleteFromTimelines,
expandHomeTimeline,
connectTimeline,
disconnectTimeline,
processTimelineUpdate,
} from './timelines';
export const STREAMING_CHAT_UPDATE = 'STREAMING_CHAT_UPDATE';
export const STREAMING_FOLLOW_RELATIONSHIPS_UPDATE = 'STREAMING_FOLLOW_RELATIONSHIPS_UPDATE';
const validLocale = locale => Object.keys(messages).includes(locale);
const getLocale = state => {
const locale = getSettings(state).get('locale');
return validLocale(locale) ? locale : 'en';
};
function updateFollowRelationships(relationships) {
return (dispatch, getState) => {
const me = getState().get('me');
return dispatch({
type: STREAMING_FOLLOW_RELATIONSHIPS_UPDATE,
me,
...relationships,
});
};
}
export function connectTimelineStream(timelineId, path, pollingRefresh = null, accept = null) {
return connectStream (path, pollingRefresh, (dispatch, getState) => {
const locale = getLocale(getState());
return {
onConnect() {
dispatch(connectTimeline(timelineId));
},
onDisconnect() {
dispatch(disconnectTimeline(timelineId));
},
onReceive(data) {
switch (data.event) {
case 'update':
dispatch(processTimelineUpdate(timelineId, JSON.parse(data.payload), accept));
break;
case 'status.update':
dispatch(updateStatus(JSON.parse(data.payload)));
break;
case 'delete':
dispatch(deleteFromTimelines(data.payload));
break;
case 'notification':
messages[locale]().then(messages => {
dispatch(updateNotificationsQueue(JSON.parse(data.payload), messages, locale, window.location.pathname));
}).catch(error => {
console.error(error);
});
break;
case 'conversation':
dispatch(updateConversations(JSON.parse(data.payload)));
break;
case 'filters_changed':
dispatch(fetchFilters());
break;
case 'pleroma:chat_update':
dispatch((dispatch, getState) => {
const chat = JSON.parse(data.payload);
const me = getState().get('me');
const messageOwned = !(chat.last_message && chat.last_message.account_id !== me);
dispatch({
type: STREAMING_CHAT_UPDATE,
chat,
me,
// Only play sounds for recipient messages
meta: !messageOwned && getSettings(getState()).getIn(['chats', 'sound']) && { sound: 'chat' },
});
});
break;
case 'pleroma:follow_relationships_update':
dispatch(updateFollowRelationships(JSON.parse(data.payload)));
break;
}
},
};
});
}
const refreshHomeTimelineAndNotification = (dispatch, done) => {
dispatch(expandHomeTimeline({}, () => dispatch(expandNotifications({}, done))));
};
export const connectUserStream = () => connectTimelineStream('home', 'user', refreshHomeTimelineAndNotification);
export const connectCommunityStream = ({ onlyMedia } = {}) => connectTimelineStream(`community${onlyMedia ? ':media' : ''}`, `public:local${onlyMedia ? ':media' : ''}`);
export const connectPublicStream = ({ onlyMedia } = {}) => connectTimelineStream(`public${onlyMedia ? ':media' : ''}`, `public${onlyMedia ? ':media' : ''}`);
export const connectRemoteStream = (instance, { onlyMedia } = {}) => connectTimelineStream(`remote${onlyMedia ? ':media' : ''}:${instance}`, `public:remote${onlyMedia ? ':media' : ''}&instance=${instance}`);
export const connectHashtagStream = (id, tag, accept) => connectTimelineStream(`hashtag:${id}`, `hashtag&tag=${tag}`, null, accept);
export const connectDirectStream = () => connectTimelineStream('direct', 'direct');
export const connectListStream = id => connectTimelineStream(`list:${id}`, `list&list=${id}`);
export const connectGroupStream = id => connectTimelineStream(`group:${id}`, `group&group=${id}`);

144
app/soapbox/actions/streaming.ts Normal file
View File

@ -0,0 +1,144 @@
import { getSettings } from 'soapbox/actions/settings';
import messages from 'soapbox/locales/messages';
import { connectStream } from '../stream';
import { updateConversations } from './conversations';
import { fetchFilters } from './filters';
import { updateNotificationsQueue, expandNotifications } from './notifications';
import { updateStatus } from './statuses';
import {
deleteFromTimelines,
expandHomeTimeline,
connectTimeline,
disconnectTimeline,
processTimelineUpdate,
} from './timelines';
import type { AppDispatch, RootState } from 'soapbox/store';
import type { APIEntity } from 'soapbox/types/entities';
const STREAMING_CHAT_UPDATE = 'STREAMING_CHAT_UPDATE';
const STREAMING_FOLLOW_RELATIONSHIPS_UPDATE = 'STREAMING_FOLLOW_RELATIONSHIPS_UPDATE';
const validLocale = (locale: string) => Object.keys(messages).includes(locale);
const getLocale = (state: RootState) => {
const locale = getSettings(state).get('locale') as string;
return validLocale(locale) ? locale : 'en';
};
const updateFollowRelationships = (relationships: APIEntity) =>
(dispatch: AppDispatch, getState: () => RootState) => {
const me = getState().me;
return dispatch({
type: STREAMING_FOLLOW_RELATIONSHIPS_UPDATE,
me,
...relationships,
});
};
const connectTimelineStream = (
timelineId: string,
path: string,
pollingRefresh: ((dispatch: AppDispatch, done?: () => void) => void) | null = null,
accept: ((status: APIEntity) => boolean) | null = null,
) => connectStream(path, pollingRefresh, (dispatch: AppDispatch, getState: () => RootState) => {
const locale = getLocale(getState());
return {
onConnect() {
dispatch(connectTimeline(timelineId));
},
onDisconnect() {
dispatch(disconnectTimeline(timelineId));
},
onReceive(data: any) {
switch (data.event) {
case 'update':
dispatch(processTimelineUpdate(timelineId, JSON.parse(data.payload), accept));
break;
case 'status.update':
dispatch(updateStatus(JSON.parse(data.payload)));
break;
case 'delete':
dispatch(deleteFromTimelines(data.payload));
break;
case 'notification':
messages[locale]().then(messages => {
dispatch(updateNotificationsQueue(JSON.parse(data.payload), messages, locale, window.location.pathname));
}).catch(error => {
console.error(error);
});
break;
case 'conversation':
dispatch(updateConversations(JSON.parse(data.payload)));
break;
case 'filters_changed':
dispatch(fetchFilters());
break;
case 'pleroma:chat_update':
dispatch((dispatch: AppDispatch, getState: () => RootState) => {
const chat = JSON.parse(data.payload);
const me = getState().me;
const messageOwned = !(chat.last_message && chat.last_message.account_id !== me);
dispatch({
type: STREAMING_CHAT_UPDATE,
chat,
me,
// Only play sounds for recipient messages
meta: !messageOwned && getSettings(getState()).getIn(['chats', 'sound']) && { sound: 'chat' },
});
});
break;
case 'pleroma:follow_relationships_update':
dispatch(updateFollowRelationships(JSON.parse(data.payload)));
break;
}
},
};
});
const refreshHomeTimelineAndNotification = (dispatch: AppDispatch, done?: () => void) =>
dispatch(expandHomeTimeline({}, () => dispatch(expandNotifications({} as any, done))));
const connectUserStream = () =>
connectTimelineStream('home', 'user', refreshHomeTimelineAndNotification);
const connectCommunityStream = ({ onlyMedia }: Record<string, any> = {}) =>
connectTimelineStream(`community${onlyMedia ? ':media' : ''}`, `public:local${onlyMedia ? ':media' : ''}`);
const connectPublicStream = ({ onlyMedia }: Record<string, any> = {}) =>
connectTimelineStream(`public${onlyMedia ? ':media' : ''}`, `public${onlyMedia ? ':media' : ''}`);
const connectRemoteStream = (instance: string, { onlyMedia }: Record<string, any> = {}) =>
connectTimelineStream(`remote${onlyMedia ? ':media' : ''}:${instance}`, `public:remote${onlyMedia ? ':media' : ''}&instance=${instance}`);
const connectHashtagStream = (id: string, tag: string, accept: (status: APIEntity) => boolean) =>
connectTimelineStream(`hashtag:${id}`, `hashtag&tag=${tag}`, null, accept);
const connectDirectStream = () =>
connectTimelineStream('direct', 'direct');
const connectListStream = (id: string) =>
connectTimelineStream(`list:${id}`, `list&list=${id}`);
const connectGroupStream = (id: string) =>
connectTimelineStream(`group:${id}`, `group&group=${id}`);
export {
STREAMING_CHAT_UPDATE,
STREAMING_FOLLOW_RELATIONSHIPS_UPDATE,
connectTimelineStream,
connectUserStream,
connectCommunityStream,
connectPublicStream,
connectRemoteStream,
connectHashtagStream,
connectDirectStream,
connectListStream,
connectGroupStream,
};

Some files were not shown because too many files have changed in this diff Show More