Merge pull request #331 from lbryio/revert

flow-typed/Blocklist.js

@@ -0,0 +1,10 @@
+declare type BlocklistState = {
+  blockedChannels: Array<string>
+};
+
+declare type BlocklistAction = {
+  type: string,
+  data: {
+    uri: string,
+  },
+};

flow-typed/Comment.js

@@ -0,0 +1,23 @@
+declare type Comment = {
+  comment: string, // comment body
+  comment_id: string, // sha256 digest
+  claim_id: string, // id linking to the claim this comment
+  timestamp: number, // integer representing unix-time
+  is_hidden: boolean, // claim owner may enable/disable this
+  channel_id?: string,  // claimId of channel signing this comment
+  channel_name?: string,  // name of channel claim
+  channel_url?: string, // full lbry url to signing channel
+  signature?: string, // signature of comment by originating channel
+  signing_ts?: string, // timestamp used when signing this comment
+  is_channel_signature_valid?: boolean, // whether or not the signature could be validated
+  parent_id?: number, // comment_id of comment this is in reply to
+};
+
+// todo: relate individual comments to their commentId
+declare type CommentsState = {
+  commentsByUri: { [string]: string },
+  byId: { [string]: Array<string> },
+  commentById: { [string]: Comment },
+  isLoading: boolean,
+  myComments: ?Set<string>,
+};

src/constants/action_types.js

@@ -131,6 +131,23 @@ export const PURCHASE_LIST_STARTED = 'PURCHASE_LIST_STARTED';
 export const PURCHASE_LIST_COMPLETED = 'PURCHASE_LIST_COMPLETED';
 export const PURCHASE_LIST_FAILED = 'PURCHASE_LIST_FAILED';
 
+// Comments
+export const COMMENT_LIST_STARTED = 'COMMENT_LIST_STARTED';
+export const COMMENT_LIST_COMPLETED = 'COMMENT_LIST_COMPLETED';
+export const COMMENT_LIST_FAILED = 'COMMENT_LIST_FAILED';
+export const COMMENT_CREATE_STARTED = 'COMMENT_CREATE_STARTED';
+export const COMMENT_CREATE_COMPLETED = 'COMMENT_CREATE_COMPLETED';
+export const COMMENT_CREATE_FAILED = 'COMMENT_CREATE_FAILED';
+export const COMMENT_ABANDON_STARTED = 'COMMENT_ABANDON_STARTED';
+export const COMMENT_ABANDON_COMPLETED = 'COMMENT_ABANDON_COMPLETED';
+export const COMMENT_ABANDON_FAILED = 'COMMENT_ABANDON_FAILED';
+export const COMMENT_UPDATE_STARTED = 'COMMENT_UPDATE_STARTED';
+export const COMMENT_UPDATE_COMPLETED = 'COMMENT_UPDATE_COMPLETED';
+export const COMMENT_UPDATE_FAILED = 'COMMENT_UPDATE_FAILED';
+export const COMMENT_HIDE_STARTED = 'COMMENT_HIDE_STARTED';
+export const COMMENT_HIDE_COMPLETED = 'COMMENT_HIDE_COMPLETED';
+export const COMMENT_HIDE_FAILED = 'COMMENT_HIDE_FAILED';
+
 // Files
 export const FILE_LIST_STARTED = 'FILE_LIST_STARTED';
 export const FILE_LIST_SUCCEEDED = 'FILE_LIST_SUCCEEDED';
@@ -266,5 +283,8 @@ export const TOGGLE_TAG_FOLLOW = 'TOGGLE_TAG_FOLLOW';
 export const TAG_ADD = 'TAG_ADD';
 export const TAG_DELETE = 'TAG_DELETE';
 
+// Blocked Channels
+export const TOGGLE_BLOCK_CHANNEL = 'TOGGLE_BLOCK_CHANNEL';
+
 // Sync
 export const USER_STATE_POPULATE = 'USER_STATE_POPULATE';

