Project managers, board members, auto-update after reconnection, refactoring

client/src/sagas/core/watchers/action.js

@@ -0,0 +1,22 @@
+import { all, takeEvery } from 'redux-saga/effects';
+
+import {
+  handleActionCreateService,
+  handleActionDeleteService,
+  handleActionUpdateService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* actionWatchers() {
+  yield all([
+    takeEvery(EntryActionTypes.ACTION_CREATE_HANDLE, ({ payload: { action } }) =>
+      handleActionCreateService(action),
+    ),
+    takeEvery(EntryActionTypes.ACTION_UPDATE_HANDLE, ({ payload: { action } }) =>
+      handleActionUpdateService(action),
+    ),
+    takeEvery(EntryActionTypes.ACTION_DELETE_HANDLE, ({ payload: { action } }) =>
+      handleActionDeleteService(action),
+    ),
+  ]);
+}

client/src/sagas/core/watchers/actions.js

@@ -1,10 +1,10 @@
-import { takeLatest } from 'redux-saga/effects';
+import { takeEvery } from 'redux-saga/effects';
 
 import { fetchActionsInCurrentCardService } from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* actionsWatchers() {
-  yield takeLatest(EntryActionTypes.ACTIONS_IN_CURRENT_CARD_FETCH, () =>
+  yield takeEvery(EntryActionTypes.ACTIONS_IN_CURRENT_CARD_FETCH, () =>
     fetchActionsInCurrentCardService(),
   );
 }

client/src/sagas/core/watchers/attachment.js

@@ -1,22 +1,34 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
 import {
   createAttachmentInCurrentCardService,
   deleteAttachmentService,
+  handleAttachmentCreateService,
+  handleAttachmentDeleteService,
+  handleAttachmentUpdateService,
   updateAttachmentService,
 } from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* attachmentWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.ATTACHMENT_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.ATTACHMENT_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
       createAttachmentInCurrentCardService(data),
     ),
-    takeLatest(EntryActionTypes.ATTACHMENT_UPDATE, ({ payload: { id, data } }) =>
+    takeEvery(EntryActionTypes.ATTACHMENT_CREATE_HANDLE, ({ payload: { attachment, requestId } }) =>
+      handleAttachmentCreateService(attachment, requestId),
+    ),
+    takeEvery(EntryActionTypes.ATTACHMENT_UPDATE, ({ payload: { id, data } }) =>
       updateAttachmentService(id, data),
     ),
-    takeLatest(EntryActionTypes.ATTACHMENT_DELETE, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.ATTACHMENT_UPDATE_HANDLE, ({ payload: { attachment } }) =>
+      handleAttachmentUpdateService(attachment),
+    ),
+    takeEvery(EntryActionTypes.ATTACHMENT_DELETE, ({ payload: { id } }) =>
       deleteAttachmentService(id),
     ),
+    takeEvery(EntryActionTypes.ATTACHMENT_DELETE_HANDLE, ({ payload: { attachment } }) =>
+      handleAttachmentDeleteService(attachment),
+    ),
   ]);
 }

client/src/sagas/core/watchers/board-membership.js

@@ -0,0 +1,26 @@
+import { all, takeEvery } from 'redux-saga/effects';
+
+import {
+  createMembershipInCurrentBoardService,
+  deleteBoardMembershipService,
+  handleBoardMembershipCreateService,
+  handleBoardMembershipDeleteService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* boardMembershipWatchers() {
+  yield all([
+    takeEvery(EntryActionTypes.MEMBERSHIP_IN_CURRENT_BOARD_CREATE, ({ payload: { data } }) =>
+      createMembershipInCurrentBoardService(data),
+    ),
+    takeEvery(EntryActionTypes.BOARD_MEMBERSHIP_CREATE_HANDLE, ({ payload: { boardMembership } }) =>
+      handleBoardMembershipCreateService(boardMembership),
+    ),
+    takeEvery(EntryActionTypes.BOARD_MEMBERSHIP_DELETE, ({ payload: { id } }) =>
+      deleteBoardMembershipService(id),
+    ),
+    takeEvery(EntryActionTypes.BOARD_MEMBERSHIP_DELETE_HANDLE, ({ payload: { boardMembership } }) =>
+      handleBoardMembershipDeleteService(boardMembership),
+    ),
+  ]);
+}

client/src/sagas/core/watchers/board.js

@@ -1,9 +1,12 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
 import {
   createBoardInCurrentProjectService,
   deleteBoardService,
-  fetchBoard,
+  fetchBoardService,
+  handleBoardCreateService,
+  handleBoardDeleteService,
+  handleBoardUpdateService,
   moveBoardService,
   updateBoardService,
 } from '../services';
@@ -11,16 +14,25 @@ import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* boardWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.BOARD_IN_CURRENT_PROJECT_CREATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.BOARD_IN_CURRENT_PROJECT_CREATE, ({ payload: { data } }) =>
       createBoardInCurrentProjectService(data),
     ),
-    takeLatest(EntryActionTypes.BOARD_FETCH, ({ payload: { id } }) => fetchBoard(id)),
-    takeLatest(EntryActionTypes.BOARD_UPDATE, ({ payload: { id, data } }) =>
+    takeEvery(EntryActionTypes.BOARD_CREATE_HANDLE, ({ payload: { board } }) =>
+      handleBoardCreateService(board),
+    ),
+    takeEvery(EntryActionTypes.BOARD_FETCH, ({ payload: { id } }) => fetchBoardService(id)),
+    takeEvery(EntryActionTypes.BOARD_UPDATE, ({ payload: { id, data } }) =>
       updateBoardService(id, data),
     ),
-    takeLatest(EntryActionTypes.BOARD_MOVE, ({ payload: { id, index } }) =>
+    takeEvery(EntryActionTypes.BOARD_UPDATE_HANDLE, ({ payload: { board } }) =>
+      handleBoardUpdateService(board),
+    ),
+    takeEvery(EntryActionTypes.BOARD_MOVE, ({ payload: { id, index } }) =>
       moveBoardService(id, index),
     ),
-    takeLatest(EntryActionTypes.BOARD_DELETE, ({ payload: { id } }) => deleteBoardService(id)),
+    takeEvery(EntryActionTypes.BOARD_DELETE, ({ payload: { id } }) => deleteBoardService(id)),
+    takeEvery(EntryActionTypes.BOARD_DELETE_HANDLE, ({ payload: { board } }) =>
+      handleBoardDeleteService(board),
+    ),
   ]);
 }

