// @flow import * as ACTIONS from 'constants/action_types'; import * as REACTION_TYPES from 'constants/reactions'; import { Lbry, parseURI, buildURI, selectClaimsByUri, selectMyChannelClaims } from 'lbry-redux'; import { doToast, doSeeNotifications } from 'redux/actions/notifications'; import { makeSelectCommentIdsForUri, makeSelectMyReactionsForComment, makeSelectOthersReactionsForComment, selectPendingCommentReacts, selectModerationBlockList, } from 'redux/selectors/comments'; import { makeSelectNotificationForCommentId } from 'redux/selectors/notifications'; import { selectActiveChannelClaim } from 'redux/selectors/app'; import { toHex } from 'util/hex'; import Comments from 'comments'; export function doCommentList(uri: string, page: number = 1, pageSize: number = 99999) { return (dispatch: Dispatch, getState: GetState) => { const state = getState(); const claim = selectClaimsByUri(state)[uri]; const claimId = claim ? claim.claim_id : null; if (!claimId) { dispatch({ type: ACTIONS.COMMENT_LIST_FAILED, data: 'unable to find claim for uri', }); return; } dispatch({ type: ACTIONS.COMMENT_LIST_STARTED, }); return Comments.comment_list({ page, claim_id: claimId, page_size: pageSize, }) .then((result: CommentListResponse) => { const { items: comments } = result; dispatch({ type: ACTIONS.COMMENT_LIST_COMPLETED, data: { comments, claimId: claimId, uri: uri, }, }); return result; }) .catch((error) => { dispatch({ type: ACTIONS.COMMENT_LIST_FAILED, data: error, }); }); }; } export function doCommentReactList(uri: string | null, commentId?: string) { return (dispatch: Dispatch, getState: GetState) => { const state = getState(); const activeChannelClaim = selectActiveChannelClaim(state); const commentIds = uri ? makeSelectCommentIdsForUri(uri)(state) : [commentId]; dispatch({ type: ACTIONS.COMMENT_REACTION_LIST_STARTED, }); const params: { comment_ids: string, channel_name?: string, channel_id?: string } = { comment_ids: commentIds.join(','), }; if (activeChannelClaim) { params['channel_name'] = activeChannelClaim.name; params['channel_id'] = activeChannelClaim.claim_id; } return Lbry.comment_react_list(params) .then((result: CommentReactListResponse) => { const { my_reactions: myReactions, others_reactions: othersReactions } = result; dispatch({ type: ACTIONS.COMMENT_REACTION_LIST_COMPLETED, data: { myReactions: myReactions || {}, othersReactions, }, }); }) .catch((error) => { dispatch({ type: ACTIONS.COMMENT_REACTION_LIST_FAILED, data: error, }); }); }; } export function doCommentReact(commentId: string, type: string) { return (dispatch: Dispatch, getState: GetState) => { const state = getState(); const activeChannelClaim = selectActiveChannelClaim(state); const pendingReacts = selectPendingCommentReacts(state); const notification = makeSelectNotificationForCommentId(commentId)(state); if (!activeChannelClaim) { console.error('Unable to react to comment. No activeChannel is set.'); // eslint-disable-line return; } if (notification && !notification.is_seen) { dispatch(doSeeNotifications([notification.id])); } const exclusiveTypes = { [REACTION_TYPES.LIKE]: REACTION_TYPES.DISLIKE, [REACTION_TYPES.DISLIKE]: REACTION_TYPES.LIKE, }; if (pendingReacts.includes(commentId + exclusiveTypes[type]) || pendingReacts.includes(commentId + type)) { // ignore dislikes during likes, for example return; } let myReacts = makeSelectMyReactionsForComment(commentId)(state); const othersReacts = makeSelectOthersReactionsForComment(commentId)(state); const params: CommentReactParams = { comment_ids: commentId, channel_name: activeChannelClaim.name, channel_id: activeChannelClaim.claim_id, react_type: type, }; if (myReacts.includes(type)) { params['remove'] = true; myReacts.splice(myReacts.indexOf(type), 1); } else { myReacts.push(type); if (Object.keys(exclusiveTypes).includes(type)) { params['clear_types'] = exclusiveTypes[type]; if (myReacts.indexOf(exclusiveTypes[type]) !== -1) { myReacts.splice(myReacts.indexOf(exclusiveTypes[type]), 1); } } } dispatch({ type: ACTIONS.COMMENT_REACT_STARTED, data: commentId + type, }); // simulate api return shape: ['like'] -> { 'like': 1 } const myReactsObj = myReacts.reduce((acc, el) => { acc[el] = 1; return acc; }, {}); dispatch({ type: ACTIONS.COMMENT_REACTION_LIST_COMPLETED, data: { myReactions: { [commentId]: myReactsObj }, othersReactions: { [commentId]: othersReacts }, }, }); Lbry.comment_react(params) .then((result: CommentReactListResponse) => { dispatch({ type: ACTIONS.COMMENT_REACT_COMPLETED, data: commentId + type, }); }) .catch((error) => { dispatch({ type: ACTIONS.COMMENT_REACT_FAILED, data: commentId + type, }); const myRevertedReactsObj = myReacts .filter((el) => el !== type) .reduce((acc, el) => { acc[el] = 1; return acc; }, {}); dispatch({ type: ACTIONS.COMMENT_REACTION_LIST_COMPLETED, data: { myReactions: { [commentId]: myRevertedReactsObj }, othersReactions: { [commentId]: othersReacts }, }, }); }); }; } export function doCommentCreate(comment: string = '', claim_id: string = '', parent_id?: string, uri: string) { return (dispatch: Dispatch, getState: GetState) => { const state = getState(); const activeChannelClaim = selectActiveChannelClaim(state); if (!activeChannelClaim) { console.error('Unable to create comment. No activeChannel is set.'); // eslint-disable-line return; } dispatch({ type: ACTIONS.COMMENT_CREATE_STARTED, }); if (parent_id) { const notification = makeSelectNotificationForCommentId(parent_id)(state); if (notification && !notification.is_seen) { dispatch(doSeeNotifications([notification.id])); } } return Lbry.comment_create({ comment: comment, claim_id: claim_id, channel_id: activeChannelClaim.claim_id, parent_id: parent_id, }) .then((result: CommentCreateResponse) => { dispatch({ type: ACTIONS.COMMENT_CREATE_COMPLETED, data: { uri, comment: result, claimId: claim_id, }, }); return result; }) .catch((error) => { dispatch({ type: ACTIONS.COMMENT_CREATE_FAILED, data: error, }); let toastMessage = __('Unable to create comment, please try again later.'); if (error && error.message === 'channel is blocked by publisher') { toastMessage = __('Unable to comment. This channel has blocked you.'); } dispatch( doToast({ message: toastMessage, isError: true, }) ); }); }; } export function doCommentPin(commentId: string, remove: boolean) { return (dispatch: Dispatch, getState: GetState) => { const state = getState(); const activeChannel = selectActiveChannelClaim(state); if (!activeChannel) { console.error('Unable to pin comment. No activeChannel is set.'); // eslint-disable-line return; } dispatch({ type: ACTIONS.COMMENT_PIN_STARTED, }); return Lbry.comment_pin({ comment_id: commentId, channel_name: activeChannel.name, channel_id: activeChannel.claim_id, ...(remove ? { remove: true } : {}), }) .then((result: CommentPinResponse) => { dispatch({ type: ACTIONS.COMMENT_PIN_COMPLETED, data: result, }); }) .catch((error) => { dispatch({ type: ACTIONS.COMMENT_PIN_FAILED, data: error, }); dispatch( doToast({ message: 'Unable to pin this comment, please try again later.', isError: true, }) ); }); }; } export function doCommentAbandon(commentId: string, creatorChannelUri?: string) { return async (dispatch: Dispatch, getState: GetState) => { const state = getState(); const claim = creatorChannelUri ? selectClaimsByUri(state)[creatorChannelUri] : undefined; const creatorChannelId = claim ? claim.claim_id : null; const creatorChannelName = claim ? claim.name : null; const activeChannelClaim = selectActiveChannelClaim(state); dispatch({ type: ACTIONS.COMMENT_ABANDON_STARTED, }); let commentIdSignature; if (activeChannelClaim) { try { commentIdSignature = await Lbry.channel_sign({ channel_id: activeChannelClaim.claim_id, hexdata: toHex(commentId), }); } catch (e) {} } return Comments.comment_abandon({ comment_id: commentId, ...(creatorChannelId ? { creator_channel_id: creatorChannelId } : {}), ...(creatorChannelName ? { creator_channel_name: creatorChannelName } : {}), ...(commentIdSignature || {}), }) .then((result: CommentAbandonResponse) => { // Comment may not be deleted if the signing channel can't be signed. // This will happen if the channel was recently created or abandoned. if (result.abandoned) { dispatch({ type: ACTIONS.COMMENT_ABANDON_COMPLETED, data: { comment_id: commentId, }, }); } else { dispatch({ type: ACTIONS.COMMENT_ABANDON_FAILED, }); dispatch( doToast({ message: 'Your channel is still being setup, try again in a few moments.', isError: true, }) ); } }) .catch((error) => { dispatch({ type: ACTIONS.COMMENT_ABANDON_FAILED, data: error, }); dispatch( doToast({ message: 'Unable to delete this comment, please try again later.', isError: true, }) ); }); }; } export function doCommentUpdate(comment_id: string, comment: string) { // if they provided an empty string, they must have wanted to abandon if (comment === '') { return doCommentAbandon(comment_id); } else { return (dispatch: Dispatch) => { dispatch({ type: ACTIONS.COMMENT_UPDATE_STARTED, }); return Lbry.comment_update({ comment_id: comment_id, comment: comment, }) .then((result: CommentUpdateResponse) => { if (result != null) { dispatch({ type: ACTIONS.COMMENT_UPDATE_COMPLETED, data: { comment: result, }, }); } else { // the result will return null dispatch({ type: ACTIONS.COMMENT_UPDATE_FAILED, }); dispatch( doToast({ message: 'Your channel is still being setup, try again in a few moments.', isError: true, }) ); } }) .catch((error) => { dispatch({ type: ACTIONS.COMMENT_UPDATE_FAILED, data: error, }); dispatch( doToast({ message: 'Unable to edit this comment, please try again later.', isError: true, }) ); }); }; } } // Hides a users comments from all creator's claims and prevent them from commenting in the future export function doCommentModToggleBlock(channelUri: string, unblock: boolean = false) { return async (dispatch: Dispatch, getState: GetState) => { const state = getState(); const myChannels = selectMyChannelClaims(state); const claim = selectClaimsByUri(state)[channelUri]; if (!claim) { console.error("Can't find claim to block"); // eslint-disable-line return; } dispatch({ type: unblock ? ACTIONS.COMMENT_MODERATION_UN_BLOCK_STARTED : ACTIONS.COMMENT_MODERATION_BLOCK_STARTED, data: { uri: channelUri, }, }); const creatorIdForAction = claim ? claim.claim_id : null; const creatorNameForAction = claim ? claim.name : null; let channelSignatures = []; if (myChannels) { for (const channelClaim of myChannels) { try { const channelSignature = await Lbry.channel_sign({ channel_id: channelClaim.claim_id, hexdata: toHex(channelClaim.name), }); channelSignatures.push({ ...channelSignature, claim_id: channelClaim.claim_id, name: channelClaim.name }); } catch (e) {} } } const sharedModBlockParams = unblock ? { un_blocked_channel_id: creatorIdForAction, un_blocked_channel_name: creatorNameForAction, } : { blocked_channel_id: creatorIdForAction, blocked_channel_name: creatorNameForAction, }; const commentAction = unblock ? Comments.moderation_unblock : Comments.moderation_block; return Promise.all( channelSignatures.map((signatureData) => commentAction({ mod_channel_id: signatureData.claim_id, mod_channel_name: signatureData.name, signature: signatureData.signature, signing_ts: signatureData.signing_ts, ...sharedModBlockParams, }) ) ) .then(() => { dispatch({ type: unblock ? ACTIONS.COMMENT_MODERATION_UN_BLOCK_COMPLETE : ACTIONS.COMMENT_MODERATION_BLOCK_COMPLETE, data: { channelUri }, }); if (!unblock) { dispatch(doToast({ message: __('Channel blocked. You will not see them again.') })); } }) .catch(() => { dispatch({ type: unblock ? ACTIONS.COMMENT_MODERATION_UN_BLOCK_FAILED : ACTIONS.COMMENT_MODERATION_BLOCK_FAILED, }); }); }; } export function doCommentModBlock(commentAuthor: string) { return (dispatch: Dispatch) => { return dispatch(doCommentModToggleBlock(commentAuthor)); }; } export function doCommentModUnBlock(commentAuthor: string) { return (dispatch: Dispatch) => { return dispatch(doCommentModToggleBlock(commentAuthor, true)); }; } export function doFetchModBlockedList() { return async (dispatch: Dispatch, getState: GetState) => { const state = getState(); const myChannels = selectMyChannelClaims(state); dispatch({ type: ACTIONS.COMMENT_MODERATION_BLOCK_LIST_STARTED, }); let channelSignatures = []; if (myChannels) { for (const channelClaim of myChannels) { try { const channelSignature = await Lbry.channel_sign({ channel_id: channelClaim.claim_id, hexdata: toHex(channelClaim.name), }); channelSignatures.push({ ...channelSignature, claim_id: channelClaim.claim_id, name: channelClaim.name }); } catch (e) {} } } return Promise.all( channelSignatures.map((signatureData) => Comments.moderation_block_list({ mod_channel_id: signatureData.claim_id, mod_channel_name: signatureData.name, signature: signatureData.signature, signing_ts: signatureData.signing_ts, }) ) ) .then((blockLists) => { let globalBlockList = []; blockLists .sort((a, b) => { return 1; }) .forEach((channelBlockListData) => { const blockListForChannel = channelBlockListData && channelBlockListData.blocked_channels; if (blockListForChannel) { blockListForChannel.forEach((blockedChannel) => { // REMOVE THIS if (blockedChannel.blocked_channel_name) { const channelUri = buildURI({ channelName: blockedChannel.blocked_channel_name, claimId: blockedChannel.blocked_channel_id, }); if (!globalBlockList.find((blockedChannel) => blockedChannel.channelUri === channelUri)) { globalBlockList.push({ channelUri, blockedAt: blockedChannel.blocked_at }); } } }); } }); dispatch({ type: ACTIONS.COMMENT_MODERATION_BLOCK_LIST_COMPLETED, data: { blockList: globalBlockList .sort((a, b) => new Date(a.blockedAt) - new Date(b.blockedAt)) .map((blockedChannel) => blockedChannel.channelUri), }, }); }) .catch((err) => { dispatch({ type: ACTIONS.COMMENT_MODERATION_BLOCK_LIST_FAILED, }); }); }; } export const doUpdateBlockListForPublishedChannel = (channelClaim: ChannelClaim) => { return async (dispatch: Dispatch, getState: GetState) => { const state = getState(); const blockedUris = selectModerationBlockList(state); let channelSignature: ?{ signature: string, signing_ts: string, }; try { channelSignature = await Lbry.channel_sign({ channel_id: channelClaim.claim_id, hexdata: toHex(channelClaim.name), }); } catch (e) {} if (!channelSignature) { return; } return Promise.all( blockedUris.map((uri) => { const { channelName, channelClaimId } = parseURI(uri); return Comments.moderation_block({ mod_channel_id: channelClaim.claim_id, mod_channel_name: channelClaim.name, // $FlowFixMe signature: channelSignature.signature, // $FlowFixMe signing_ts: channelSignature.signing_ts, blocked_channel_id: channelClaimId, blocked_channel_name: channelName, }); }) ); }; };