Progress on dms, code cleanup

Progress on dms, code cleanup

app/javascript/gabsocial/reducers/chat_compose.js

@@ -1,43 +0,0 @@
-import {
-  MESSAGE_INPUT_CHANGE,
-  MESSAGE_INPUT_RESET,
-  MESSAGE_SEND_REQUEST,
-  MESSAGE_SEND_SUCCESS,
-  MESSAGE_SEND_FAIL,
-  MESSAGE_DELETE_REQUEST,
-  MESSAGE_DELETE_SUCCESS,
-  MESSAGE_DELETE_FAIL,
-} from '../actions/lists'
-import { Map as ImmutableMap, fromJS } from 'immutable'
-
-const initialState = ImmutableMap({
-  text: '',
-  conversationId: null,
-  idempotencyKey: null,
-})
-
-const normalizeList = (state, list) => state.set(list.id, fromJS(list))
-
-const normalizeLists = (state, lists) => {
-  lists.forEach(list => {
-    state = normalizeList(state, list)
-  })
-
-  return state
-}
-
-export default function lists(state = initialState, action) {
-  switch(action.type) {
-  case LIST_FETCH_SUCCESS:
-  case LIST_CREATE_SUCCESS:
-  case LIST_UPDATE_SUCCESS:
-    return normalizeList(state, action.list);
-  case LISTS_FETCH_SUCCESS:
-    return normalizeLists(state, action.lists);
-  case LIST_DELETE_SUCCESS:
-  case LIST_FETCH_FAIL:
-    return state.set(action.id, false);
-  default:
-    return state;
-  }
-}

app/javascript/gabsocial/reducers/chat_conversation_lists.js

@@ -0,0 +1,85 @@
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable'
+import {
+  CHAT_CONVERSATIONS_APPROVED_FETCH_REQUEST,
+  CHAT_CONVERSATIONS_APPROVED_FETCH_SUCCESS,
+  CHAT_CONVERSATIONS_APPROVED_FETCH_FAIL,
+  CHAT_CONVERSATIONS_APPROVED_EXPAND_REQUEST,
+  CHAT_CONVERSATIONS_APPROVED_EXPAND_SUCCESS,
+  CHAT_CONVERSATIONS_APPROVED_EXPAND_FAIL,
+
+  CHAT_CONVERSATIONS_REQUESTED_FETCH_REQUEST,
+  CHAT_CONVERSATIONS_REQUESTED_FETCH_SUCCESS,
+  CHAT_CONVERSATIONS_REQUESTED_FETCH_FAIL,
+  CHAT_CONVERSATIONS_REQUESTED_EXPAND_REQUEST,
+  CHAT_CONVERSATIONS_REQUESTED_EXPAND_SUCCESS,
+  CHAT_CONVERSATIONS_REQUESTED_EXPAND_FAIL,
+
+  CHAT_CONVERSATION_REQUEST_APPROVE_SUCCESS,
+} from '../actions/chat_conversations'
+
+const initialState = ImmutableMap({
+  approved: ImmutableMap({
+    next: null,
+    isLoading: false,
+    items: ImmutableList(),
+  }),
+  requested: ImmutableMap({
+    next: null,
+    isLoading: false,
+    items: ImmutableList(),
+  }),
+})
+
+const normalizeList = (state, source, chatConversations, next) => {
+  return state.update(source, listMap => listMap.withMutations(map => {
+    map.set('next', next)
+    map.set('loaded', true)
+    map.set('isLoading', false)
+    map.set('items', ImmutableList(chatConversations.map(chatConversation => chatConversation.chat_conversation_id)))
+  }))
+}
+
+const appendToList = (state, source, chatConversations, next) => {
+  return state.update(source, listMap => listMap.withMutations(map => {
+    map.set('next', next)
+    map.set('isLoading', false)
+    map.set('items', map.get('items').concat(chatConversations.map(chatConversation => chatConversation.chat_conversation_id)))
+  }))
+}
+
+const removeOneFromList = (state, source, chatConversationId) => {
+  return state.update(source, listMap => listMap.withMutations(map => {
+    map.set('items', map.get('items').filter(id => id !== chatConversationId))
+  }))
+}
+
+export default function chat_conversation_lists(state = initialState, action) {
+  switch (action.type) {
+  case CHAT_CONVERSATIONS_APPROVED_FETCH_REQUEST:
+  case CHAT_CONVERSATIONS_APPROVED_EXPAND_REQUEST:
+    return state.setIn(['approved', 'isLoading'], true)
+  case CHAT_CONVERSATIONS_APPROVED_FETCH_FAIL:
+  case CHAT_CONVERSATIONS_APPROVED_EXPAND_FAIL:
+    return state.setIn(['approved', 'isLoading'], false)
+  case CHAT_CONVERSATIONS_APPROVED_FETCH_SUCCESS:
+    return normalizeList(state, 'approved', action.chatConversations, action.next)
+  case CHAT_CONVERSATIONS_APPROVED_EXPAND_SUCCESS:
+    return appendToList(state, 'approved', action.chatConversations, action.next)
+  
+  case CHAT_CONVERSATIONS_REQUESTED_FETCH_REQUEST:
+  case CHAT_CONVERSATIONS_REQUESTED_EXPAND_REQUEST:
+    return state.setIn(['requested', 'isLoading'], true)
+  case CHAT_CONVERSATIONS_REQUESTED_FETCH_FAIL:
+  case CHAT_CONVERSATIONS_REQUESTED_EXPAND_FAIL:
+    return state.setIn(['requested', 'isLoading'], false)
+  case CHAT_CONVERSATIONS_REQUESTED_FETCH_SUCCESS:
+    return normalizeList(state, 'requested', action.chatConversations, action.next) 
+  case CHAT_CONVERSATIONS_REQUESTED_EXPAND_SUCCESS:
+    return appendToList(state, 'requested', action.chatConversations, action.next)
+
+  case CHAT_CONVERSATION_REQUEST_APPROVE_SUCCESS:
+    return removeOneFromList(state, 'requested', action.chatConversation.chat_conversation_id)
+  default:
+    return state
+  }
+}