src/index.js

@@ -135,6 +135,16 @@ export {
 
 export { doToggleTagFollow, doAddTag, doDeleteTag } from 'redux/actions/tags';
 
+export {
+  doCommentList,
+  doCommentCreate,
+  doCommentAbandon,
+  doCommentHide,
+  doCommentUpdate,
+} from 'redux/actions/comments';
+
+export { doToggleBlockChannel } from 'redux/actions/blocked';
+
 export { doPopulateSharedUserState, doPreferenceGet, doPreferenceSet } from 'redux/actions/sync';
 
 // utils
@@ -145,12 +155,14 @@ export { isClaimNsfw, createNormalizedClaimSearchKey } from 'util/claim';
 
 // reducers
 export { claimsReducer } from 'redux/reducers/claims';
+export { commentReducer } from 'redux/reducers/comments';
 export { contentReducer } from 'redux/reducers/content';
 export { fileInfoReducer } from 'redux/reducers/file_info';
 export { notificationsReducer } from 'redux/reducers/notifications';
 export { publishReducer } from 'redux/reducers/publish';
 export { searchReducer } from 'redux/reducers/search';
 export { tagsReducer } from 'redux/reducers/tags';
+export { blockedReducer } from 'redux/reducers/blocked';
 export { walletReducer } from 'redux/reducers/wallet';
 
 // selectors
@@ -240,6 +252,8 @@ export {
   selectPurchaseUriSuccess,
 } from 'redux/selectors/claims';
 
+export { makeSelectCommentsForUri, selectIsFetchingComments } from 'redux/selectors/comments';
+
 export {
   makeSelectFileInfoForUri,
   makeSelectDownloadingForUri,
@@ -347,3 +361,9 @@ export {
   selectUnfollowedTags,
   makeSelectIsFollowingTag,
 } from 'redux/selectors/tags';
+
+export {
+  selectBlockedChannels,
+  selectChannelIsBlocked,
+  selectBlockedChannelsCount,
+} from 'redux/selectors/blocked';

src/redux/actions/blocked.js

@@ -0,0 +1,9 @@
+// @flow
+import * as ACTIONS from 'constants/action_types';
+
+export const doToggleBlockChannel = (uri: string) => ({
+  type: ACTIONS.TOGGLE_BLOCK_CHANNEL,
+  data: {
+    uri,
+  },
+});

src/redux/actions/comments.js

@@ -0,0 +1,225 @@
+// @flow
+import * as ACTIONS from 'constants/action_types';
+import Lbry from 'lbry';
+import { selectClaimsByUri, selectMyChannelClaims } from 'redux/selectors/claims';
+import { doToast } from 'redux/actions/notifications';
+
+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;
+
+    dispatch({
+      type: ACTIONS.COMMENT_LIST_STARTED,
+    });
+    Lbry.comment_list({
+      claim_id: claimId,
+      page,
+      page_size: pageSize,
+    })
+      .then((result: CommentListResponse) => {
+        const { items: comments } = result;
+        dispatch({
+          type: ACTIONS.COMMENT_LIST_COMPLETED,
+          data: {
+            comments,
+            claimId: claimId,
+            uri: uri,
+          },
+        });
+      })
+      .catch(error => {
+        console.log(error);
+        dispatch({
+          type: ACTIONS.COMMENT_LIST_FAILED,
+          data: error,
+        });
+      });
+  };
+}
+
+export function doCommentCreate(
+  comment: string = '',
+  claim_id: string = '',
+  channel: string,
+  parent_id?: string
+) {
+  return (dispatch: Dispatch, getState: GetState) => {
+    const state = getState();
+    dispatch({
+      type: ACTIONS.COMMENT_CREATE_STARTED,
+    });
+
+    const myChannels = selectMyChannelClaims(state);
+    const namedChannelClaim =
+      myChannels && myChannels.find(myChannel => myChannel.name === channel);
+    const channel_id = namedChannelClaim.claim_id;
+
+    if (channel_id == null) {
+      dispatch({
+        type: ACTIONS.COMMENT_CREATE_FAILED,
+        data: {},
+      });
+      dispatch(
+        doToast({
+          message: 'Channel cannot be anonymous, please select a channel and try again.',
+          isError: true,
+        })
+      );
+      return;
+    }
+
+    return Lbry.comment_create({
+      comment: comment,
+      claim_id: claim_id,
+      channel_id: channel_id,
+      parent_id: parent_id,
+    })
+      .then((result: CommentCreateResponse) => {
+        dispatch({
+          type: ACTIONS.COMMENT_CREATE_COMPLETED,
+          data: {
+            comment: result,
+            claimId: claim_id,
+          },
+        });
+      })
+      .catch(error => {
+        dispatch({
+          type: ACTIONS.COMMENT_CREATE_FAILED,
+          data: error,
+        });
+        dispatch(
+          doToast({
+            message: 'Unable to create comment, please try again later.',
+            isError: true,
+          })
+        );
+      });
+  };
+}
+
+export function doCommentHide(comment_id: string) {
+  return (dispatch: Dispatch) => {
+    dispatch({
+      type: ACTIONS.COMMENT_HIDE_STARTED,
+    });
+    return Lbry.comment_hide({
+      comment_ids: [comment_id],
+    })
+      .then((result: CommentHideResponse) => {
+        dispatch({
+          type: ACTIONS.COMMENT_HIDE_COMPLETED,
+          data: result,
+        });
+      })
+      .catch(error => {
+        dispatch({
+          type: ACTIONS.COMMENT_HIDE_FAILED,
+          data: error,
+        });
+        dispatch(
+          doToast({
+            message: 'Unable to hide this comment, please try again later.',
+            isError: true,
+          })
+        );
+      });
+  };
+}
+
+export function doCommentAbandon(comment_id: string) {
+  return (dispatch: Dispatch) => {
+    dispatch({
+      type: ACTIONS.COMMENT_ABANDON_STARTED,
+    });
+    return Lbry.comment_abandon({
+      comment_id: comment_id,
+    })
+      .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: comment_id,
+            },
+          });
+        } 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,
+            })
+          );
+        });
+    };
+  }
+}