client/src/sagas/core/watchers/card.js

@@ -1,9 +1,12 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
 import {
   createCardService,
   deleteCardService,
   deleteCurrentCardService,
+  handleCardCreateService,
+  handleCardDeleteService,
+  handleCardUpdateService,
   moveCardService,
   moveCurrentCardService,
   transferCardService,
@@ -15,28 +18,37 @@ import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* cardWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.CARD_CREATE, ({ payload: { listId, data } }) =>
+    takeEvery(EntryActionTypes.CARD_CREATE, ({ payload: { listId, data } }) =>
       createCardService(listId, data),
     ),
-    takeLatest(EntryActionTypes.CARD_UPDATE, ({ payload: { id, data } }) =>
+    takeEvery(EntryActionTypes.CARD_CREATE_HANDLE, ({ payload: { card } }) =>
+      handleCardCreateService(card),
+    ),
+    takeEvery(EntryActionTypes.CARD_UPDATE, ({ payload: { id, data } }) =>
       updateCardService(id, data),
     ),
-    takeLatest(EntryActionTypes.CURRENT_CARD_UPDATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.CURRENT_CARD_UPDATE, ({ payload: { data } }) =>
       updateCurrentCardService(data),
     ),
-    takeLatest(EntryActionTypes.CARD_MOVE, ({ payload: { id, listId, index } }) =>
+    takeEvery(EntryActionTypes.CARD_UPDATE_HANDLE, ({ payload: { card } }) =>
+      handleCardUpdateService(card),
+    ),
+    takeEvery(EntryActionTypes.CARD_MOVE, ({ payload: { id, listId, index } }) =>
       moveCardService(id, listId, index),
     ),
-    takeLatest(EntryActionTypes.CURRENT_CARD_MOVE, ({ payload: { listId, index } }) =>
+    takeEvery(EntryActionTypes.CURRENT_CARD_MOVE, ({ payload: { listId, index } }) =>
       moveCurrentCardService(listId, index),
     ),
-    takeLatest(EntryActionTypes.CARD_TRANSFER, ({ payload: { id, boardId, listId, index } }) =>
+    takeEvery(EntryActionTypes.CARD_TRANSFER, ({ payload: { id, boardId, listId, index } }) =>
       transferCardService(id, boardId, listId, index),
     ),
-    takeLatest(EntryActionTypes.CURRENT_CARD_TRANSFER, ({ payload: { boardId, listId, index } }) =>
+    takeEvery(EntryActionTypes.CURRENT_CARD_TRANSFER, ({ payload: { boardId, listId, index } }) =>
       transferCurrentCardService(boardId, listId, index),
     ),
-    takeLatest(EntryActionTypes.CARD_DELETE, ({ payload: { id } }) => deleteCardService(id)),
-    takeLatest(EntryActionTypes.CURRENT_CARD_DELETE, () => deleteCurrentCardService()),
+    takeEvery(EntryActionTypes.CARD_DELETE, ({ payload: { id } }) => deleteCardService(id)),
+    takeEvery(EntryActionTypes.CURRENT_CARD_DELETE, () => deleteCurrentCardService()),
+    takeEvery(EntryActionTypes.CARD_DELETE_HANDLE, ({ payload: { card } }) =>
+      handleCardDeleteService(card),
+    ),
   ]);
 }

client/src/sagas/core/watchers/comment-action.js

@@ -1,4 +1,4 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
 import {
   createCommentActionInCurrentCardService,
@@ -9,13 +9,13 @@ import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* commentActionWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.COMMENT_ACTION_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.COMMENT_ACTION_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
       createCommentActionInCurrentCardService(data),
     ),
-    takeLatest(EntryActionTypes.COMMENT_ACTION_UPDATE, ({ payload: { id, data } }) =>
+    takeEvery(EntryActionTypes.COMMENT_ACTION_UPDATE, ({ payload: { id, data } }) =>
       updateCommentActionService(id, data),
     ),
-    takeLatest(EntryActionTypes.COMMENT_ACTION_DELETE, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.COMMENT_ACTION_DELETE, ({ payload: { id } }) =>
       deleteCommentActionService(id),
     ),
   ]);

client/src/sagas/core/watchers/core.js

@@ -0,0 +1,8 @@
+import { takeEvery } from 'redux-saga/effects';
+
+import { initializeCoreService } from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* coreWatchers() {
+  yield takeEvery(EntryActionTypes.CORE_INITIALIZE, () => initializeCoreService());
+}

client/src/sagas/core/watchers/index.js

@@ -1,17 +1,20 @@
 import router from './router';
 import socket from './socket';
 import login from './login';
+import core from './core';
 import modal from './modal';
 import user from './user';
 import project from './project';
-import projectMembership from './project-membership';
+import projectManager from './project-manager';
 import board from './board';
+import boardMembership from './board-membership';
 import label from './label';
 import list from './list';
 import card from './card';
 import task from './task';
 import attachment from './attachment';
 import actions from './actions';
+import action from './action';
 import commentAction from './comment-action';
 import notification from './notification';
 
@@ -19,17 +22,20 @@ export default [
   router,
   socket,
   login,
+  core,
   modal,
   user,
   project,
-  projectMembership,
+  projectManager,
   board,
+  boardMembership,
   label,
   list,
   card,
   task,
   attachment,
   actions,
+  action,
   commentAction,
   notification,
 ];

client/src/sagas/core/watchers/label.js

@@ -1,4 +1,4 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
 import {
   addLabelToCardService,
@@ -6,6 +6,11 @@ import {
   addLabelToFilterInCurrentBoardService,
   createLabelInCurrentBoardService,
   deleteLabelService,
+  handleLabelCreateService,
+  handleLabelDeleteService,
+  handleLabelFromCardRemoveService,
+  handleLabelToCardAddService,
+  handleLabelUpdateService,
   removeLabelFromCardService,
   removeLabelFromCurrentCardService,
   removeLabelFromFilterInCurrentBoardService,
@@ -15,29 +20,44 @@ import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* labelWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.LABEL_IN_CURRENT_BOARD_CREATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.LABEL_IN_CURRENT_BOARD_CREATE, ({ payload: { data } }) =>
       createLabelInCurrentBoardService(data),
     ),
-    takeLatest(EntryActionTypes.LABEL_UPDATE, ({ payload: { id, data } }) =>
+    takeEvery(EntryActionTypes.LABEL_CREATE_HANDLE, ({ payload: { label } }) =>
+      handleLabelCreateService(label),
+    ),
+    takeEvery(EntryActionTypes.LABEL_UPDATE, ({ payload: { id, data } }) =>
       updateLabelService(id, data),
     ),
-    takeLatest(EntryActionTypes.LABEL_DELETE, ({ payload: { id } }) => deleteLabelService(id)),
-    takeLatest(EntryActionTypes.LABEL_TO_CARD_ADD, ({ payload: { id, cardId } }) =>
+    takeEvery(EntryActionTypes.LABEL_UPDATE_HANDLE, ({ payload: { label } }) =>
+      handleLabelUpdateService(label),
+    ),
+    takeEvery(EntryActionTypes.LABEL_DELETE, ({ payload: { id } }) => deleteLabelService(id)),
+    takeEvery(EntryActionTypes.LABEL_DELETE_HANDLE, ({ payload: { label } }) =>
+      handleLabelDeleteService(label),
+    ),
+    takeEvery(EntryActionTypes.LABEL_TO_CARD_ADD, ({ payload: { id, cardId } }) =>
       addLabelToCardService(id, cardId),
     ),
-    takeLatest(EntryActionTypes.LABEL_TO_CURRENT_CARD_ADD, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.LABEL_TO_CURRENT_CARD_ADD, ({ payload: { id } }) =>
       addLabelToCurrentCardService(id),
     ),
-    takeLatest(EntryActionTypes.LABEL_FROM_CARD_REMOVE, ({ payload: { id, cardId } }) =>
+    takeEvery(EntryActionTypes.LABEL_TO_CARD_ADD_HANDLE, ({ payload: { cardLabel } }) =>
+      handleLabelToCardAddService(cardLabel),
+    ),
+    takeEvery(EntryActionTypes.LABEL_FROM_CARD_REMOVE, ({ payload: { id, cardId } }) =>
       removeLabelFromCardService(id, cardId),
     ),
-    takeLatest(EntryActionTypes.LABEL_FROM_CURRENT_CARD_REMOVE, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.LABEL_FROM_CURRENT_CARD_REMOVE, ({ payload: { id } }) =>
       removeLabelFromCurrentCardService(id),
     ),
-    takeLatest(EntryActionTypes.LABEL_TO_FILTER_IN_CURRENT_BOARD_ADD, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.LABEL_FROM_CARD_REMOVE_HANDLE, ({ payload: { cardLabel } }) =>
+      handleLabelFromCardRemoveService(cardLabel),
+    ),
+    takeEvery(EntryActionTypes.LABEL_TO_FILTER_IN_CURRENT_BOARD_ADD, ({ payload: { id } }) =>
       addLabelToFilterInCurrentBoardService(id),
     ),
-    takeLatest(EntryActionTypes.LABEL_FROM_FILTER_IN_CURRENT_BOARD_REMOVE, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.LABEL_FROM_FILTER_IN_CURRENT_BOARD_REMOVE, ({ payload: { id } }) =>
       removeLabelFromFilterInCurrentBoardService(id),
     ),
   ]);

client/src/sagas/core/watchers/list.js

@@ -1,8 +1,11 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
 import {
   createListInCurrentBoardService,
   deleteListService,
+  handleListCreateService,
+  handleListDeleteService,
+  handleListUpdateService,
   moveListService,
   updateListService,
 } from '../services';
@@ -10,15 +13,24 @@ import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* listWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.LIST_IN_CURRENT_BOARD_CREATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.LIST_IN_CURRENT_BOARD_CREATE, ({ payload: { data } }) =>
       createListInCurrentBoardService(data),
     ),
-    takeLatest(EntryActionTypes.LIST_UPDATE, ({ payload: { id, data } }) =>
+    takeEvery(EntryActionTypes.LIST_CREATE_HANDLE, ({ payload: { list } }) =>
+      handleListCreateService(list),
+    ),
+    takeEvery(EntryActionTypes.LIST_UPDATE, ({ payload: { id, data } }) =>
       updateListService(id, data),
     ),
-    takeLatest(EntryActionTypes.LIST_MOVE, ({ payload: { id, index } }) =>
+    takeEvery(EntryActionTypes.LIST_UPDATE_HANDLE, ({ payload: { list } }) =>
+      handleListUpdateService(list),
+    ),
+    takeEvery(EntryActionTypes.LIST_MOVE, ({ payload: { id, index } }) =>
       moveListService(id, index),
     ),
-    takeLatest(EntryActionTypes.LIST_DELETE, ({ payload: { id } }) => deleteListService(id)),
+    takeEvery(EntryActionTypes.LIST_DELETE, ({ payload: { id } }) => deleteListService(id)),
+    takeEvery(EntryActionTypes.LIST_DELETE_HANDLE, ({ payload: { list } }) =>
+      handleListDeleteService(list),
+    ),
   ]);
 }

client/src/sagas/core/watchers/login.js

@@ -1,8 +1,8 @@
-import { takeLatest } from 'redux-saga/effects';
+import { takeEvery } from 'redux-saga/effects';
 
 import { logoutService } from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* loginWatchers() {
-  yield takeLatest(EntryActionTypes.LOGOUT, () => logoutService());
+  yield takeEvery(EntryActionTypes.LOGOUT, () => logoutService());
 }

client/src/sagas/core/watchers/modal.js

@@ -1,11 +1,11 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
 import { closeModalService, openModalService } from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* modalWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.MODAL_OPEN, ({ payload: { type } }) => openModalService(type)),
-    takeLatest(EntryActionTypes.MODAL_CLOSE, () => closeModalService()),
+    takeEvery(EntryActionTypes.MODAL_OPEN, ({ payload: { type } }) => openModalService(type)),
+    takeEvery(EntryActionTypes.MODAL_CLOSE, () => closeModalService()),
   ]);
 }