app/javascript/gabsocial/reducers/chat_conversation_messages.js

@@ -0,0 +1,105 @@
+import {
+  List as ImmutableList,
+  Map as ImmutableMap,
+  fromJS,
+} from 'immutable'
+import compareId from '../utils/compare_id'
+import {
+  CHAT_MESSAGES_SEND_SUCCESS,
+  CHAT_MESSAGES_DELETE_REQUEST,
+} from '../actions/chat_messages'
+import {
+  CHAT_CONVERSATION_MESSAGES_EXPAND_REQUEST,
+  CHAT_CONVERSATION_MESSAGES_EXPAND_SUCCESS,
+  CHAT_CONVERSATION_MESSAGES_EXPAND_FAIL,
+  CHAT_CONVERSATION_MESSAGES_CONNECT,
+  CHAT_CONVERSATION_MESSAGES_DISCONNECT,
+  CHAT_CONVERSATION_MESSAGES_CLEAR,
+} from '../actions/chat_conversation_messages'
+
+const initialState = ImmutableMap()
+
+const initialConversation = ImmutableMap({
+  unread: 0,
+  online: false,
+  top: true,
+  isLoading: false,
+  isError: false,
+  hasMore: true,
+  items: ImmutableList(),
+})
+
+const expandNormalizedChatConversation = (state, chatConversationId, chatMessages, next, isPartial, isLoadingRecent) => {
+  return state.update(chatConversationId, initialConversation, map => map.withMutations((mMap) => {
+    mMap.set('isLoading', false)
+    mMap.set('isPartial', isPartial)
+
+    if (!next && !isLoadingRecent) mMap.set('hasMore', false)
+
+    if (!!chatMessages && !chatMessages.isEmpty()) {
+      mMap.update('items', ImmutableList(), oldIds => {
+        const newIds = chatMessages.map(chatMessage => chatMessage.get('id'));
+
+        const lastIndex = oldIds.findLastIndex((id) => id !== null && compareId(id, newIds.last()) >= 0) + 1;
+        const firstIndex = oldIds.take(lastIndex).findLastIndex(id => id !== null && compareId(id, newIds.first()) > 0);
+
+        if (firstIndex < 0) {
+          return (isPartial ? newIds.unshift(null) : newIds).concat(oldIds.skip(lastIndex));
+        }
+
+        return oldIds.take(firstIndex + 1).concat(
+          isPartial && oldIds.get(firstIndex) !== null ? newIds.unshift(null) : newIds,
+          oldIds.skip(lastIndex)
+        );
+      });
+    }
+  }));
+};
+
+const updateChatMessageConversation = (state, chatConversationId, chatMessage) => {
+  const top        = state.getIn([chatConversationId, 'top']);
+  const ids        = state.getIn([chatConversationId, 'items'], ImmutableList());
+  const includesId = ids.includes(chatMessage.get('id'));
+  const unread     = state.getIn([chatConversationId, 'unread'], 0);
+
+  if (includesId) {
+    return state;
+  }
+
+  let newIds = ids;
+
+  return state.update(chatConversationId, initialConversation, map => map.withMutations(mMap => {
+    if (!top) mMap.set('unread', unread + 1);
+    // if (top && ids.size > 40) newIds = newIds.take(20);
+    mMap.set('items', newIds.unshift(chatMessage.get('id')));
+  }));
+};
+
+export default function chat_conversation_messages(state = initialState, action) {
+  switch (action.type) {
+  case CHAT_CONVERSATION_MESSAGES_CONNECT:
+    return state.update(action.chatConversationId, initialConversation, map => map.set('online', true))
+  case CHAT_CONVERSATION_MESSAGES_DISCONNECT:
+    return state.update(
+      action.chatConversationId,
+      initialConversation,
+      map => map.set('online', false).update('items', items => items.first() ? items.unshift(null) : items)
+    )
+  case CHAT_CONVERSATION_MESSAGES_CLEAR:
+    return state.set(chatConversationId, initialTimeline)
+  case CHAT_CONVERSATION_MESSAGES_EXPAND_REQUEST:
+    return state.update(action.chatConversationId, initialConversation, map => map.set('isLoading', true))
+  case CHAT_CONVERSATION_MESSAGES_EXPAND_FAIL:
+    return state.update(action.chatConversationId, initialConversation, map => map.withMutations((mMap) => {
+      map.set('isLoading', false)
+      map.set('isError', true)
+    }))
+  case CHAT_CONVERSATION_MESSAGES_EXPAND_SUCCESS:
+    return expandNormalizedChatConversation(state, action.chatConversationId, fromJS(action.chatMessages), action.next, action.partial, action.isLoadingRecent)
+  case CHAT_MESSAGES_SEND_SUCCESS:
+    return updateChatMessageConversation(state, action.chatConversationId, fromJS(action.chatMessage))
+  // CHAT_MESSAGES_DELETE_REQUEST
+  default:
+    return state
+  }
+}

