ref: Refactoring

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

@@ -1,22 +0,0 @@
-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,19 +0,0 @@
-import { all, takeEvery } from 'redux-saga/effects';
-
-import {
-  fetchActionsInCurrentCardService,
-  toggleActionsDetailsInCurrentCardService,
-} from '../services';
-import EntryActionTypes from '../../../constants/EntryActionTypes';
-
-export default function* actionsWatchers() {
-  yield all([
-    takeEvery(EntryActionTypes.ACTIONS_IN_CURRENT_CARD_FETCH, () =>
-      fetchActionsInCurrentCardService(),
-    ),
-    takeEvery(
-      EntryActionTypes.ACTIONS_DETAILS_IN_CURRENT_CARD_TOGGLE,
-      ({ payload: { isVisible } }) => toggleActionsDetailsInCurrentCardService(isVisible),
-    ),
-  ]);
-}

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

@@ -0,0 +1,25 @@
+import { all, takeEvery } from 'redux-saga/effects';
+
+import services from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* activitiesWatchers() {
+  yield all([
+    takeEvery(EntryActionTypes.ACTIVITIES_IN_CURRENT_CARD_FETCH, () =>
+      services.fetchActivitiesInCurrentCard(),
+    ),
+    takeEvery(
+      EntryActionTypes.ACTIVITIES_DETAILS_IN_CURRENT_CARD_TOGGLE,
+      ({ payload: { isVisible } }) => services.toggleActivitiesDetailsInCurrentCard(isVisible),
+    ),
+    takeEvery(EntryActionTypes.ACTIVITY_CREATE_HANDLE, ({ payload: { activity } }) =>
+      services.handleActivityCreate(activity),
+    ),
+    takeEvery(EntryActionTypes.ACTIVITY_UPDATE_HANDLE, ({ payload: { activity } }) =>
+      services.handleActivityUpdate(activity),
+    ),
+    takeEvery(EntryActionTypes.ACTIVITY_DELETE_HANDLE, ({ payload: { activity } }) =>
+      services.handleActivityDelete(activity),
+    ),
+  ]);
+}

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

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

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

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

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

@@ -1,38 +1,29 @@
 import { all, takeEvery } from 'redux-saga/effects';
 
