2023-05-28 23:38:10 +09:00
|
|
|
import { Map as ImmutableMap, fromJS } from 'immutable';
|
|
|
|
|
2016-10-30 23:06:43 +09:00
|
|
|
import {
|
2016-11-24 07:34:12 +09:00
|
|
|
REBLOG_REQUEST,
|
|
|
|
REBLOG_FAIL,
|
|
|
|
FAVOURITE_REQUEST,
|
|
|
|
FAVOURITE_FAIL,
|
2019-10-25 05:49:45 +09:00
|
|
|
UNFAVOURITE_SUCCESS,
|
2018-04-12 02:42:25 +09:00
|
|
|
BOOKMARK_REQUEST,
|
|
|
|
BOOKMARK_FAIL,
|
2022-11-29 17:54:35 +09:00
|
|
|
REACTION_UPDATE,
|
|
|
|
REACTION_ADD_FAIL,
|
|
|
|
REACTION_REMOVE_FAIL,
|
|
|
|
REACTION_ADD_REQUEST,
|
|
|
|
REACTION_REMOVE_REQUEST,
|
2017-12-04 16:26:40 +09:00
|
|
|
} from 'flavours/glitch/actions/interactions';
|
2018-07-16 06:24:19 +09:00
|
|
|
import {
|
Feature conversations muting (#3017)
* Add <ostatus:conversation /> tag to Atom input/output
Only uses ref attribute (not href) because href would be
the alternate link that's always included also.
Creates new conversation for every non-reply status. Carries
over conversation for every reply. Keeps remote URIs verbatim,
generates local URIs on the fly like the rest of them.
* Conversation muting - prevents notifications that reference a conversation
(including replies, favourites, reblogs) from being created. API endpoints
/api/v1/statuses/:id/mute and /api/v1/statuses/:id/unmute
Currently no way to tell when a status/conversation is muted, so the web UI
only has a "disable notifications" button, doesn't work as a toggle
* Display "Dismiss notifications" on all statuses in notifications column, not just own
* Add "muted" as a boolean attribute on statuses JSON
For now always false on contained reblogs, since it's only relevant for
statuses returned from the notifications endpoint, which are not nested
Remove "Disable notifications" from detailed status view, since it's
only relevant in the notifications column
* Up max class length
* Remove pending test for conversation mute
* Add tests, clean up
* Rename to "mute conversation" and "unmute conversation"
* Raise validation error when trying to mute/unmute status without conversation
2017-05-15 10:04:13 +09:00
|
|
|
STATUS_MUTE_SUCCESS,
|
2017-05-21 00:31:47 +09:00
|
|
|
STATUS_UNMUTE_SUCCESS,
|
2022-07-25 03:01:30 +09:00
|
|
|
STATUS_REVEAL,
|
|
|
|
STATUS_HIDE,
|
|
|
|
STATUS_COLLAPSE,
|
2022-09-24 06:00:12 +09:00
|
|
|
STATUS_TRANSLATE_SUCCESS,
|
|
|
|
STATUS_TRANSLATE_UNDO,
|
2022-10-20 21:35:29 +09:00
|
|
|
STATUS_FETCH_REQUEST,
|
|
|
|
STATUS_FETCH_FAIL,
|
2017-12-04 16:26:40 +09:00
|
|
|
} from 'flavours/glitch/actions/statuses';
|
2016-10-30 23:06:43 +09:00
|
|
|
import {
|
|
|
|
TIMELINE_DELETE,
|
2017-12-04 16:26:40 +09:00
|
|
|
} from 'flavours/glitch/actions/timelines';
|
2023-05-28 23:38:10 +09:00
|
|
|
|
2019-03-06 04:15:43 +09:00
|
|
|
import { STATUS_IMPORT, STATUSES_IMPORT } from '../actions/importer';
|
2023-06-01 07:10:21 +09:00
|
|
|
import { normalizeStatusTranslation } from '../actions/importer/normalizer';
|
2016-10-30 23:06:43 +09:00
|
|
|
|
2019-03-06 04:15:43 +09:00
|
|
|
const importStatus = (state, status) => state.set(status.id, fromJS(status));
|
2017-04-16 23:33:38 +09:00
|
|
|
|
2019-03-06 04:15:43 +09:00
|
|
|
const importStatuses = (state, statuses) =>
|
|
|
|
state.withMutations(mutable => statuses.forEach(status => importStatus(mutable, status)));
|
2016-10-30 23:06:43 +09:00
|
|
|
|
|
|
|
const deleteStatus = (state, id, references) => {
|
|
|
|
references.forEach(ref => {
|
2020-04-28 16:53:42 +09:00
|
|
|
state = deleteStatus(state, ref, []);
|
2016-10-30 23:06:43 +09:00
|
|
|
});
|
|
|
|
|
|
|
|
return state.delete(id);
|
|
|
|
};
|
|
|
|
|
2022-11-25 02:30:52 +09:00
|
|
|
const updateReaction = (state, id, name, updater) => state.update(
|
|
|
|
id,
|
|
|
|
status => status.update(
|
|
|
|
'reactions',
|
|
|
|
reactions => {
|
|
|
|
const index = reactions.findIndex(reaction => reaction.get('name') === name);
|
|
|
|
if (index > -1) {
|
|
|
|
return reactions.update(index, reaction => updater(reaction));
|
|
|
|
} else {
|
|
|
|
return reactions.push(updater(fromJS({ name, count: 0 })));
|
|
|
|
}
|
|
|
|
},
|
|
|
|
),
|
|
|
|
);
|
|
|
|
|
|
|
|
const updateReactionCount = (state, reaction) => updateReaction(state, reaction.status_id, reaction.name, x => x.set('count', reaction.count));
|
|
|
|
|
2022-12-04 01:20:29 +09:00
|
|
|
// The url parameter is only used when adding a new custom emoji reaction
|
|
|
|
// (one that wasn't in the reactions list before) because we don't have its
|
|
|
|
// URL yet. In all other cases, it's undefined.
|
|
|
|
const addReaction = (state, id, name, url) => updateReaction(
|
2022-11-25 02:30:52 +09:00
|
|
|
state,
|
|
|
|
id,
|
|
|
|
name,
|
2022-12-04 01:20:29 +09:00
|
|
|
x => x.set('me', true)
|
|
|
|
.update('count', n => n + 1)
|
|
|
|
.update('url', old => old ? old : url)
|
|
|
|
.update('static_url', old => old ? old : url),
|
2022-11-25 02:30:52 +09:00
|
|
|
);
|
|
|
|
|
|
|
|
const removeReaction = (state, id, name) => updateReaction(
|
|
|
|
state,
|
|
|
|
id,
|
|
|
|
name,
|
|
|
|
x => x.set('me', false).update('count', n => n - 1),
|
|
|
|
);
|
|
|
|
|
2023-06-01 07:10:21 +09:00
|
|
|
const statusTranslateSuccess = (state, id, translation) => {
|
|
|
|
return state.withMutations(map => {
|
|
|
|
map.setIn([id, 'translation'], fromJS(normalizeStatusTranslation(translation, map.get(id))));
|
|
|
|
|
|
|
|
const list = map.getIn([id, 'media_attachments']);
|
|
|
|
if (translation.media_attachments && list) {
|
|
|
|
translation.media_attachments.forEach(item => {
|
|
|
|
const index = list.findIndex(i => i.get('id') === item.id);
|
|
|
|
map.setIn([id, 'media_attachments', index, 'translation'], fromJS({ description: item.description }));
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
const statusTranslateUndo = (state, id) => {
|
|
|
|
return state.withMutations(map => {
|
|
|
|
map.deleteIn([id, 'translation']);
|
|
|
|
map.getIn([id, 'media_attachments']).forEach((item, index) => map.deleteIn([id, 'media_attachments', index, 'translation']));
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2017-07-11 08:00:14 +09:00
|
|
|
const initialState = ImmutableMap();
|
2016-10-30 23:06:43 +09:00
|
|
|
|
|
|
|
export default function statuses(state = initialState, action) {
|
|
|
|
switch(action.type) {
|
2022-10-20 21:35:29 +09:00
|
|
|
case STATUS_FETCH_REQUEST:
|
|
|
|
return state.setIn([action.id, 'isLoading'], true);
|
|
|
|
case STATUS_FETCH_FAIL:
|
|
|
|
return state.delete(action.id);
|
2019-03-06 04:15:43 +09:00
|
|
|
case STATUS_IMPORT:
|
|
|
|
return importStatus(state, action.status);
|
|
|
|
case STATUSES_IMPORT:
|
|
|
|
return importStatuses(state, action.statuses);
|
2017-01-16 21:27:58 +09:00
|
|
|
case FAVOURITE_REQUEST:
|
|
|
|
return state.setIn([action.status.get('id'), 'favourited'], true);
|
2019-10-25 05:49:45 +09:00
|
|
|
case UNFAVOURITE_SUCCESS:
|
2020-01-30 00:18:33 +09:00
|
|
|
return state.updateIn([action.status.get('id'), 'favourites_count'], x => Math.max(0, x - 1));
|
2017-01-16 21:27:58 +09:00
|
|
|
case FAVOURITE_FAIL:
|
2018-11-14 00:30:07 +09:00
|
|
|
return state.get(action.status.get('id')) === undefined ? state : state.setIn([action.status.get('id'), 'favourited'], false);
|
2018-04-12 02:42:25 +09:00
|
|
|
case BOOKMARK_REQUEST:
|
|
|
|
return state.setIn([action.status.get('id'), 'bookmarked'], true);
|
|
|
|
case BOOKMARK_FAIL:
|
2018-11-14 00:30:07 +09:00
|
|
|
return state.get(action.status.get('id')) === undefined ? state : state.setIn([action.status.get('id'), 'bookmarked'], false);
|
2017-01-16 21:27:58 +09:00
|
|
|
case REBLOG_REQUEST:
|
|
|
|
return state.setIn([action.status.get('id'), 'reblogged'], true);
|
|
|
|
case REBLOG_FAIL:
|
2018-11-14 00:30:07 +09:00
|
|
|
return state.get(action.status.get('id')) === undefined ? state : state.setIn([action.status.get('id'), 'reblogged'], false);
|
2022-11-29 17:54:35 +09:00
|
|
|
case REACTION_UPDATE:
|
2022-11-25 02:30:52 +09:00
|
|
|
return updateReactionCount(state, action.reaction);
|
2022-11-29 17:54:35 +09:00
|
|
|
case REACTION_ADD_REQUEST:
|
|
|
|
case REACTION_REMOVE_FAIL:
|
2022-12-04 01:20:29 +09:00
|
|
|
return addReaction(state, action.id, action.name, action.url);
|
2022-11-29 17:54:35 +09:00
|
|
|
case REACTION_REMOVE_REQUEST:
|
|
|
|
case REACTION_ADD_FAIL:
|
2022-11-25 02:30:52 +09:00
|
|
|
return removeReaction(state, action.id, action.name);
|
Feature conversations muting (#3017)
* Add <ostatus:conversation /> tag to Atom input/output
Only uses ref attribute (not href) because href would be
the alternate link that's always included also.
Creates new conversation for every non-reply status. Carries
over conversation for every reply. Keeps remote URIs verbatim,
generates local URIs on the fly like the rest of them.
* Conversation muting - prevents notifications that reference a conversation
(including replies, favourites, reblogs) from being created. API endpoints
/api/v1/statuses/:id/mute and /api/v1/statuses/:id/unmute
Currently no way to tell when a status/conversation is muted, so the web UI
only has a "disable notifications" button, doesn't work as a toggle
* Display "Dismiss notifications" on all statuses in notifications column, not just own
* Add "muted" as a boolean attribute on statuses JSON
For now always false on contained reblogs, since it's only relevant for
statuses returned from the notifications endpoint, which are not nested
Remove "Disable notifications" from detailed status view, since it's
only relevant in the notifications column
* Up max class length
* Remove pending test for conversation mute
* Add tests, clean up
* Rename to "mute conversation" and "unmute conversation"
* Raise validation error when trying to mute/unmute status without conversation
2017-05-15 10:04:13 +09:00
|
|
|
case STATUS_MUTE_SUCCESS:
|
|
|
|
return state.setIn([action.id, 'muted'], true);
|
|
|
|
case STATUS_UNMUTE_SUCCESS:
|
|
|
|
return state.setIn([action.id, 'muted'], false);
|
2022-07-25 03:01:30 +09:00
|
|
|
case STATUS_REVEAL:
|
|
|
|
return state.withMutations(map => {
|
|
|
|
action.ids.forEach(id => {
|
|
|
|
if (!(state.get(id) === undefined)) {
|
|
|
|
map.setIn([id, 'hidden'], false);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
case STATUS_HIDE:
|
|
|
|
return state.withMutations(map => {
|
|
|
|
action.ids.forEach(id => {
|
|
|
|
if (!(state.get(id) === undefined)) {
|
|
|
|
map.setIn([id, 'hidden'], true);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
case STATUS_COLLAPSE:
|
|
|
|
return state.setIn([action.id, 'collapsed'], action.isCollapsed);
|
2017-01-16 21:27:58 +09:00
|
|
|
case TIMELINE_DELETE:
|
|
|
|
return deleteStatus(state, action.id, action.references);
|
2022-09-24 06:00:12 +09:00
|
|
|
case STATUS_TRANSLATE_SUCCESS:
|
2023-06-01 07:10:21 +09:00
|
|
|
return statusTranslateSuccess(state, action.id, action.translation);
|
2022-09-24 06:00:12 +09:00
|
|
|
case STATUS_TRANSLATE_UNDO:
|
2023-06-01 07:10:21 +09:00
|
|
|
return statusTranslateUndo(state, action.id);
|
2017-01-16 21:27:58 +09:00
|
|
|
default:
|
|
|
|
return state;
|
2016-10-30 23:06:43 +09:00
|
|
|
}
|
2023-02-04 04:52:07 +09:00
|
|
|
}
|