client/src/sagas/core/watchers/notification.js

@@ -1,10 +1,22 @@
-import { takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
-import { deleteNotificationService } from '../services';
+import {
+  deleteNotificationService,
+  handleNotificationCreateService,
+  handleNotificationDeleteService,
+} from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* notificationWatchers() {
-  yield takeLatest(EntryActionTypes.NOTIFICATION_DELETE, ({ payload: { id } }) =>
-    deleteNotificationService(id),
-  );
+  yield all([
+    takeEvery(EntryActionTypes.NOTIFICATION_CREATE_HANDLE, ({ payload: { notification } }) =>
+      handleNotificationCreateService(notification),
+    ),
+    takeEvery(EntryActionTypes.NOTIFICATION_DELETE, ({ payload: { id } }) =>
+      deleteNotificationService(id),
+    ),
+    takeEvery(EntryActionTypes.NOTIFICATION_DELETE_HANDLE, ({ payload: { notification } }) =>
+      handleNotificationDeleteService(notification),
+    ),
+  ]);
 }

client/src/sagas/core/watchers/project-manager.js

@@ -0,0 +1,26 @@
+import { all, takeEvery } from 'redux-saga/effects';
+
+import {
+  createManagerInCurrentProjectService,
+  deleteProjectManagerService,
+  handleProjectManagerCreateService,
+  handleProjectManagerDeleteService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* projectManagerWatchers() {
+  yield all([
+    takeEvery(EntryActionTypes.MANAGER_IN_CURRENT_PROJECT_CREATE, ({ payload: { data } }) =>
+      createManagerInCurrentProjectService(data),
+    ),
+    takeEvery(EntryActionTypes.PROJECT_MANAGER_CREATE_HANDLE, ({ payload: { projectManager } }) =>
+      handleProjectManagerCreateService(projectManager),
+    ),
+    takeEvery(EntryActionTypes.PROJECT_MANAGER_DELETE, ({ payload: { id } }) =>
+      deleteProjectManagerService(id),
+    ),
+    takeEvery(EntryActionTypes.PROJECT_MANAGER_DELETE_HANDLE, ({ payload: { projectManager } }) =>
+      handleProjectManagerDeleteService(projectManager),
+    ),
+  ]);
+}

client/src/sagas/core/watchers/project-membership.js

@@ -1,18 +0,0 @@
-import { all, takeLatest } from 'redux-saga/effects';
-
-import {
-  createMembershipInCurrentProjectService,
-  deleteProjectMembershipService,
-} from '../services';
-import EntryActionTypes from '../../../constants/EntryActionTypes';
-
-export default function* projectMembershipWatchers() {
-  yield all([
-    takeLatest(EntryActionTypes.MEMBERSHIP_IN_CURRENT_PROJECT_CREATE, ({ payload: { data } }) =>
-      createMembershipInCurrentProjectService(data),
-    ),
-    takeLatest(EntryActionTypes.PROJECT_MEMBERSHIP_DELETE, ({ payload: { id } }) =>
-      deleteProjectMembershipService(id),
-    ),
-  ]);
-}

client/src/sagas/core/watchers/project.js

@@ -1,8 +1,11 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
 import {
   createProjectService,
   deleteCurrentProjectService,
+  handleProjectCreateService,
+  handleProjectDeleteService,
+  handleProjectUpdateService,
   updateCurrentProjectBackgroundImageService,
   updateCurrentProjectService,
 } from '../services';
@@ -10,15 +13,24 @@ import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* projectWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.PROJECT_CREATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.PROJECT_CREATE, ({ payload: { data } }) =>
       createProjectService(data),
     ),
-    takeLatest(EntryActionTypes.CURRENT_PROJECT_UPDATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.PROJECT_CREATE_HANDLE, ({ payload: { project } }) =>
+      handleProjectCreateService(project),
+    ),
+    takeEvery(EntryActionTypes.CURRENT_PROJECT_UPDATE, ({ payload: { data } }) =>
       updateCurrentProjectService(data),
     ),
-    takeLatest(EntryActionTypes.CURRENT_PROJECT_BACKGROUND_IMAGE_UPDATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.PROJECT_UPDATE_HANDLE, ({ payload: { project } }) =>
+      handleProjectUpdateService(project),
+    ),
+    takeEvery(EntryActionTypes.CURRENT_PROJECT_BACKGROUND_IMAGE_UPDATE, ({ payload: { data } }) =>
       updateCurrentProjectBackgroundImageService(data),
     ),
-    takeLatest(EntryActionTypes.CURRENT_PROJECT_DELETE, () => deleteCurrentProjectService()),
+    takeEvery(EntryActionTypes.CURRENT_PROJECT_DELETE, () => deleteCurrentProjectService()),
+    takeEvery(EntryActionTypes.PROJECT_DELETE_HANDLE, ({ payload: { project } }) =>
+      handleProjectDeleteService(project),
+    ),
   ]);
 }