-import {
-  createBoardInCurrentProjectService,
-  deleteBoardService,
-  fetchBoardService,
-  handleBoardCreateService,
-  handleBoardDeleteService,
-  handleBoardUpdateService,
-  moveBoardService,
-  updateBoardService,
-} from '../services';
+import services from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
-export default function* boardWatchers() {
+export default function* boardsWatchers() {
   yield all([
     takeEvery(EntryActionTypes.BOARD_IN_CURRENT_PROJECT_CREATE, ({ payload: { data } }) =>
-      createBoardInCurrentProjectService(data),
+      services.createBoardInCurrentProject(data),
     ),
     takeEvery(EntryActionTypes.BOARD_CREATE_HANDLE, ({ payload: { board } }) =>
-      handleBoardCreateService(board),
+      services.handleBoardCreate(board),
     ),
-    takeEvery(EntryActionTypes.BOARD_FETCH, ({ payload: { id } }) => fetchBoardService(id)),
+    takeEvery(EntryActionTypes.BOARD_FETCH, ({ payload: { id } }) => services.fetchBoard(id)),
     takeEvery(EntryActionTypes.BOARD_UPDATE, ({ payload: { id, data } }) =>
-      updateBoardService(id, data),
+      services.updateBoard(id, data),
     ),
     takeEvery(EntryActionTypes.BOARD_UPDATE_HANDLE, ({ payload: { board } }) =>
-      handleBoardUpdateService(board),
+      services.handleBoardUpdate(board),
     ),
     takeEvery(EntryActionTypes.BOARD_MOVE, ({ payload: { id, index } }) =>
-      moveBoardService(id, index),
+      services.moveBoard(id, index),
     ),
-    takeEvery(EntryActionTypes.BOARD_DELETE, ({ payload: { id } }) => deleteBoardService(id)),
+    takeEvery(EntryActionTypes.BOARD_DELETE, ({ payload: { id } }) => services.deleteBoard(id)),
     takeEvery(EntryActionTypes.BOARD_DELETE_HANDLE, ({ payload: { board } }) =>
-      handleBoardDeleteService(board),
+      services.handleBoardDelete(board),
     ),
   ]);
 }

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

@@ -1,54 +1,41 @@
 import { all, takeEvery } from 'redux-saga/effects';
 
-import {
-  createCardService,
-  deleteCardService,
-  deleteCurrentCardService,
-  handleCardCreateService,
-  handleCardDeleteService,
-  handleCardUpdateService,
-  moveCardService,
-  moveCurrentCardService,
-  transferCardService,
-  transferCurrentCardService,
-  updateCardService,
-  updateCurrentCardService,
-} from '../services';
+import services from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
-export default function* cardWatchers() {
+export default function* cardsWatchers() {
   yield all([
     takeEvery(EntryActionTypes.CARD_CREATE, ({ payload: { listId, data } }) =>
-      createCardService(listId, data),
+      services.createCard(listId, data),
     ),
     takeEvery(EntryActionTypes.CARD_CREATE_HANDLE, ({ payload: { card } }) =>
-      handleCardCreateService(card),
+      services.handleCardCreate(card),
     ),
     takeEvery(EntryActionTypes.CARD_UPDATE, ({ payload: { id, data } }) =>
-      updateCardService(id, data),
+      services.updateCard(id, data),
     ),
     takeEvery(EntryActionTypes.CURRENT_CARD_UPDATE, ({ payload: { data } }) =>
-      updateCurrentCardService(data),
+      services.updateCurrentCard(data),
     ),
     takeEvery(EntryActionTypes.CARD_UPDATE_HANDLE, ({ payload: { card } }) =>
-      handleCardUpdateService(card),
+      services.handleCardUpdate(card),
     ),
     takeEvery(EntryActionTypes.CARD_MOVE, ({ payload: { id, listId, index } }) =>
-      moveCardService(id, listId, index),
+      services.moveCard(id, listId, index),
     ),
     takeEvery(EntryActionTypes.CURRENT_CARD_MOVE, ({ payload: { listId, index } }) =>
-      moveCurrentCardService(listId, index),
+      services.moveCurrentCard(listId, index),
     ),
     takeEvery(EntryActionTypes.CARD_TRANSFER, ({ payload: { id, boardId, listId, index } }) =>
-      transferCardService(id, boardId, listId, index),
+      services.transferCard(id, boardId, listId, index),
     ),
     takeEvery(EntryActionTypes.CURRENT_CARD_TRANSFER, ({ payload: { boardId, listId, index } }) =>
-      transferCurrentCardService(boardId, listId, index),
+      services.transferCurrentCard(boardId, listId, index),
     ),
-    takeEvery(EntryActionTypes.CARD_DELETE, ({ payload: { id } }) => deleteCardService(id)),
-    takeEvery(EntryActionTypes.CURRENT_CARD_DELETE, () => deleteCurrentCardService()),
+    takeEvery(EntryActionTypes.CARD_DELETE, ({ payload: { id } }) => services.deleteCard(id)),
+    takeEvery(EntryActionTypes.CURRENT_CARD_DELETE, () => services.deleteCurrentCard()),
     takeEvery(EntryActionTypes.CARD_DELETE_HANDLE, ({ payload: { card } }) =>
-      handleCardDeleteService(card),
+      services.handleCardDelete(card),
     ),
   ]);
 }

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

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

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

@@ -0,0 +1,18 @@
+import { all, takeEvery } from 'redux-saga/effects';
+
+import services from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* commentActivitiesWatchers() {
+  yield all([
+    takeEvery(EntryActionTypes.COMMENT_ACTIVITY_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
+      services.createCommentActivityInCurrentCard(data),
+    ),
+    takeEvery(EntryActionTypes.COMMENT_ACTIVITY_UPDATE, ({ payload: { id, data } }) =>
+      services.updateCommentActivity(id, data),
+    ),
+    takeEvery(EntryActionTypes.COMMENT_ACTIVITY_DELETE, ({ payload: { id } }) =>
+      services.deleteCommentActivity(id),
+    ),
+  ]);
+}

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

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

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

@@ -1,41 +1,37 @@
 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 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';
+import modals from './modals';
+import users from './users';
+import projects from './projects';
+import projectManagers from './project-managers';
+import boards from './boards';
+import boardMemberships from './board-memberships';
+import labels from './labels';
+import lists from './lists';
+import cards from './cards';
+import tasks from './tasks';
+import attachments from './attachments';
+import activities from './activities';
+import commentActivities from './comment-activities';
+import notifications from './notifications';
 
 export default [
   router,
   socket,
-  login,
   core,
-  modal,
-  user,
-  project,
-  projectManager,
-  board,
-  boardMembership,
-  label,
-  list,
-  card,
-  task,
-  attachment,
-  actions,
-  action,
-  commentAction,
-  notification,
+  modals,
+  users,
+  projects,
+  projectManagers,
+  boards,
+  boardMemberships,
+  labels,
+  lists,
+  cards,
+  tasks,
+  attachments,
+  activities,
+  commentActivities,
+  notifications,
 ];

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

@@ -1,64 +1,49 @@
 import { all, takeEvery } from 'redux-saga/effects';
 
-import {
-  addLabelToCardService,
-  addLabelToCurrentCardService,
-  addLabelToFilterInCurrentBoardService,
-  createLabelInCurrentBoardService,
-  deleteLabelService,
-  handleLabelCreateService,
-  handleLabelDeleteService,
-  handleLabelFromCardRemoveService,
-  handleLabelToCardAddService,
-  handleLabelUpdateService,
-  removeLabelFromCardService,
-  removeLabelFromCurrentCardService,
-  removeLabelFromFilterInCurrentBoardService,
-  updateLabelService,
-} from '../services';
+import services from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
-export default function* labelWatchers() {
+export default function* labelsWatchers() {
   yield all([
     takeEvery(EntryActionTypes.LABEL_IN_CURRENT_BOARD_CREATE, ({ payload: { data } }) =>
-      createLabelInCurrentBoardService(data),
+      services.createLabelInCurrentBoard(data),
     ),
     takeEvery(EntryActionTypes.LABEL_CREATE_HANDLE, ({ payload: { label } }) =>
-      handleLabelCreateService(label),
+      services.handleLabelCreate(label),
     ),
     takeEvery(EntryActionTypes.LABEL_UPDATE, ({ payload: { id, data } }) =>
-      updateLabelService(id, data),
+      services.updateLabel(id, data),
     ),
     takeEvery(EntryActionTypes.LABEL_UPDATE_HANDLE, ({ payload: { label } }) =>
-      handleLabelUpdateService(label),
+      services.handleLabelUpdate(label),
     ),
-    takeEvery(EntryActionTypes.LABEL_DELETE, ({ payload: { id } }) => deleteLabelService(id)),
+    takeEvery(EntryActionTypes.LABEL_DELETE, ({ payload: { id } }) => services.deleteLabel(id)),
     takeEvery(EntryActionTypes.LABEL_DELETE_HANDLE, ({ payload: { label } }) =>
-      handleLabelDeleteService(label),
+      services.handleLabelDelete(label),
     ),
     takeEvery(EntryActionTypes.LABEL_TO_CARD_ADD, ({ payload: { id, cardId } }) =>
-      addLabelToCardService(id, cardId),
+      services.addLabelToCard(id, cardId),
     ),
     takeEvery(EntryActionTypes.LABEL_TO_CURRENT_CARD_ADD, ({ payload: { id } }) =>
-      addLabelToCurrentCardService(id),
+      services.addLabelToCurrentCard(id),
     ),
     takeEvery(EntryActionTypes.LABEL_TO_CARD_ADD_HANDLE, ({ payload: { cardLabel } }) =>
-      handleLabelToCardAddService(cardLabel),
+      services.handleLabelToCardAdd(cardLabel),
     ),
     takeEvery(EntryActionTypes.LABEL_FROM_CARD_REMOVE, ({ payload: { id, cardId } }) =>
-      removeLabelFromCardService(id, cardId),
+      services.removeLabelFromCard(id, cardId),
     ),
     takeEvery(EntryActionTypes.LABEL_FROM_CURRENT_CARD_REMOVE, ({ payload: { id } }) =>
-      removeLabelFromCurrentCardService(id),
+      services.removeLabelFromCurrentCard(id),
     ),
     takeEvery(EntryActionTypes.LABEL_FROM_CARD_REMOVE_HANDLE, ({ payload: { cardLabel } }) =>
-      handleLabelFromCardRemoveService(cardLabel),
+      services.handleLabelFromCardRemove(cardLabel),
     ),
     takeEvery(EntryActionTypes.LABEL_TO_FILTER_IN_CURRENT_BOARD_ADD, ({ payload: { id } }) =>
-      addLabelToFilterInCurrentBoardService(id),
+      services.addLabelToFilterInCurrentBoard(id),
     ),
     takeEvery(EntryActionTypes.LABEL_FROM_FILTER_IN_CURRENT_BOARD_REMOVE, ({ payload: { id } }) =>
-      removeLabelFromFilterInCurrentBoardService(id),
+      services.removeLabelFromFilterInCurrentBoard(id),
     ),
   ]);
 }

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

@@ -1,36 +1,28 @@
 import { all, takeEvery } from 'redux-saga/effects';
 
-import {
-  createListInCurrentBoardService,
-  deleteListService,
-  handleListCreateService,
-  handleListDeleteService,
-  handleListUpdateService,
-  moveListService,
-  updateListService,
-} from '../services';
+import services from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
-export default function* listWatchers() {
+export default function* listsWatchers() {
   yield all([
     takeEvery(EntryActionTypes.LIST_IN_CURRENT_BOARD_CREATE, ({ payload: { data } }) =>
-      createListInCurrentBoardService(data),
+      services.createListInCurrentBoard(data),
     ),
     takeEvery(EntryActionTypes.LIST_CREATE_HANDLE, ({ payload: { list } }) =>
-      handleListCreateService(list),
+      services.handleListCreate(list),
     ),
     takeEvery(EntryActionTypes.LIST_UPDATE, ({ payload: { id, data } }) =>
-      updateListService(id, data),
+      services.updateList(id, data),
     ),
     takeEvery(EntryActionTypes.LIST_UPDATE_HANDLE, ({ payload: { list } }) =>
-      handleListUpdateService(list),
+      services.handleListUpdate(list),
     ),
     takeEvery(EntryActionTypes.LIST_MOVE, ({ payload: { id, index } }) =>
-      moveListService(id, index),
+      services.moveList(id, index),
     ),
-    takeEvery(EntryActionTypes.LIST_DELETE, ({ payload: { id } }) => deleteListService(id)),
+    takeEvery(EntryActionTypes.LIST_DELETE, ({ payload: { id } }) => services.deleteList(id)),
     takeEvery(EntryActionTypes.LIST_DELETE_HANDLE, ({ payload: { list } }) =>
-      handleListDeleteService(list),
+      services.handleListDelete(list),
     ),
   ]);
 }

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

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

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

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

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

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

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

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

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

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

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

@@ -1,36 +1,28 @@
 import { all, takeEvery } from 'redux-saga/effects';
 
-import {
-  createProjectService,
-  deleteCurrentProjectService,
-  handleProjectCreateService,
-  handleProjectDeleteService,
-  handleProjectUpdateService,
-  updateCurrentProjectBackgroundImageService,
-  updateCurrentProjectService,
-} from '../services';
+import services from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
-export default function* projectWatchers() {
+export default function* projectsWatchers() {
   yield all([
     takeEvery(EntryActionTypes.PROJECT_CREATE, ({ payload: { data } }) =>
-      createProjectService(data),
+      services.createProject(data),
     ),
     takeEvery(EntryActionTypes.PROJECT_CREATE_HANDLE, ({ payload: { project } }) =>
-      handleProjectCreateService(project),
+      services.handleProjectCreate(project),
     ),
     takeEvery(EntryActionTypes.CURRENT_PROJECT_UPDATE, ({ payload: { data } }) =>
-      updateCurrentProjectService(data),
+      services.updateCurrentProject(data),
     ),
     takeEvery(EntryActionTypes.PROJECT_UPDATE_HANDLE, ({ payload: { project } }) =>
-      handleProjectUpdateService(project),
+      services.handleProjectUpdate(project),
     ),
     takeEvery(EntryActionTypes.CURRENT_PROJECT_BACKGROUND_IMAGE_UPDATE, ({ payload: { data } }) =>
-      updateCurrentProjectBackgroundImageService(data),
+      services.updateCurrentProjectBackgroundImage(data),
     ),
-    takeEvery(EntryActionTypes.CURRENT_PROJECT_DELETE, () => deleteCurrentProjectService()),
+    takeEvery(EntryActionTypes.CURRENT_PROJECT_DELETE, () => services.deleteCurrentProject()),
     takeEvery(EntryActionTypes.PROJECT_DELETE_HANDLE, ({ payload: { project } }) =>
-      handleProjectDeleteService(project),
+      services.handleProjectDelete(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 { handleLocationChangeService } from '../services';
+import services from '../services';
 
 export default function* routerWatchers() {
-  yield takeEvery(LOCATION_CHANGE, () => handleLocationChangeService());
+  yield takeEvery(LOCATION_CHANGE, () => services.handleLocationChange());
 }

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

@@ -1,208 +1,168 @@
 import { eventChannel } from 'redux-saga';
 import { all, call, cancelled, put, take, takeEvery } from 'redux-saga/effects';
 
-import { handleSocketDisconnectService, handleSocketReconnectService } from '../services';
-import {
-  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 services from '../services';
+import entryActions from '../../../entry-actions';
 import api, { socket } from '../../../api';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
 const createSocketEventsChannel = () =>
   eventChannel((emit) => {
     const handleDisconnect = () => {
-      emit(handleSocketDisconnectAction());
+      emit(entryActions.handleSocketDisconnect());
     };
 
     const handleReconnect = () => {
-      emit(handleSocketReconnectAction());
+      emit(entryActions.handleSocketReconnect());
     };
 
     const handleUserCreate = ({ item }) => {
-      emit(handleUserCreateAction(item));
+      emit(entryActions.handleUserCreate(item));
     };
 
     const handleUserUpdate = ({ item }) => {
-      emit(handleUserUpdateAction(item));
+      emit(entryActions.handleUserUpdate(item));
     };
 
     const handleUserDelete = ({ item }) => {
-      emit(handleUserDeleteAction(item));
+      emit(entryActions.handleUserDelete(item));
     };
 
     const handleProjectCreate = ({ item }) => {
-      emit(handleProjectCreateAction(item));
+      emit(entryActions.handleProjectCreate(item));
     };
 
     const handleProjectUpdate = ({ item }) => {
-      emit(handleProjectUpdateAction(item));
+      emit(entryActions.handleProjectUpdate(item));
     };
 
     const handleProjectDelete = ({ item }) => {
-      emit(handleProjectDeleteAction(item));
+      emit(entryActions.handleProjectDelete(item));
     };
 
     const handleProjectManagerCreate = ({ item }) => {
-      emit(handleProjectManagerCreateAction(item));
+      emit(entryActions.handleProjectManagerCreate(item));
     };
 
     const handleProjectManagerDelete = ({ item }) => {
-      emit(handleProjectManagerDeleteAction(item));
+      emit(entryActions.handleProjectManagerDelete(item));
     };
 
     const handleBoardCreate = ({ item }) => {
-      emit(handleBoardCreateAction(item));
+      emit(entryActions.handleBoardCreate(item));
     };
 
     const handleBoardUpdate = ({ item }) => {
-      emit(handleBoardUpdateAction(item));
+      emit(entryActions.handleBoardUpdate(item));
     };
 
     const handleBoardDelete = ({ item }) => {
-      emit(handleBoardDeleteAction(item));
+      emit(entryActions.handleBoardDelete(item));
     };
 
     const handleBoardMembershipCreate = ({ item }) => {
-      emit(handleBoardMembershipCreateAction(item));
+      emit(entryActions.handleBoardMembershipCreate(item));
     };
 
     const handleBoardMembershipDelete = ({ item }) => {
-      emit(handleBoardMembershipDeleteAction(item));
+      emit(entryActions.handleBoardMembershipDelete(item));
     };
 
     const handleListCreate = ({ item }) => {
-      emit(handleListCreateAction(item));
+      emit(entryActions.handleListCreate(item));
     };
 
     const handleListUpdate = ({ item }) => {
-      emit(handleListUpdateAction(item));
+      emit(entryActions.handleListUpdate(item));
     };
 
     const handleListDelete = ({ item }) => {
-      emit(handleListDeleteAction(item));
+      emit(entryActions.handleListDelete(item));
     };
 
     const handleLabelCreate = ({ item }) => {
-      emit(handleLabelCreateAction(item));
+      emit(entryActions.handleLabelCreate(item));
     };
 
     const handleLabelUpdate = ({ item }) => {
-      emit(handleLabelUpdateAction(item));
+      emit(entryActions.handleLabelUpdate(item));
     };
 
     const handleLabelDelete = ({ item }) => {
-      emit(handleLabelDeleteAction(item));
+      emit(entryActions.handleLabelDelete(item));
     };
 
     const handleCardCreate = api.makeHandleCardCreate(({ item }) => {
-      emit(handleCardCreateAction(item));
+      emit(entryActions.handleCardCreate(item));
     });
 
     const handleCardUpdate = api.makeHandleCardUpdate(({ item }) => {
-      emit(handleCardUpdateAction(item));
+      emit(entryActions.handleCardUpdate(item));
     });
 
     const handleCardDelete = api.makeHandleCardDelete(({ item }) => {
-      emit(handleCardDeleteAction(item));
+      emit(entryActions.handleCardDelete(item));
     });
 
     const handleUserToCardAdd = ({ item }) => {
-      emit(handleUserToCardAddAction(item));
+      emit(entryActions.handleUserToCardAdd(item));
     };
 
     const handleUserFromCardRemove = ({ item }) => {
-      emit(handleUserFromCardRemoveAction(item));
+      emit(entryActions.handleUserFromCardRemove(item));
     };
 
     const handleLabelToCardAdd = ({ item }) => {
-      emit(handleLabelToCardAddAction(item));
+      emit(entryActions.handleLabelToCardAdd(item));
     };
 
     const handleLabelFromCardRemove = ({ item }) => {
-      emit(handleLabelFromCardRemoveAction(item));
+      emit(entryActions.handleLabelFromCardRemove(item));
     };
 
     const handleTaskCreate = ({ item }) => {
-      emit(handleTaskCreateAction(item));
+      emit(entryActions.handleTaskCreate(item));
     };
 
     const handleTaskUpdate = ({ item }) => {
-      emit(handleTaskUpdateAction(item));
+      emit(entryActions.handleTaskUpdate(item));
     };
 
     const handleTaskDelete = ({ item }) => {
-      emit(handleTaskDeleteAction(item));
+      emit(entryActions.handleTaskDelete(item));
     };
 
     const handleAttachmentCreate = api.makeHandleAttachmentCreate(({ item, requestId }) => {
-      emit(handleAttachmentCreateAction(item, requestId));
+      emit(entryActions.handleAttachmentCreate(item, requestId));
     });
 
     const handleAttachmentUpdate = api.makeHandleAttachmentUpdate(({ item }) => {
-      emit(handleAttachmentUpdateAction(item));
+      emit(entryActions.handleAttachmentUpdate(item));
     });
 
     const handleAttachmentDelete = api.makeHandleAttachmentDelete(({ item }) => {
-      emit(handleAttachmentDeleteAction(item));
+      emit(entryActions.handleAttachmentDelete(item));
     });
 
-    const handleActionCreate = api.makeHandleActionCreate(({ item }) => {
-      emit(handleActionCreateAction(item));
+    const handleActivityCreate = api.makeHandleActivityCreate(({ item }) => {
+      emit(entryActions.handleActivityCreate(item));
     });
 
-    const handleActionUpdate = api.makeHandleActionUpdate(({ item }) => {
-      emit(handleActionUpdateAction(item));
+    const handleActivityUpdate = api.makeHandleActivityUpdate(({ item }) => {
+      emit(entryActions.handleActivityUpdate(item));
     });
 
-    const handleActionDelete = api.makeHandleActionDelete(({ item }) => {
-      emit(handleActionDeleteAction(item));
+    const handleActivityDelete = api.makeHandleActivityDelete(({ item }) => {
+      emit(entryActions.handleActivityDelete(item));
     });
 
-    const handleNotificationCreate = ({ item }) => {
-      emit(handleNotificationCreateAction(item));
-    };
+    const handleNotificationCreate = api.makeHandleNotificationCreate(({ item }) => {
+      emit(entryActions.handleNotificationCreate(item));
+    });
 
-    const handleNotificationDelete = ({ item }) => {
-      emit(handleNotificationDeleteAction(item));
-    };
+    const handleNotificationUpdate = api.makeHandleNotificationUpdate(({ item }) => {
+      emit(entryActions.handleNotificationDelete(item));
+    });
 
     socket.on('disconnect', handleDisconnect);
     socket.on('reconnect', handleReconnect);
@@ -251,12 +211,12 @@ const createSocketEventsChannel = () =>
     socket.on('attachmentUpdate', handleAttachmentUpdate);
     socket.on('attachmentDelete', handleAttachmentDelete);
 
-    socket.on('actionCreate', handleActionCreate);
-    socket.on('actionUpdate', handleActionUpdate);
-    socket.on('actionDelete', handleActionDelete);
+    socket.on('actionCreate', handleActivityCreate);
+    socket.on('actionUpdate', handleActivityUpdate);
+    socket.on('actionDelete', handleActivityDelete);
 
     socket.on('notificationCreate', handleNotificationCreate);
-    socket.on('notificationUpdate', handleNotificationDelete);
+    socket.on('notificationUpdate', handleNotificationUpdate);
 
     return () => {
       socket.off('disconnect', handleDisconnect);
@@ -306,21 +266,23 @@ const createSocketEventsChannel = () =>
       socket.off('attachmentUpdate', handleAttachmentUpdate);
       socket.off('attachmentDelete', handleAttachmentDelete);
 
-      socket.off('actionCreate', handleActionCreate);
-      socket.off('actionUpdate', handleActionUpdate);
-      socket.off('actionDelete', handleActionDelete);
+      socket.off('actionCreate', handleActivityCreate);
+      socket.off('actionUpdate', handleActivityUpdate);
+      socket.off('actionDelete', handleActivityDelete);
 
       socket.off('notificationCreate', handleNotificationCreate);
-      socket.off('notificationUpdate', handleNotificationDelete);
+      socket.off('notificationUpdate', handleNotificationUpdate);
     };
   });
 
 export default function* socketWatchers() {
   yield all([
     yield takeEvery(EntryActionTypes.SOCKET_DISCONNECT_HANDLE, () =>
-      handleSocketDisconnectService(),
+      services.handleSocketDisconnect(),
+    ),
+    yield takeEvery(EntryActionTypes.SOCKET_RECONNECT_HANDLE, () =>
+      services.handleSocketReconnect(),
     ),
-    yield takeEvery(EntryActionTypes.SOCKET_RECONNECT_HANDLE, () => handleSocketReconnectService()),
   ]);
 
   const socketEventsChannel = yield call(createSocketEventsChannel);

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

@@ -1,36 +1,28 @@
 import { all, takeEvery } from 'redux-saga/effects';
 
-import {
-  createTaskInCurrentCardService,
-  deleteTaskService,
-  handleTaskCreateService,
-  handleTaskDeleteService,
-  handleTaskUpdateService,
-  moveTaskService,
-  updateTaskService,
-} from '../services';
+import services from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
-export default function* taskWatchers() {
+export default function* tasksWatchers() {
   yield all([
     takeEvery(EntryActionTypes.TASK_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
-      createTaskInCurrentCardService(data),
+      services.createTaskInCurrentCard(data),
     ),
     takeEvery(EntryActionTypes.TASK_CREATE_HANDLE, ({ payload: { task } }) =>
-      handleTaskCreateService(task),
+      services.handleTaskCreate(task),
     ),
     takeEvery(EntryActionTypes.TASK_UPDATE, ({ payload: { id, data } }) =>
-      updateTaskService(id, data),
+      services.updateTask(id, data),
     ),
     takeEvery(EntryActionTypes.TASK_UPDATE_HANDLE, ({ payload: { task } }) =>
-      handleTaskUpdateService(task),
+      services.handleTaskUpdate(task),
     ),
     takeEvery(EntryActionTypes.TASK_MOVE, ({ payload: { id, index } }) =>
-      moveTaskService(id, index),
+      services.moveTask(id, index),
     ),
-    takeEvery(EntryActionTypes.TASK_DELETE, ({ payload: { id } }) => deleteTaskService(id)),
+    takeEvery(EntryActionTypes.TASK_DELETE, ({ payload: { id } }) => services.deleteTask(id)),
     takeEvery(EntryActionTypes.TASK_DELETE_HANDLE, ({ payload: { task } }) =>
-      handleTaskDeleteService(task),
+      services.handleTaskDelete(task),
     ),
   ]);
 }

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

@@ -1,124 +1,93 @@
 import { all, takeEvery } from 'redux-saga/effects';
 
-import {
-  addUserToCardService,
-  addUserToCurrentCardService,
-  addUserToFilterInCurrentBoardService,
-  clearCurrentUserEmailUpdateErrorService,
-  clearCurrentUserPasswordUpdateErrorService,
-  clearCurrentUserUsernameUpdateErrorService,
-  clearUserCreateErrorService,
-  clearUserEmailUpdateErrorService,
-  clearUserPasswordUpdateErrorService,
-  clearUserUsernameUpdateErrorService,
-  createUserService,
-  deleteUserService,
-  handleUserCreateService,
-  handleUserDeleteService,
-  handleUserFromCardRemoveService,
-  handleUserToCardAddService,
-  handleUserUpdateService,
-  removeUserFromCardService,
-  removeUserFromCurrentCardService,
-  removeUserFromFilterInCurrentBoardService,
-  updateUserService,
-  updateCurrentUserAvatarService,
-  updateCurrentUserEmailService,
-  updateCurrentUserLanguageService,
-  updateCurrentUserPasswordService,
-  updateCurrentUserService,
-  updateCurrentUserUsernameService,
-  updateUserEmailService,
-  updateUserPasswordService,
-  updateUserUsernameService,
-} from '../services';
+import services from '../services';
 import EntryActionTypes from '../../../constants/EntryActionTypes';
 
-export default function* userWatchers() {
+export default function* usersWatchers() {
   yield all([
-    takeEvery(EntryActionTypes.USER_CREATE, ({ payload: { data } }) => createUserService(data)),
+    takeEvery(EntryActionTypes.USER_CREATE, ({ payload: { data } }) => services.createUser(data)),
     takeEvery(EntryActionTypes.USER_CREATE_HANDLE, ({ payload: { user } }) =>
-      handleUserCreateService(user),
+      services.handleUserCreate(user),
     ),
-    takeEvery(EntryActionTypes.USER_CREATE_ERROR_CLEAR, () => clearUserCreateErrorService()),
+    takeEvery(EntryActionTypes.USER_CREATE_ERROR_CLEAR, () => services.clearUserCreateError()),
     takeEvery(EntryActionTypes.USER_UPDATE, ({ payload: { id, data } }) =>
-      updateUserService(id, data),
+      services.updateUser(id, data),
     ),
     takeEvery(EntryActionTypes.CURRENT_USER_UPDATE, ({ payload: { data } }) =>
-      updateCurrentUserService(data),
+      services.updateCurrentUser(data),
     ),
     takeEvery(EntryActionTypes.USER_UPDATE_HANDLE, ({ payload: { user } }) =>
-      handleUserUpdateService(user),
+      services.handleUserUpdate(user),
     ),
     takeEvery(EntryActionTypes.CURRENT_USER_LANGUAGE_UPDATE, ({ payload: { language } }) =>
-      updateCurrentUserLanguageService(language),
+      services.updateCurrentUserLanguage(language),
     ),
     takeEvery(EntryActionTypes.USER_EMAIL_UPDATE, ({ payload: { id, data } }) =>
-      updateUserEmailService(id, data),
+      services.updateUserEmail(id, data),
     ),
     takeEvery(EntryActionTypes.CURRENT_USER_EMAIL_UPDATE, ({ payload: { data } }) =>
-      updateCurrentUserEmailService(data),
+      services.updateCurrentUserEmail(data),
     ),
     takeEvery(EntryActionTypes.USER_EMAIL_UPDATE_ERROR_CLEAR, ({ payload: { id } }) =>
-      clearUserEmailUpdateErrorService(id),
+      services.clearUserEmailUpdateError(id),
     ),
     takeEvery(EntryActionTypes.CURRENT_USER_EMAIL_UPDATE_ERROR_CLEAR, () =>
-      clearCurrentUserEmailUpdateErrorService(),
+      services.clearCurrentUserEmailUpdateError(),
     ),
     takeEvery(EntryActionTypes.USER_PASSWORD_UPDATE, ({ payload: { id, data } }) =>
-      updateUserPasswordService(id, data),
+      services.updateUserPassword(id, data),
     ),
     takeEvery(EntryActionTypes.CURRENT_USER_PASSWORD_UPDATE, ({ payload: { data } }) =>
-      updateCurrentUserPasswordService(data),
+      services.updateCurrentUserPassword(data),
     ),
     takeEvery(EntryActionTypes.USER_PASSWORD_UPDATE_ERROR_CLEAR, ({ payload: { id } }) =>
-      clearUserPasswordUpdateErrorService(id),
+      services.clearUserPasswordUpdateError(id),
     ),
     takeEvery(EntryActionTypes.CURRENT_USER_PASSWORD_UPDATE_ERROR_CLEAR, () =>
-      clearCurrentUserPasswordUpdateErrorService(),
+      services.clearCurrentUserPasswordUpdateError(),
     ),
     takeEvery(EntryActionTypes.USER_USERNAME_UPDATE, ({ payload: { id, data } }) =>
-      updateUserUsernameService(id, data),
+      services.updateUserUsername(id, data),
     ),
     takeEvery(EntryActionTypes.CURRENT_USER_USERNAME_UPDATE, ({ payload: { data } }) =>
-      updateCurrentUserUsernameService(data),
+      services.updateCurrentUserUsername(data),
     ),
     takeEvery(EntryActionTypes.USER_USERNAME_UPDATE_ERROR_CLEAR, ({ payload: { id } }) =>
-      clearUserUsernameUpdateErrorService(id),
+      services.clearUserUsernameUpdateError(id),
     ),
     takeEvery(EntryActionTypes.CURRENT_USER_USERNAME_UPDATE_ERROR_CLEAR, () =>
-      clearCurrentUserUsernameUpdateErrorService(),
+      services.clearCurrentUserUsernameUpdateError(),
     ),
     takeEvery(EntryActionTypes.CURRENT_USER_AVATAR_UPDATE, ({ payload: { data } }) =>
-      updateCurrentUserAvatarService(data),
+      services.updateCurrentUserAvatar(data),
     ),
-    takeEvery(EntryActionTypes.USER_DELETE, ({ payload: { id } }) => deleteUserService(id)),
+    takeEvery(EntryActionTypes.USER_DELETE, ({ payload: { id } }) => services.deleteUser(id)),
     takeEvery(EntryActionTypes.USER_DELETE_HANDLE, ({ payload: { user } }) =>
-      handleUserDeleteService(user),
+      services.handleUserDelete(user),
     ),
     takeEvery(EntryActionTypes.USER_TO_CARD_ADD, ({ payload: { id, cardId } }) =>
-      addUserToCardService(id, cardId),
+      services.addUserToCard(id, cardId),
     ),
     takeEvery(EntryActionTypes.USER_TO_CURRENT_CARD_ADD, ({ payload: { id } }) =>
-      addUserToCurrentCardService(id),
+      services.addUserToCurrentCard(id),
     ),
     takeEvery(EntryActionTypes.USER_TO_CARD_ADD_HANDLE, ({ payload: { cardMembership } }) =>
-      handleUserToCardAddService(cardMembership),
+      services.handleUserToCardAdd(cardMembership),
     ),
     takeEvery(EntryActionTypes.USER_FROM_CARD_REMOVE, ({ payload: { id, cardId } }) =>
-      removeUserFromCardService(id, cardId),
+      services.removeUserFromCard(id, cardId),
     ),
     takeEvery(EntryActionTypes.USER_FROM_CURRENT_CARD_REMOVE, ({ payload: { id } }) =>
-      removeUserFromCurrentCardService(id),
+      services.removeUserFromCurrentCard(id),
     ),
     takeEvery(EntryActionTypes.USER_FROM_CARD_REMOVE_HANDLE, ({ payload: { cardMembership } }) =>
-      handleUserFromCardRemoveService(cardMembership),
+      services.handleUserFromCardRemove(cardMembership),
     ),
     takeEvery(EntryActionTypes.USER_TO_FILTER_IN_CURRENT_BOARD_ADD, ({ payload: { id } }) =>
-      addUserToFilterInCurrentBoardService(id),
+      services.addUserToFilterInCurrentBoard(id),
     ),
     takeEvery(EntryActionTypes.USER_FROM_FILTER_IN_CURRENT_BOARD_REMOVE, ({ payload: { id } }) =>
-      removeUserFromFilterInCurrentBoardService(id),
+      services.removeUserFromFilterInCurrentBoard(id),
     ),
   ]);
 }