app/javascript/gabsocial/reducers/chat_conversations.js

@@ -0,0 +1,43 @@
+import {
+  Map as ImmutableMap,
+  List as ImmutableList,
+  fromJS,
+} from 'immutable'
+import { me } from '../initial_state'
+import { 
+  CHAT_CONVERSATIONS_APPROVED_FETCH_SUCCESS,
+  CHAT_CONVERSATIONS_APPROVED_EXPAND_SUCCESS,
+  CHAT_CONVERSATIONS_REQUESTED_FETCH_SUCCESS,
+  CHAT_CONVERSATIONS_REQUESTED_EXPAND_SUCCESS,
+  CHAT_CONVERSATION_REQUEST_APPROVE_SUCCESS,
+} from '../actions/chat_conversations'
+
+const initialState = ImmutableMap()
+
+export const normalizeChatConversation = (chatConversation) => {
+  const { other_accounts, ...rest } = chatConversation
+  return fromJS({
+    ...rest,
+    other_account_ids: other_accounts.map((a) => a.id),
+  })
+}
+
+const importChatConversation = (state, chatConversation) => state.set(chatConversation.chat_conversation_id, normalizeChatConversation(chatConversation))
+
+const importChatConversations = (state, chatConversations) => {
+  return state.withMutations((mutable) => chatConversations.forEach((chatConversation) => importChatConversation(mutable, chatConversation)))
+}
+
+export default function chat_conversations(state = initialState, action) {
+  switch(action.type) {
+  case CHAT_CONVERSATION_REQUEST_APPROVE_SUCCESS:
+    return importChatConversation(state, action.chatConversation)
+  case CHAT_CONVERSATIONS_APPROVED_FETCH_SUCCESS:
+  case CHAT_CONVERSATIONS_APPROVED_EXPAND_SUCCESS:
+  case CHAT_CONVERSATIONS_REQUESTED_FETCH_SUCCESS:
+  case CHAT_CONVERSATIONS_REQUESTED_EXPAND_SUCCESS:
+    return importChatConversations(state, action.chatConversations)
+  default:
+    return state
+  }
+}