src/redux/reducers/blocked.js

@@ -0,0 +1,41 @@
+// @flow
+import * as ACTIONS from 'constants/action_types';
+import { handleActions } from 'util/redux-utils';
+
+const defaultState: BlocklistState = {
+  blockedChannels: [],
+};
+
+export const blockedReducer = handleActions(
+  {
+    [ACTIONS.TOGGLE_BLOCK_CHANNEL]: (
+      state: BlocklistState,
+      action: BlocklistAction
+    ): BlocklistState => {
+      const { blockedChannels } = state;
+      const { uri } = action.data;
+      let newBlockedChannels = blockedChannels.slice();
+
+      if (newBlockedChannels.includes(uri)) {
+        newBlockedChannels = newBlockedChannels.filter(id => id !== uri);
+      } else {
+        newBlockedChannels.push(uri);
+      }
+
+      return {
+        blockedChannels: newBlockedChannels,
+      };
+    },
+    [ACTIONS.USER_STATE_POPULATE]: (
+      state: BlocklistState,
+      action: { data: { blocked: ?Array<string> } }
+    ) => {
+      const { blocked } = action.data;
+      return {
+        ...state,
+        blockedChannels: blocked && blocked.length ? blocked : state.blockedChannels,
+      };
+    },
+  },
+  defaultState
+);

src/redux/reducers/comments.js

