miklo
/
soapbox
sforkowany z mirror/soapbox
1
0
Forkuj 0
Kod Zgłoszenia Oczekujące zmiany Packages Projekty Wydania Wiki Aktywność

Actions: TypeScript 

Signed-off-by: marcin mikołajczak <git@mkljczk.pl>
settings-alert
marcin mikołajczak 2022-06-19 21:26:57 +02:00
rodzic 86511dc26b
commit 4719cf6b5b
9 zmienionych plików z 638 dodań i 498 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

394
app/soapbox/actions/lists.js
Wyświetl plik

@ -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 100644
Wyświetl plik

@ -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,
};

55
app/soapbox/actions/settings.js → app/soapbox/actions/settings.ts
Wyświetl plik

@ -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,10 +187,9 @@ export function changeSettingImmediate(path, value) {
dispatch(saveSettingsImmediate());
};
}
export function changeSetting(path, value) {
return dispatch => {
const changeSetting = (path: string[], value: any) =>
(dispatch: AppDispatch) => {
dispatch({
type: SETTING_CHANGE,
path,
@ -197,22 +198,21 @@ export function changeSetting(path, value) {
return dispatch(saveSettings());
};
}
export function saveSettingsImmediate() {
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 });
dispatch(snackbar.success(messages.saveSuccess));
@ -220,8 +220,19 @@ export function saveSettingsImmediate() {
dispatch(showAlertForError(error));
});
};
}
export function saveSettings() {
return (dispatch, getState) => dispatch(saveSettingsImmediate());
}
const saveSettings = () =>
(dispatch: AppDispatch) => dispatch(saveSettingsImmediate());
export {
SETTING_CHANGE,
SETTING_SAVE,
SETTINGS_UPDATE,
FE_NAME,
defaultSettings,
getSettings,
changeSettingImmediate,
changeSetting,
saveSettingsImmediate,
saveSettings,
};

171
app/soapbox/actions/statuses.js → app/soapbox/actions/statuses.ts
Wyświetl plik

@ -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) => {
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,
};

6
app/soapbox/components/status_action_bar.tsx
Wyświetl plik