client/src/sagas/core/watchers/router.js

@@ -1,8 +1,8 @@
 import { takeEvery } from 'redux-saga/effects';
 import { LOCATION_CHANGE } from 'connected-react-router';
 
-import { locationChangedService } from '../services';
+import { handleLocationChangeService } from '../services';
 
 export default function* routerWatchers() {
-  yield takeEvery(LOCATION_CHANGE, () => locationChangedService());
+  yield takeEvery(LOCATION_CHANGE, () => handleLocationChangeService());
 }

client/src/sagas/core/watchers/socket.js

@@ -1,206 +1,211 @@
 import { eventChannel } from 'redux-saga';
-import { call, cancelled, take } from 'redux-saga/effects';
+import { all, call, cancelled, put, take, takeEvery } from 'redux-saga/effects';
 
+import { handleSocketDisconnectService, handleSocketReconnectService } from '../services';
 import {
-  createActionReceivedService,
-  createAttachmentReceivedService,
-  createBoardReceivedService,
-  createCardLabelReceivedService,
-  createCardMembershipReceivedService,
-  createCardReceivedService,
-  createLabelReceivedService,
-  createListReceivedService,
-  createNotificationReceivedService,
-  createProjectMembershipReceivedService,
-  createProjectReceivedService,
-  createTaskReceivedService,
-  createUserReceivedService,
-  deleteActionReceivedService,
-  deleteAttachmentReceivedService,
-  deleteCardLabelReceivedService,
-  deleteCardMembershipReceivedService,
-  deleteCardReceivedService,
-  deleteBoardReceivedService,
-  deleteLabelReceivedService,
-  deleteListReceivedService,
-  deleteNotificationReceivedService,
-  deleteProjectMembershipReceivedService,
-  deleteProjectReceivedService,
-  deleteTaskReceivedService,
-  deleteUserReceivedService,
-  socketDisconnectedService,
-  socketReconnectedService,
-  updateActionReceivedService,
-  updateAttachmentReceivedService,
-  updateBoardReceivedService,
-  updateCardReceivedService,
-  updateLabelReceivedService,
-  updateListReceivedService,
-  updateProjectReceivedService,
-  updateTaskReceivedService,
-  updateUserReceivedService,
-} from '../services';
+  handleProjectManagerCreate as handleProjectManagerCreateAction,
+  handleProjectManagerDelete as handleProjectManagerDeleteAction,
+  handleBoardCreate as handleBoardCreateAction,
+  handleBoardUpdate as handleBoardUpdateAction,
+  handleBoardDelete as handleBoardDeleteAction,
+  handleBoardMembershipCreate as handleBoardMembershipCreateAction,
+  handleBoardMembershipDelete as handleBoardMembershipDeleteAction,
+  handleListCreate as handleListCreateAction,
+  handleListUpdate as handleListUpdateAction,
+  handleListDelete as handleListDeleteAction,
+  handleLabelCreate as handleLabelCreateAction,
+  handleLabelUpdate as handleLabelUpdateAction,
+  handleLabelDelete as handleLabelDeleteAction,
+  handleCardCreate as handleCardCreateAction,
+  handleCardUpdate as handleCardUpdateAction,
+  handleCardDelete as handleCardDeleteAction,
+  handleUserToCardAdd as handleUserToCardAddAction,
+  handleUserFromCardRemove as handleUserFromCardRemoveAction,
+  handleLabelToCardAdd as handleLabelToCardAddAction,
+  handleLabelFromCardRemove as handleLabelFromCardRemoveAction,
+  handleTaskCreate as handleTaskCreateAction,
+  handleTaskUpdate as handleTaskUpdateAction,
+  handleTaskDelete as handleTaskDeleteAction,
+  handleAttachmentCreate as handleAttachmentCreateAction,
+  handleAttachmentUpdate as handleAttachmentUpdateAction,
+  handleAttachmentDelete as handleAttachmentDeleteAction,
+  handleActionCreate as handleActionCreateAction,
+  handleActionUpdate as handleActionUpdateAction,
+  handleActionDelete as handleActionDeleteAction,
+  handleNotificationCreate as handleNotificationCreateAction,
+  handleNotificationDelete as handleNotificationDeleteAction,
+  handleSocketDisconnect as handleSocketDisconnectAction,
+  handleUserCreate as handleUserCreateAction,
+  handleUserUpdate as handleUserUpdateAction,
+  handleUserDelete as handleUserDeleteAction,
+  handleProjectCreate as handleProjectCreateAction,
+  handleProjectUpdate as handleProjectUpdateAction,
+  handleProjectDelete as handleProjectDeleteAction,
+  handleSocketReconnect as handleSocketReconnectAction,
+} from '../../../actions/entry';
 import api, { socket } from '../../../api';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 const createSocketEventsChannel = () =>
   eventChannel((emit) => {
+    const handleDisconnect = () => {
+      emit(handleSocketDisconnectAction());
+    };
+
     const handleReconnect = () => {
-      emit([socketReconnectedService]);
+      emit(handleSocketReconnectAction());
     };
 
     const handleUserCreate = ({ item }) => {
-      emit([createUserReceivedService, item]);
+      emit(handleUserCreateAction(item));
     };
 
     const handleUserUpdate = ({ item }) => {
-      emit([updateUserReceivedService, item]);
+      emit(handleUserUpdateAction(item));
     };
 
     const handleUserDelete = ({ item }) => {
-      emit([deleteUserReceivedService, item]);
+      emit(handleUserDeleteAction(item));
     };
 
-    const handleProjectCreate = ({ item, included: { users, projectMemberships, boards } }) => {
-      emit([createProjectReceivedService, item, users, projectMemberships, boards]);
+    const handleProjectCreate = ({ item }) => {
+      emit(handleProjectCreateAction(item));
     };
 
     const handleProjectUpdate = ({ item }) => {
-      emit([updateProjectReceivedService, item]);
+      emit(handleProjectUpdateAction(item));
     };
 
     const handleProjectDelete = ({ item }) => {
-      emit([deleteProjectReceivedService, item]);
+      emit(handleProjectDeleteAction(item));
     };
 
-    const handleProjectMembershipCreate = ({ item, included: { users } }) => {
-      emit([createProjectMembershipReceivedService, item, users[0]]);
+    const handleProjectManagerCreate = ({ item }) => {
+      emit(handleProjectManagerCreateAction(item));
     };
 
-    const handleProjectMembershipDelete = ({ item }) => {
-      emit([deleteProjectMembershipReceivedService, item]);
+    const handleProjectManagerDelete = ({ item }) => {
+      emit(handleProjectManagerDeleteAction(item));
     };
 
-    const handleBoardCreate = ({ item, included: { lists, labels } }) => {
-      emit([createBoardReceivedService, item, lists, labels]);
+    const handleBoardCreate = ({ item }) => {
+      emit(handleBoardCreateAction(item));
     };
 
     const handleBoardUpdate = ({ item }) => {
-      emit([updateBoardReceivedService, item]);
+      emit(handleBoardUpdateAction(item));
     };
 
     const handleBoardDelete = ({ item }) => {
-      emit([deleteBoardReceivedService, item]);
+      emit(handleBoardDeleteAction(item));
+    };
+
+    const handleBoardMembershipCreate = ({ item }) => {
+      emit(handleBoardMembershipCreateAction(item));
+    };
+
+    const handleBoardMembershipDelete = ({ item }) => {
+      emit(handleBoardMembershipDeleteAction(item));
     };
 
     const handleListCreate = ({ item }) => {
-      emit([createListReceivedService, item]);
+      emit(handleListCreateAction(item));
     };
 
     const handleListUpdate = ({ item }) => {
-      emit([updateListReceivedService, item]);
+      emit(handleListUpdateAction(item));
     };
 
     const handleListDelete = ({ item }) => {
-      emit([deleteListReceivedService, item]);
+      emit(handleListDeleteAction(item));
     };
 
     const handleLabelCreate = ({ item }) => {
-      emit([createLabelReceivedService, item]);
+      emit(handleLabelCreateAction(item));
     };
 
     const handleLabelUpdate = ({ item }) => {
-      emit([updateLabelReceivedService, item]);
+      emit(handleLabelUpdateAction(item));
     };
 
     const handleLabelDelete = ({ item }) => {
-      emit([deleteLabelReceivedService, item]);
+      emit(handleLabelDeleteAction(item));
     };
 
-    const handleCardCreate = api.makeHandleCardCreate(
-      ({ item, included: { cardMemberships, cardLabels, tasks, attachments } }) => {
-        emit([createCardReceivedService, item, cardMemberships, cardLabels, tasks, attachments]);
-      },
-    );
+    const handleCardCreate = api.makeHandleCardCreate(({ item }) => {
+      emit(handleCardCreateAction(item));
+    });
 
     const handleCardUpdate = api.makeHandleCardUpdate(({ item }) => {
-      emit([updateCardReceivedService, item]);
+      emit(handleCardUpdateAction(item));
     });
 
     const handleCardDelete = api.makeHandleCardDelete(({ item }) => {
-      emit([deleteCardReceivedService, item]);
+      emit(handleCardDeleteAction(item));
     });
 
-    const handleCardMembershipCreate = ({ item }) => {
-      emit([createCardMembershipReceivedService, item]);
+    const handleUserToCardAdd = ({ item }) => {
+      emit(handleUserToCardAddAction(item));
     };
 
-    const handleCardMembershipDelete = ({ item }) => {
-      emit([deleteCardMembershipReceivedService, item]);
+    const handleUserFromCardRemove = ({ item }) => {
+      emit(handleUserFromCardRemoveAction(item));
     };
 
-    const handleCardLabelCreate = ({ item }) => {
-      emit([createCardLabelReceivedService, item]);
+    const handleLabelToCardAdd = ({ item }) => {
+      emit(handleLabelToCardAddAction(item));
     };
 
-    const handleCardLabelDelete = ({ item }) => {
-      emit([deleteCardLabelReceivedService, item]);
+    const handleLabelFromCardRemove = ({ item }) => {
+      emit(handleLabelFromCardRemoveAction(item));
     };
 
     const handleTaskCreate = ({ item }) => {
-      emit([createTaskReceivedService, item]);
+      emit(handleTaskCreateAction(item));
     };
 
     const handleTaskUpdate = ({ item }) => {
-      emit([updateTaskReceivedService, item]);
+      emit(handleTaskUpdateAction(item));
     };
 
     const handleTaskDelete = ({ item }) => {
-      emit([deleteTaskReceivedService, item]);
+      emit(handleTaskDeleteAction(item));
     };
 
     const handleAttachmentCreate = api.makeHandleAttachmentCreate(({ item, requestId }) => {
-      emit([createAttachmentReceivedService, item, requestId]);
+      emit(handleAttachmentCreateAction(item, requestId));
     });
 
     const handleAttachmentUpdate = api.makeHandleAttachmentUpdate(({ item }) => {
-      emit([updateAttachmentReceivedService, item]);
+      emit(handleAttachmentUpdateAction(item));
     });
 
     const handleAttachmentDelete = api.makeHandleAttachmentDelete(({ item }) => {
-      emit([deleteAttachmentReceivedService, item]);
+      emit(handleAttachmentDeleteAction(item));
     });
 
     const handleActionCreate = api.makeHandleActionCreate(({ item }) => {
-      emit([createActionReceivedService, item]);
+      emit(handleActionCreateAction(item));
     });
 
     const handleActionUpdate = api.makeHandleActionUpdate(({ item }) => {
-      emit([updateActionReceivedService, item]);
+      emit(handleActionUpdateAction(item));
     });
 
     const handleActionDelete = api.makeHandleActionDelete(({ item }) => {
-      emit([deleteActionReceivedService, item]);
+      emit(handleActionDeleteAction(item));
     });
 
-    const handleNotificationCreate = api.makeHandleNotificationCreate(
-      ({ item, included: { users, cards, actions } }) => {
-        emit([createNotificationReceivedService, item, users[0], cards[0], actions[0]]);
-      },
-    );
-
-    const handleNotificationDelete = ({ item }) => {
-      emit([deleteNotificationReceivedService, item]);
+    const handleNotificationCreate = ({ item }) => {
+      emit(handleNotificationCreateAction(item));
     };
 
-    const handleDisconnect = () => {
-      socket.off('disconnect', handleDisconnect);
-
-      emit([socketDisconnectedService]);
-
-      socket.on('reconnect', handleReconnect);
+    const handleNotificationDelete = ({ item }) => {
+      emit(handleNotificationDeleteAction(item));
     };
 
     socket.on('disconnect', handleDisconnect);
+    socket.on('reconnect', handleReconnect);
 
     socket.on('userCreate', handleUserCreate);
     socket.on('userUpdate', handleUserUpdate);
@@ -210,13 +215,16 @@ const createSocketEventsChannel = () =>
     socket.on('projectUpdate', handleProjectUpdate);
     socket.on('projectDelete', handleProjectDelete);
 
-    socket.on('projectMembershipCreate', handleProjectMembershipCreate);
-    socket.on('projectMembershipDelete', handleProjectMembershipDelete);
+    socket.on('projectManagerCreate', handleProjectManagerCreate);
+    socket.on('projectManagerDelete', handleProjectManagerDelete);
 
     socket.on('boardCreate', handleBoardCreate);
     socket.on('boardUpdate', handleBoardUpdate);
     socket.on('boardDelete', handleBoardDelete);
 
+    socket.on('boardMembershipCreate', handleBoardMembershipCreate);
+    socket.on('boardMembershipDelete', handleBoardMembershipDelete);
+
     socket.on('listCreate', handleListCreate);
     socket.on('listUpdate', handleListUpdate);
     socket.on('listDelete', handleListDelete);
@@ -229,11 +237,11 @@ const createSocketEventsChannel = () =>
     socket.on('cardUpdate', handleCardUpdate);
     socket.on('cardDelete', handleCardDelete);
 
-    socket.on('cardMembershipCreate', handleCardMembershipCreate);
-    socket.on('cardMembershipDelete', handleCardMembershipDelete);
+    socket.on('cardMembershipCreate', handleUserToCardAdd);
+    socket.on('cardMembershipDelete', handleUserFromCardRemove);
 
-    socket.on('cardLabelCreate', handleCardLabelCreate);
-    socket.on('cardLabelDelete', handleCardLabelDelete);
+    socket.on('cardLabelCreate', handleLabelToCardAdd);
+    socket.on('cardLabelDelete', handleLabelFromCardRemove);
 
     socket.on('taskCreate', handleTaskCreate);
     socket.on('taskUpdate', handleTaskUpdate);
@@ -262,13 +270,16 @@ const createSocketEventsChannel = () =>
       socket.off('projectUpdate', handleProjectUpdate);
       socket.off('projectDelete', handleProjectDelete);
 
-      socket.off('projectMembershipCreate', handleProjectMembershipCreate);
-      socket.off('projectMembershipDelete', handleProjectMembershipDelete);
+      socket.off('projectManagerCreate', handleProjectManagerCreate);
+      socket.off('projectManagerDelete', handleProjectManagerDelete);
 
       socket.off('boardCreate', handleBoardCreate);
       socket.off('boardUpdate', handleBoardUpdate);
       socket.off('boardDelete', handleBoardDelete);
 
+      socket.off('boardMembershipCreate', handleBoardMembershipCreate);
+      socket.off('boardMembershipDelete', handleBoardMembershipDelete);
+
       socket.off('listCreate', handleListCreate);
       socket.off('listUpdate', handleListUpdate);
       socket.off('listDelete', handleListDelete);
@@ -281,11 +292,11 @@ const createSocketEventsChannel = () =>
       socket.off('cardUpdate', handleCardUpdate);
       socket.off('cardDelete', handleCardDelete);
 
-      socket.off('cardMembershipCreate', handleCardMembershipCreate);
-      socket.off('cardMembershipDelete', handleCardMembershipDelete);
+      socket.off('cardMembershipCreate', handleUserToCardAdd);
+      socket.off('cardMembershipDelete', handleUserFromCardRemove);
 
-      socket.off('cardLabelCreate', handleCardLabelCreate);
-      socket.off('cardLabelDelete', handleCardLabelDelete);
+      socket.off('cardLabelCreate', handleLabelToCardAdd);
+      socket.off('cardLabelDelete', handleLabelFromCardRemove);
 
       socket.off('taskCreate', handleTaskCreate);
       socket.off('taskUpdate', handleTaskUpdate);
@@ -305,13 +316,20 @@ const createSocketEventsChannel = () =>
   });
 
 export default function* socketWatchers() {
+  yield all([
+    yield takeEvery(EntryActionTypes.SOCKET_DISCONNECT_HANDLE, () =>
+      handleSocketDisconnectService(),
+    ),
+    yield takeEvery(EntryActionTypes.SOCKET_RECONNECT_HANDLE, () => handleSocketReconnectService()),
+  ]);
+
   const socketEventsChannel = yield call(createSocketEventsChannel);
 
   try {
     while (true) {
-      const args = yield take(socketEventsChannel);
+      const action = yield take(socketEventsChannel);
 
-      yield call(...args);
+      yield put(action);
     }
   } finally {
     if (yield cancelled()) {

client/src/sagas/core/watchers/task.js

@@ -1,16 +1,32 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
-import { createTaskInCurrentCardService, deleteTaskService, updateTaskService } from '../services';
+import {
+  createTaskInCurrentCardService,
+  deleteTaskService,
+  handleTaskCreateService,
+  handleTaskDeleteService,
+  handleTaskUpdateService,
+  updateTaskService,
+} from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* taskWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.TASK_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.TASK_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
       createTaskInCurrentCardService(data),
     ),
-    takeLatest(EntryActionTypes.TASK_UPDATE, ({ payload: { id, data } }) =>
+    takeEvery(EntryActionTypes.TASK_CREATE_HANDLE, ({ payload: { task } }) =>
+      handleTaskCreateService(task),
+    ),
+    takeEvery(EntryActionTypes.TASK_UPDATE, ({ payload: { id, data } }) =>
       updateTaskService(id, data),
     ),
-    takeLatest(EntryActionTypes.TASK_DELETE, ({ payload: { id } }) => deleteTaskService(id)),
+    takeEvery(EntryActionTypes.TASK_UPDATE_HANDLE, ({ payload: { task } }) =>
+      handleTaskUpdateService(task),
+    ),
+    takeEvery(EntryActionTypes.TASK_DELETE, ({ payload: { id } }) => deleteTaskService(id)),
+    takeEvery(EntryActionTypes.TASK_DELETE_HANDLE, ({ payload: { task } }) =>
+      handleTaskDeleteService(task),
+    ),
   ]);
 }

client/src/sagas/core/watchers/user.js

@@ -1,4 +1,4 @@
-import { all, takeLatest } from 'redux-saga/effects';
+import { all, takeEvery } from 'redux-saga/effects';
 
 import {
   addUserToCardService,
@@ -19,57 +19,77 @@ import {
   updateCurrentUserPasswordService,
   updateCurrentUserService,
   updateCurrentUserUsernameService,
+  handleUserCreateService,
+  handleUserUpdateService,
+  handleUserDeleteService,
+  handleUserToCardAddService,
+  handleUserFromCardRemoveService,
 } from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 export default function* userWatchers() {
   yield all([
-    takeLatest(EntryActionTypes.USER_CREATE, ({ payload: { data } }) => createUserService(data)),
-    takeLatest(EntryActionTypes.USER_CREATE_ERROR_CLEAR, () => clearUserCreateErrorService()),
-    takeLatest(EntryActionTypes.USER_UPDATE, ({ payload: { id, data } }) =>
+    takeEvery(EntryActionTypes.USER_CREATE, ({ payload: { data } }) => createUserService(data)),
+    takeEvery(EntryActionTypes.USER_CREATE_HANDLE, ({ payload: { user } }) =>
+      handleUserCreateService(user),
+    ),
+    takeEvery(EntryActionTypes.USER_CREATE_ERROR_CLEAR, () => clearUserCreateErrorService()),
+    takeEvery(EntryActionTypes.USER_UPDATE, ({ payload: { id, data } }) =>
       updateUserService(id, data),
     ),
-    takeLatest(EntryActionTypes.CURRENT_USER_UPDATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.CURRENT_USER_UPDATE, ({ payload: { data } }) =>
       updateCurrentUserService(data),
     ),
-    takeLatest(EntryActionTypes.CURRENT_USER_EMAIL_UPDATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.USER_UPDATE_HANDLE, ({ payload: { user } }) =>
+      handleUserUpdateService(user),
+    ),
+    takeEvery(EntryActionTypes.CURRENT_USER_EMAIL_UPDATE, ({ payload: { data } }) =>
       updateCurrentUserEmailService(data),
     ),
-    takeLatest(EntryActionTypes.CURRENT_USER_EMAIL_UPDATE_ERROR_CLEAR, () =>
+    takeEvery(EntryActionTypes.CURRENT_USER_EMAIL_UPDATE_ERROR_CLEAR, () =>
       clearCurrentUserEmailUpdateErrorService(),
     ),
-    takeLatest(EntryActionTypes.CURRENT_USER_PASSWORD_UPDATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.CURRENT_USER_PASSWORD_UPDATE, ({ payload: { data } }) =>
       updateCurrentUserPasswordService(data),
     ),
-    takeLatest(EntryActionTypes.CURRENT_USER_PASSWORD_UPDATE_ERROR_CLEAR, () =>
+    takeEvery(EntryActionTypes.CURRENT_USER_PASSWORD_UPDATE_ERROR_CLEAR, () =>
       clearCurrentUserPasswordUpdateErrorService(),
     ),
-    takeLatest(EntryActionTypes.CURRENT_USER_USERNAME_UPDATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.CURRENT_USER_USERNAME_UPDATE, ({ payload: { data } }) =>
       updateCurrentUserUsernameService(data),
     ),
-    takeLatest(EntryActionTypes.CURRENT_USER_USERNAME_UPDATE_ERROR_CLEAR, () =>
+    takeEvery(EntryActionTypes.CURRENT_USER_USERNAME_UPDATE_ERROR_CLEAR, () =>
       clearCurrentUserUsernameUpdateErrorService(),
     ),
-    takeLatest(EntryActionTypes.CURRENT_USER_AVATAR_UPDATE, ({ payload: { data } }) =>
+    takeEvery(EntryActionTypes.CURRENT_USER_AVATAR_UPDATE, ({ payload: { data } }) =>
       updateCurrentUserAvatarService(data),
     ),
-    takeLatest(EntryActionTypes.USER_DELETE, ({ payload: { id } }) => deleteUserService(id)),
-    takeLatest(EntryActionTypes.USER_TO_CARD_ADD, ({ payload: { id, cardId } }) =>
+    takeEvery(EntryActionTypes.USER_DELETE, ({ payload: { id } }) => deleteUserService(id)),
+    takeEvery(EntryActionTypes.USER_DELETE_HANDLE, ({ payload: { user } }) =>
+      handleUserDeleteService(user),
+    ),
+    takeEvery(EntryActionTypes.USER_TO_CARD_ADD, ({ payload: { id, cardId } }) =>
       addUserToCardService(id, cardId),
     ),
-    takeLatest(EntryActionTypes.USER_TO_CURRENT_CARD_ADD, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.USER_TO_CURRENT_CARD_ADD, ({ payload: { id } }) =>
       addUserToCurrentCardService(id),
     ),
-    takeLatest(EntryActionTypes.USER_FROM_CARD_REMOVE, ({ payload: { id, cardId } }) =>
+    takeEvery(EntryActionTypes.USER_TO_CARD_ADD_HANDLE, ({ payload: { cardMembership } }) =>
+      handleUserToCardAddService(cardMembership),
+    ),
+    takeEvery(EntryActionTypes.USER_FROM_CARD_REMOVE, ({ payload: { id, cardId } }) =>
       removeUserFromCardService(id, cardId),
     ),
-    takeLatest(EntryActionTypes.USER_FROM_CURRENT_CARD_REMOVE, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.USER_FROM_CURRENT_CARD_REMOVE, ({ payload: { id } }) =>
       removeUserFromCurrentCardService(id),
     ),
-    takeLatest(EntryActionTypes.USER_TO_FILTER_IN_CURRENT_BOARD_ADD, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.USER_FROM_CARD_REMOVE_HANDLE, ({ payload: { cardMembership } }) =>
+      handleUserFromCardRemoveService(cardMembership),
+    ),
+    takeEvery(EntryActionTypes.USER_TO_FILTER_IN_CURRENT_BOARD_ADD, ({ payload: { id } }) =>
       addUserToFilterInCurrentBoardService(id),
     ),
-    takeLatest(EntryActionTypes.USER_FROM_FILTER_IN_CURRENT_BOARD_REMOVE, ({ payload: { id } }) =>
+    takeEvery(EntryActionTypes.USER_FROM_FILTER_IN_CURRENT_BOARD_REMOVE, ({ payload: { id } }) =>
       removeUserFromFilterInCurrentBoardService(id),
     ),
   ]);