app/javascript/gabsocial/reducers/chat_messages.js

@@ -1,84 +1,32 @@
+import { Map as ImmutableMap, fromJS } from 'immutable'
 import {
-  REPOST_REQUEST,
-  UNREPOST_REQUEST,
-  REPOST_FAIL,
-  FAVORITE_REQUEST,
-  FAVORITE_FAIL,
-  UNFAVORITE_REQUEST,
-} from '../actions/interactions';
+  CHAT_MESSAGES_SEND_SUCCESS,
+  CHAT_MESSAGES_DELETE_REQUEST,
+} from '../actions/chat_messages'
 import {
-  STATUS_REVEAL,
-  STATUS_HIDE,
-  UPDATE_STATUS_STATS,
-} from '../actions/statuses';
-import { TIMELINE_DELETE } from '../actions/timelines';
-import { STATUS_IMPORT, STATUSES_IMPORT } from '../actions/importer';
-import { Map as ImmutableMap, fromJS } from 'immutable';
+  CHAT_MESSAGES_IMPORT,
+} from '../actions/importer'
 
-const importStatus = (state, status) => state.set(status.id, fromJS(status));
+const importChatMessage = (state, chatMessage) => state.set(chatMessage.id, fromJS(chatMessage))
 
-const importStatuses = (state, statuses) =>
-  state.withMutations(mutable => statuses.forEach(status => importStatus(mutable, status)));
+const importChatMessages = (state, chatMessages) =>
+  state.withMutations((mutable) => chatMessages.forEach((chatMessage) => importChatMessage(mutable, chatMessage)))
 
-const deleteStatus = (state, id, references) => {
-  references.forEach(ref => {
-    state = deleteStatus(state, ref[0], []);
-  });
+const deleteChatMessage = (state, id) => {
+  return state.delete(id)
+}
 
-  return state.delete(id);
-};
+const initialState = ImmutableMap()
 
-const initialState = ImmutableMap();
-
-export default function statuses(state = initialState, action) {
+export default function chat_messages(state = initialState, action) {
   switch(action.type) {
-  case STATUS_IMPORT:
-    return importStatus(state, action.status);
-  case STATUSES_IMPORT:
-    return importStatuses(state, action.statuses);
-  case FAVORITE_REQUEST:
-    return state.setIn([action.status.get('id'), 'favourited'], true);
-  case FAVORITE_FAIL:
-    return state.get(action.status.get('id')) === undefined ? state : state.setIn([action.status.get('id'), 'favourited'], false);
-  case UNFAVORITE_REQUEST:
-    return state.setIn([action.status.get('id'), 'favourited'], false);
-  case REPOST_REQUEST:
-    return state.setIn([action.status.get('id'), 'reblogged'], true);
-  case UNREPOST_REQUEST:
-    return state.setIn([action.status.get('id'), 'reblogged'], false);
-  case REPOST_FAIL:
-    return state.get(action.status.get('id')) === undefined ? state : state.setIn([action.status.get('id'), 'reblogged'], false);
-  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 TIMELINE_DELETE:
-    return deleteStatus(state, action.id, action.references);
-  case UPDATE_STATUS_STATS:
-    const { status_id } = action.data
-    return state.withMutations((map) => {
-      if (action.data.favourited !== undefined) map.setIn([status_id, 'favourited'], action.data.favourited)
-      if (action.data.favourites_count !== undefined) map.setIn([status_id, 'favourites_count'], action.data.favourites_count)
-      if (action.data.reblogged !== undefined) map.setIn([status_id, 'reblogged'], action.data.reblogged)
-      if (action.data.reblogs_count !== undefined) map.setIn([status_id, 'reblogs_count'], action.data.reblogs_count)
-      if (action.data.replies_count !== undefined) map.setIn([status_id, 'replies_count'], action.data.replies_count)
-      if (action.data.pinned !== undefined) map.setIn([status_id, 'pinned'], action.data.pinned)
-      if (action.data.pinned_by_group !== undefined) map.setIn([status_id, 'pinned_by_group'], action.data.pinned_by_group)
-      if (action.data.bookmarked !== undefined) map.setIn([status_id, 'bookmarked'], action.data.bookmarked)
-    })
+  case CHAT_MESSAGES_IMPORT:
+    return importChatMessages(state, action.chatMessages)
+  case CHAT_MESSAGES_SEND_SUCCESS:
+    return importChatMessage(state, action.chatMessage)
+  case CHAT_MESSAGES_DELETE_REQUEST:
+    return deleteChatMessage(state, action.chatMessageId)
   default:
-    return state;
+    return state
   }
-};
+}