@ -76,7 +76,7 @@ interface IStatusActionBar extends RouteComponentProps {
onBookmark: (status: Status) => void,
onReblog: (status: Status, e: React.MouseEvent) => void,
onQuote: (status: Status, history: History) => void,
onDelete: (status: Status, history: History, redraft?: boolean) => void,
onDelete: (status: Status, redraft?: boolean) => void,
onEdit: (status: Status) => void,
onDirect: (account: any, history: History) => void,
onChat: (account: any, history: History) => void,
@ -241,12 +241,12 @@ class StatusActionBar extends ImmutablePureComponent<IStatusActionBar, IStatusAc
handleDeleteClick: React.EventHandler<React.MouseEvent> = (e) => {
e.stopPropagation();
this.props.onDelete(this.props.status, this.props.history);
this.props.onDelete(this.props.status);
}
handleRedraftClick: React.EventHandler<React.MouseEvent> = (e) => {
e.stopPropagation();
this.props.onDelete(this.props.status, this.props.history, true);
this.props.onDelete(this.props.status, true);
}
handleEditClick: React.EventHandler<React.MouseEvent> = () => {

6
app/soapbox/containers/status_container.js
Wyświetl plik

@ -156,18 +156,18 @@ const mapDispatchToProps = (dispatch, { intl }) => {
}));
},
onDelete(status, history, withRedraft = false) {
onDelete(status, withRedraft = false) {
dispatch((_, getState) => {
const deleteModal = getSettings(getState()).get('deleteModal');
if (!deleteModal) {
dispatch(deleteStatus(status.get('id'), history, withRedraft));
dispatch(deleteStatus(status.get('id'), withRedraft));
} else {
dispatch(openModal('CONFIRM', {
icon: withRedraft ? require('@tabler/icons/icons/edit.svg') : require('@tabler/icons/icons/trash.svg'),
heading: intl.formatMessage(withRedraft ? messages.redraftHeading : messages.deleteHeading),
message: intl.formatMessage(withRedraft ? messages.redraftMessage : messages.deleteMessage),
confirm: intl.formatMessage(withRedraft ? messages.redraftConfirm : messages.deleteConfirm),
onConfirm: () => dispatch(deleteStatus(status.get('id'), history, withRedraft)),
onConfirm: () => dispatch(deleteStatus(status.get('id'), withRedraft)),
}));
}
});

6
app/soapbox/features/status/components/action-bar.tsx
Wyświetl plik

@ -94,7 +94,7 @@ interface OwnProps {
onQuote: (status: StatusEntity, history: History) => void,
onFavourite: (status: StatusEntity) => void,
onEmojiReact: (status: StatusEntity, emoji: string) => void,
onDelete: (status: StatusEntity, history: History, redraft?: boolean) => void,
onDelete: (status: StatusEntity, redraft?: boolean) => void,
onEdit: (status: StatusEntity) => void,
onBookmark: (status: StatusEntity) => void,
onDirect: (account: AccountEntity, history: History) => void,
@ -236,11 +236,11 @@ class ActionBar extends React.PureComponent<IActionBar, IActionBarState> {
}
handleDeleteClick: React.EventHandler<React.MouseEvent> = () => {
this.props.onDelete(this.props.status, this.props.history);
this.props.onDelete(this.props.status);
}
handleRedraftClick: React.EventHandler<React.MouseEvent> = () => {
this.props.onDelete(this.props.status, this.props.history, true);
this.props.onDelete(this.props.status, true);
}
handleEditClick: React.EventHandler<React.MouseEvent> = () => {

6
app/soapbox/features/status/containers/detailed_status_container.js
Wyświetl plik

@ -128,18 +128,18 @@ const mapDispatchToProps = (dispatch, { intl }) => ({
}));
},
onDelete(status, history, withRedraft = false) {
onDelete(status, withRedraft = false) {
dispatch((_, getState) => {
const deleteModal = getSettings(getState()).get('deleteModal');
if (!deleteModal) {
dispatch(deleteStatus(status.get('id'), history, withRedraft));
dispatch(deleteStatus(status.get('id'), withRedraft));
} else {
dispatch(openModal('CONFIRM', {
icon: withRedraft ? require('@tabler/icons/icons/edit.svg') : require('@tabler/icons/icons/trash.svg'),
heading: intl.formatMessage(withRedraft ? messages.redraftHeading : messages.deleteHeading),
message: intl.formatMessage(withRedraft ? messages.redraftMessage : messages.deleteMessage),
confirm: intl.formatMessage(withRedraft ? messages.redraftConfirm : messages.deleteConfirm),
onConfirm: () => dispatch(deleteStatus(status.get('id'), history, withRedraft)),
onConfirm: () => dispatch(deleteStatus(status.get('id'), withRedraft)),
}));
}
});

6
app/soapbox/features/status/index.tsx
Wyświetl plik

@ -312,20 +312,20 @@ class Status extends ImmutablePureComponent<IStatus, IStatusState> {
}
}
handleDeleteClick = (status: StatusEntity, history: History, withRedraft = false) => {
handleDeleteClick = (status: StatusEntity, withRedraft = false) => {
const { dispatch, intl } = this.props;
this.props.dispatch((_, getState) => {
const deleteModal = getSettings(getState()).get('deleteModal');
if (!deleteModal) {
dispatch(deleteStatus(status.id, history, withRedraft));
dispatch(deleteStatus(status.id, withRedraft));
} else {
dispatch(openModal('CONFIRM', {
icon: withRedraft ? require('@tabler/icons/icons/edit.svg') : require('@tabler/icons/icons/trash.svg'),
heading: intl.formatMessage(withRedraft ? messages.redraftHeading : messages.deleteHeading),
message: intl.formatMessage(withRedraft ? messages.redraftMessage : messages.deleteMessage),
confirm: intl.formatMessage(withRedraft ? messages.redraftConfirm : messages.deleteConfirm),
onConfirm: () => dispatch(deleteStatus(status.id, history, withRedraft)),
onConfirm: () => dispatch(deleteStatus(status.id, withRedraft)),
}));
}
});