@@ -0,0 +1,153 @@
+// @flow
+import * as ACTIONS from 'constants/action_types';
+import { handleActions } from 'util/redux-utils';
+
+const defaultState: CommentsState = {
+  commentById: {}, // commentId -> Comment
+  byId: {}, // ClaimID -> list of comments
+  commentsByUri: {}, // URI -> claimId
+  isLoading: false,
+  myComments: undefined,
+};
+
+export const commentReducer = handleActions(
+  {
+    [ACTIONS.COMMENT_CREATE_STARTED]: (state: CommentsState, action: any): CommentsState => ({
+      ...state,
+      isLoading: true,
+    }),
+
+    [ACTIONS.COMMENT_CREATE_FAILED]: (state: CommentsState, action: any) => ({
+      ...state,
+      isLoading: false,
+    }),
+
+    [ACTIONS.COMMENT_CREATE_COMPLETED]: (state: CommentsState, action: any): CommentsState => {
+      const { comment, claimId }: { comment: Comment, claimId: string } = action.data;
+      const commentById = Object.assign({}, state.commentById);
+      const byId = Object.assign({}, state.byId);
+      const comments = byId[claimId];
+      const newCommentIds = comments.slice();
+
+      // add the comment by its ID
+      commentById[comment.comment_id] = comment;
+
+      // push the comment_id to the top of ID list
+      newCommentIds.unshift(comment.comment_id);
+      byId[claimId] = newCommentIds;
+
+      return {
+        ...state,
+        commentById,
+        byId,
+        isLoading: false,
+      };
+    },
+
+    [ACTIONS.COMMENT_LIST_STARTED]: state => ({ ...state, isLoading: true }),
+
+    [ACTIONS.COMMENT_LIST_COMPLETED]: (state: CommentsState, action: any) => {
+      const { comments, claimId, uri } = action.data;
+
+      const commentById = Object.assign({}, state.commentById);
+      const byId = Object.assign({}, state.byId);
+      const commentsByUri = Object.assign({}, state.commentsByUri);
+
+      if (comments) {
+        // we use an Array to preserve order of listing
+        // in reality this doesn't matter and we can just
+        // sort comments by their timestamp
+        const commentIds = Array(comments.length);
+
+        // map the comment_ids to the new comments
+        for (let i = 0; i < comments.length; i++) {
+          commentIds[i] = comments[i].comment_id;
+          commentById[commentIds[i]] = comments[i];
+        }
+
+        byId[claimId] = commentIds;
+        commentsByUri[uri] = claimId;
+      }
+      return {
+        ...state,
+        byId,
+        commentById,
+        commentsByUri,
+        isLoading: false,
+      };
+    },
+
+    [ACTIONS.COMMENT_LIST_FAILED]: (state: CommentsState, action: any) => ({
+      ...state,
+      isLoading: false,
+    }),
+    [ACTIONS.COMMENT_ABANDON_STARTED]: (state: CommentsState, action: any) => ({
+      ...state,
+      isLoading: true,
+    }),
+    [ACTIONS.COMMENT_ABANDON_COMPLETED]: (state: CommentsState, action: any) => {
+      const { comment_id } = action.data;
+      const commentById = Object.assign({}, state.commentById);
+      const byId = Object.assign({}, state.byId);
+
+      // to remove the comment and its references
+      const claimId = commentById[comment_id].claim_id;
+      for (let i = 0; i < byId[claimId].length; i++) {
+        if (byId[claimId][i] === comment_id) {
+          byId[claimId].splice(i, 1);
+          break;
+        }
+      }
+      delete commentById[comment_id];
+
+      return {
+        ...state,
+        commentById,
+        byId,
+        isLoading: false,
+      };
+    },
+    // do nothing
+    [ACTIONS.COMMENT_ABANDON_FAILED]: (state: CommentsState, action: any) => ({
+      ...state,
+      isLoading: false,
+    }),
+    // do nothing
+    [ACTIONS.COMMENT_UPDATE_STARTED]: (state: CommentsState, action: any) => ({
+      ...state,
+      isLoading: true,
+    }),
+    // replace existing comment with comment returned here under its comment_id
+    [ACTIONS.COMMENT_UPDATE_COMPLETED]: (state: CommentsState, action: any) => {
+      const { comment } = action.data;
+      const commentById = Object.assign({}, state.commentById);
+      commentById[comment.comment_id] = comment;
+
+      return {
+        ...state,
+        commentById,
+        isLoading: false,
+      };
+    },
+    // nothing can be done here
+    [ACTIONS.COMMENT_UPDATE_FAILED]: (state: CommentsState, action: any) => ({
+      ...state,
+      isLoading: false,
+    }),
+    // nothing can really be done here
+    [ACTIONS.COMMENT_HIDE_STARTED]: (state: CommentsState, action: any) => ({
+      ...state,
+      isLoading: true,
+    }),
+    [ACTIONS.COMMENT_HIDE_COMPLETED]: (state: CommentsState, action: any) => ({
+      ...state, // todo: add HiddenComments state & create selectors
+      isLoading: false,
+    }),
+    // nothing can be done here
+    [ACTIONS.COMMENT_HIDE_FAILED]: (state: CommentsState, action: any) => ({
+      ...state,
+      isLoading: false,
+    }),
+  },
+  defaultState
+);