app/javascript/gabsocial/reducers/chats.js

@@ -0,0 +1,38 @@
+import {
+  Map as ImmutableMap,
+  List as ImmutableList,
+  fromJS,
+} from 'immutable'
+import { me } from '../initial_state'
+import {
+  CHAT_CONVERSATION_CREATE_SEARCH_ACCOUNTS_SUCCESS,
+  SET_CHAT_CONVERSATION_SELECTED,
+} from '../actions/chats'
+import {
+  CHAT_CONVERSATION_REQUESTED_COUNT_FETCH_SUCCESS,
+} from '../actions/chat_conversations'
+import { 
+  CHAT_MESSAGES_SEND_SUCCESS,
+  CHAT_MESSAGES_DELETE_REQUEST,
+  CHAT_MESSAGES_FETCH_SUCCESS,
+  CHAT_CONVERSATION_MESSAGES_EXPAND_SUCCESS,
+} from '../actions/chat_messages'
+
+const initialState = ImmutableMap({
+  createChatConversationSuggestionIds: ImmutableList(),
+  selectedChatConversationId: null,
+  chatConversationRequestCount: 0,
+})
+
+export default function chats(state = initialState, action) {
+  switch(action.type) {
+  case CHAT_CONVERSATION_CREATE_SEARCH_ACCOUNTS_SUCCESS:
+    return state.set('createChatConversationSuggestionIds', ImmutableList(action.accounts.map((item) => item.id)))
+  case SET_CHAT_CONVERSATION_SELECTED:
+    return state.set('selectedChatConversationId', action.chatConversationId)
+  case CHAT_CONVERSATION_REQUESTED_COUNT_FETCH_SUCCESS:
+    return state.set('chatConversationRequestCount', action.count)
+  default:
+    return state
+  }
+}

app/javascript/gabsocial/reducers/index.js

@@ -2,7 +2,9 @@ import { combineReducers } from 'redux-immutable'
 import { loadingBarReducer } from 'react-redux-loading-bar'
 import accounts from './accounts'
 import accounts_counters from './accounts_counters'
-import chat_compose from './chat_compose'
+import chats from './chats'
+import chat_conversation_lists from './chat_conversation_lists'
+import chat_conversation_messages from './chat_conversation_messages'
 import chat_conversations from './chat_conversations'
 import chat_messages from './chat_messages'
 import compose from './compose'
@@ -49,6 +51,9 @@ import user_lists from './user_lists'
 const reducers = {
   accounts,
   accounts_counters,
+  chats,
+  chat_conversation_lists,
+  chat_conversation_messages,
   chat_conversations,
   chat_messages,
   compose,
@@ -88,10 +93,10 @@ const reducers = {
   status_revisions,
   suggestions,
   timelines,
-  timeline_injections,
-  toasts,
-  user,
-  user_lists,
+  // timeline_injections,
+  // toasts,
+  // user,
+  // user_lists,
 }
 
 export default combineReducers(reducers)

app/javascript/gabsocial/reducers/timelines.js

@@ -62,7 +62,6 @@ const expandNormalizedTimeline = (state, timeline, statuses, next, isPartial, is
         const firstIndex = oldIds.take(lastIndex).findLastIndex(id => id !== null && compareId(id, newIds.first()) > 0);
 
         if (firstIndex < 0) {
-          console.log("----2")
           return (isPartial ? newIds.unshift(null) : newIds).concat(oldIds.skip(lastIndex));
         }
 

app/javascript/gabsocial/reducers/user.js

@@ -19,7 +19,6 @@ export default function (state = initialState, action) {
     case SAVE_USER_PROFILE_INFORMATION_FETCH_SUCCESS:
       return state
     case SAVE_USER_PROFILE_INFORMATION_FETCH_FAIL:
-      alert('Failed to update your profile. Max profile image size is 2MB. Please update and try again.')
       return state.set('isError', true)
     case RESEND_USER_CONFIRMATION_EMAIL_SUCCESS:
       return state.set('emailConfirmationResends', state.get('emailConfirmationResends') + 1)