src/redux/selectors/blocked.js

@@ -0,0 +1,22 @@
+// @flow
+import { createSelector } from 'reselect';
+
+const selectState = (state: { blocked: BlocklistState }) => state.blocked || {};
+
+export const selectBlockedChannels = createSelector(
+  selectState,
+  (state: BlocklistState) => state.blockedChannels
+);
+
+export const selectBlockedChannelsCount = createSelector(
+  selectBlockedChannels,
+  (state: Array<string>) => state.length
+);
+
+export const selectChannelIsBlocked = (uri: string) =>
+  createSelector(
+    selectBlockedChannels,
+    (state: Array<string>) => {
+      return state.includes(uri);
+    }
+  );

src/redux/selectors/comments.js

@@ -0,0 +1,71 @@
+// @flow
+import { createSelector } from 'reselect';
+
+const selectState = state => state.comments || {};
+
+export const selectCommentsById = createSelector(
+  selectState,
+  state => state.commentById || {}
+);
+
+export const selectIsFetchingComments = createSelector(
+  selectState,
+  state => state.isLoading
+);
+
+export const selectCommentsByClaimId = createSelector(
+  selectState,
+  selectCommentsById,
+  (state, byId) => {
+    const byClaimId = state.byId || {};
+    const comments = {};
+
+    // replace every comment_id in the list with the actual comment object
+    Object.keys(byClaimId).forEach(claimId => {
+      const commentIds = byClaimId[claimId];
+
+      comments[claimId] = Array(commentIds === null ? 0 : commentIds.length);
+      for (let i = 0; i < commentIds.length; i++) {
+        comments[claimId][i] = byId[commentIds[i]];
+      }
+    });
+
+    return comments;
+  }
+);
+
+// previously this used a mapping from claimId -> Array<Comments>
+/* export const selectCommentsById = createSelector(
+  selectState,
+  state => state.byId || {}
+); */
+export const selectCommentsByUri = createSelector(
+  selectState,
+  state => {
+    const byUri = state.commentsByUri || {};
+    const comments = {};
+    Object.keys(byUri).forEach(uri => {
+      const claimId = byUri[uri];
+      if (claimId === null) {
+        comments[uri] = null;
+      } else {
+        comments[uri] = claimId;
+      }
+    });
+
+    return comments;
+  }
+);
+
+export const makeSelectCommentsForUri = (uri: string) =>
+  createSelector(
+    selectCommentsByClaimId,
+    selectCommentsByUri,
+    (byClaimId, byUri) => {
+      const claimId = byUri[uri];
+      return byClaimId && byClaimId[claimId];
+    }
+  );
+
+// todo: allow SDK to retrieve user comments through comment_list
+// todo: implement selectors for selecting comments owned by user