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

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

@@ -0,0 +1,15 @@
+import { put } from 'redux-saga/effects';
+
+import { handleActionCreate, handleActionDelete, handleActionUpdate } from '../../../actions';
+
+export function* handleActionCreateService(action) {
+  yield put(handleActionCreate(action));
+}
+
+export function* handleActionUpdateService(action) {
+  yield put(handleActionUpdate(action));
+}
+
+export function* handleActionDeleteService(action) {
+  yield put(handleActionDelete(action));
+}

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

@@ -1,12 +1,31 @@
-import { call, select } from 'redux-saga/effects';
+import { call, put, select } from 'redux-saga/effects';
 
-import { fetchActionsRequest } from '../requests';
+import request from '../request';
 import { lastActionIdByCardIdSelector, pathSelector } from '../../../selectors';
+import { fetchActions } from '../../../actions';
+import api from '../../../api';
 
 export function* fetchActionsService(cardId) {
   const lastId = yield select(lastActionIdByCardIdSelector, cardId);
 
-  yield call(fetchActionsRequest, cardId, lastId);
+  yield put(fetchActions(cardId));
+
+  let actions;
+  let users;
+
+  try {
+    ({
+      items: actions,
+      included: { users },
+    } = yield call(request, api.getActions, cardId, {
+      beforeId: lastId,
+    }));
+  } catch (error) {
+    yield put(fetchActions.failure(cardId, error));
+    return;
+  }
+
+  yield put(fetchActions.success(cardId, actions, users));
 }
 
 export function* fetchActionsInCurrentCardService() {

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

@@ -1,12 +1,16 @@
 import { call, put, select } from 'redux-saga/effects';
 
+import request from '../request';
+import { isAttachmentWithIdExistsSelector, pathSelector } from '../../../selectors';
 import {
-  createAttachmentRequest,
-  deleteAttachmentRequest,
-  updateAttachmentRequest,
-} from '../requests';
-import { pathSelector } from '../../../selectors';
-import { createAttachment, deleteAttachment, updateAttachment } from '../../../actions';
+  createAttachment,
+  deleteAttachment,
+  handleAttachmentCreate,
+  handleAttachmentDelete,
+  handleAttachmentUpdate,
+  updateAttachment,
+} from '../../../actions';
+import api from '../../../api';
 import { createLocalId } from '../../../utils/local-id';
 
 export function* createAttachmentService(cardId, data) {
@@ -20,7 +24,15 @@ export function* createAttachmentService(cardId, data) {
     }),
   );
 
-  yield call(createAttachmentRequest, cardId, localId, data);
+  let attachment;
+  try {
+    ({ item: attachment } = yield call(request, api.createAttachment, cardId, data, localId));
+  } catch (error) {
+    yield put(createAttachment.failure(localId, error));
+    return;
+  }
+
+  yield put(createAttachment.success(localId, attachment));
 }
 
 export function* createAttachmentInCurrentCardService(data) {
@@ -29,12 +41,46 @@ export function* createAttachmentInCurrentCardService(data) {
   yield call(createAttachmentService, cardId, data);
 }
 
+export function* handleAttachmentCreateService(attachment, requestId) {
+  const isExists = yield select(isAttachmentWithIdExistsSelector, requestId);
+
+  if (!isExists) {
+    yield put(handleAttachmentCreate(attachment));
+  }
+}
+
 export function* updateAttachmentService(id, data) {
   yield put(updateAttachment(id, data));
-  yield call(updateAttachmentRequest, id, data);
+
+  let attachment;
+  try {
+    ({ item: attachment } = yield call(request, api.updateAttachment, id, data));
+  } catch (error) {
+    yield put(updateAttachment.failure(id, error));
+    return;
+  }
+
+  yield put(updateAttachment.success(attachment));
+}
+
+export function* handleAttachmentUpdateService(attachment) {
+  yield put(handleAttachmentUpdate(attachment));
 }
 
 export function* deleteAttachmentService(id) {
   yield put(deleteAttachment(id));
-  yield call(deleteAttachmentRequest, id);
+
+  let attachment;
+  try {
+    ({ item: attachment } = yield call(request, api.deleteAttachment, id));
+  } catch (error) {
+    yield put(deleteAttachment.failure(id, error));
+    return;
+  }
+
+  yield put(deleteAttachment.success(attachment));
+}
+
+export function* handleAttachmentDeleteService(attachment) {
+  yield put(handleAttachmentDelete(attachment));
 }

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

@@ -0,0 +1,186 @@
+import { call, put, select } from 'redux-saga/effects';
+
+import { goToProjectService } from './router';
+import request from '../request';
+import { fetchBoardByCurrentPathRequest } from '../requests';
+import {
+  boardMembershipByIdSelector,
+  currentUserIdSelector,
+  isCurrentUserManagerForCurrentProjectSelector,
+  notificationsByCardIdSelector,
+  pathSelector,
+} from '../../../selectors';
+import {
+  createBoardMembership,
+  deleteBoardMembership,
+  handleBoardMembershipCreate,
+  handleBoardMembershipDelete,
+} from '../../../actions';
+import api from '../../../api';
+import { createLocalId } from '../../../utils/local-id';
+import mergeRecords from '../../../utils/merge-records';
+
+export function* createBoardMembershipService(boardId, data) {
+  const localId = yield call(createLocalId);
+
+  yield put(
+    createBoardMembership({
+      ...data,
+      boardId,
+      id: localId,
+    }),
+  );
+
+  let boardMembership;
+  try {
+    ({ item: boardMembership } = yield call(request, api.createBoardMembership, boardId, data));
+  } catch (error) {
+    yield put(createBoardMembership.failure(localId, error));
+    return;
+  }
+
+  yield put(createBoardMembership.success(localId, boardMembership));
+}
+
+export function* createMembershipInCurrentBoardService(data) {
+  const { boardId } = yield select(pathSelector);
+
+  yield call(createBoardMembershipService, boardId, data);
+}
+
+export function* handleBoardMembershipCreateService(boardMembership) {
+  const currentUserId = yield select(currentUserIdSelector);
+  const isCurrentUser = boardMembership.userId === currentUserId;
+
+  let user;
+  let project;
+  let board1;
+  let users1;
+  let users2;
+  let projectManagers;
+  let boards;
+  let boardMemberships1;
+  let boardMemberships2;
+  let labels;
+  let lists;
+  let cards;
+  let cardMemberships;
+  let cardLabels;
+  let tasks;
+  let attachments;
+  let notifications;
+
+  if (isCurrentUser) {
+    let board2;
+    try {
+      ({ item: board2 } = yield call(request, api.getBoard, boardMembership.boardId));
+    } catch {
+      return;
+    }
+
+    const { boardId } = yield select(pathSelector);
+
+    yield put(handleBoardMembershipCreate.fetchProject(board2.projectId, currentUserId, boardId));
+
+    try {
+      ({
+        item: project,
+        included: { users: users1, projectManagers, boards, boardMemberships: boardMemberships1 },
+      } = yield call(request, api.getProject, board2.projectId));
+    } catch {
+      return;
+    }
+
+    let body;
+    try {
+      body = yield call(fetchBoardByCurrentPathRequest);
+    } catch {} // eslint-disable-line no-empty
+
+    if (body && body.project && body.project.id === board2.projectId) {
+      ({
+        project,
+        board: board1,
+        users: users2,
+        boardMemberships: boardMemberships2,
+        labels,
+        lists,
+        cards,
+        cardMemberships,
+        cardLabels,
+        tasks,
+        attachments,
+      } = body);
+
+      if (body.card) {
+        notifications = yield select(notificationsByCardIdSelector, body.card.id);
+      }
+    }
+  } else {
+    try {
+      ({ item: user } = yield call(request, api.getUser, boardMembership.userId));
+    } catch {
+      return;
+    }
+  }
+
+  yield put(
+    handleBoardMembershipCreate(
+      boardMembership,
+      project,
+      board1,
+      isCurrentUser ? mergeRecords(users1, users2) : [user],
+      projectManagers,
+      boards,
+      mergeRecords(boardMemberships1, boardMemberships2),
+      labels,
+      lists,
+      cards,
+      cardMemberships,
+      cardLabels,
+      tasks,
+      attachments,
+      notifications,
+    ),
+  );
+}
+
+export function* deleteBoardMembershipService(id) {
+  let boardMembership = yield select(boardMembershipByIdSelector, id);
+
+  const currentUserId = yield select(currentUserIdSelector);
+  const { boardId, projectId } = yield select(pathSelector);
+
+  if (boardMembership.userId === currentUserId && boardMembership.boardId === boardId) {
+    const isCurrentUserManager = yield select(isCurrentUserManagerForCurrentProjectSelector);
+
+    if (!isCurrentUserManager) {
+      yield call(goToProjectService, projectId);
+    }
+  }
+
+  yield put(deleteBoardMembership(id));
+
+  try {
+    ({ item: boardMembership } = yield call(request, api.deleteBoardMembership, id));
+  } catch (error) {
+    yield put(deleteBoardMembership.failure(id, error));
+    return;
+  }
+
+  yield put(deleteBoardMembership.success(boardMembership));
+}
+
+export function* handleBoardMembershipDeleteService(boardMembership) {
+  const currentUserId = yield select(currentUserIdSelector);
+  const { boardId, projectId } = yield select(pathSelector);
+
+  if (boardMembership.userId === currentUserId && boardMembership.boardId === boardId) {
+    const isCurrentUserManager = yield select(isCurrentUserManagerForCurrentProjectSelector);
+
+    if (!isCurrentUserManager) {
+      yield call(goToProjectService, projectId);
+    }
+  }
+
+  yield put(handleBoardMembershipDelete(boardMembership));
+}

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

@@ -1,14 +1,18 @@
 import { call, put, select } from 'redux-saga/effects';
 
 import { goToBoardService, goToProjectService } from './router';
-import {
-  createBoardRequest,
-  deleteBoardRequest,
-  fetchBoardRequest,
-  updateBoardRequest,
-} from '../requests';
+import request from '../request';
 import { boardByIdSelector, nextBoardPositionSelector, pathSelector } from '../../../selectors';
-import { createBoard, deleteBoard, updateBoard } from '../../../actions';
+import {
+  createBoard,
+  deleteBoard,
+  fetchBoard,
+  handleBoardCreate,
+  handleBoardDelete,
+  handleBoardUpdate,
+  updateBoard,
+} from '../../../actions';
+import api from '../../../api';
 import { createLocalId } from '../../../utils/local-id';
 
 export function* createBoardService(projectId, data) {
@@ -27,14 +31,21 @@ export function* createBoardService(projectId, data) {
     }),
   );
 
-  const {
-    success,
-    payload: { board },
-  } = yield call(createBoardRequest, projectId, localId, nextData);
+  let board;
+  let boardMemberships;
 
-  if (success) {
-    yield call(goToBoardService, board.id);
+  try {
+    ({
+      item: board,
+      included: { boardMemberships },
+    } = yield call(request, api.createBoard, projectId, nextData));
+  } catch (error) {
+    yield put(createBoard.failure(localId, error));
+    return;
   }
+
+  yield put(createBoard.success(localId, board, boardMemberships));
+  yield call(goToBoardService, board.id);
 }
 
 export function* createBoardInCurrentProjectService(data) {
@@ -43,13 +54,79 @@ export function* createBoardInCurrentProjectService(data) {
   yield call(createBoardService, projectId, data);
 }
 
-export function* fetchBoard(id) {
-  yield call(fetchBoardRequest, id);
+export function* handleBoardCreateService(board) {
+  yield put(handleBoardCreate(board));
+}
+
+export function* fetchBoardService(id) {
+  yield put(fetchBoard(id));
+
+  let board;
+  let users;
+  let projects;
+  let boardMemberships;
+  let labels;
+  let lists;
+  let cards;
+  let cardMemberships;
+  let cardLabels;
+  let tasks;
+  let attachments;
+
+  try {
+    ({
+      item: board,
+      included: {
+        users,
+        projects,
+        boardMemberships,
+        labels,
+        lists,
+        cards,
+        cardMemberships,
+        cardLabels,
+        tasks,
+        attachments,
+      },
+    } = yield call(request, api.getBoard, id));
+  } catch (error) {
+    yield put(fetchBoard.failure(id, error));
+    return;
+  }
+
+  yield put(
+    fetchBoard.success(
+      board,
+      users,
+      projects,
+      boardMemberships,
+      labels,
+      lists,
+      cards,
+      cardMemberships,
+      cardLabels,
+      tasks,
+      attachments,
+    ),
+  );
 }
 
 export function* updateBoardService(id, data) {
   yield put(updateBoard(id, data));
-  yield call(updateBoardRequest, id, data);
+
+  let board;
+  try {
+    ({ item: board } = yield call(request, api.updateBoard, id, data));
+  } catch (error) {
+    yield put(updateBoard.failure(id, error));
+    return;
+  }
+
+  yield put(updateBoard.success(board));
+}
+
+export function* handleBoardUpdateService(board) {
+  yield put(handleBoardUpdate(board));
 }
 
 export function* moveBoardService(id, index) {
@@ -69,5 +146,24 @@ export function* deleteBoardService(id) {
   }
 
   yield put(deleteBoard(id));
-  yield call(deleteBoardRequest, id);
+
+  let board;
+  try {
+    ({ item: board } = yield call(request, api.deleteBoard, id));
+  } catch (error) {
+    yield put(deleteBoard.failure(id, error));
+    return;
+  }
+
+  yield put(deleteBoard.success(board));
+}
+
+export function* handleBoardDeleteService(board) {
+  const { boardId, projectId } = yield select(pathSelector);
+
+  if (board.id === boardId) {
+    yield call(goToProjectService, projectId);
+  }
+
+  yield put(handleBoardDelete(board));
 }

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

@@ -1,9 +1,17 @@
 import { call, put, select } from 'redux-saga/effects';
 
 import { goToBoardService } from './router';
-import { createCardRequest, deleteCardRequest, updateCardRequest } from '../requests';
+import request from '../request';
 import { listByIdSelector, nextCardPositionSelector, pathSelector } from '../../../selectors';
-import { createCard, deleteCard, updateCard } from '../../../actions';
+import {
+  createCard,
+  deleteCard,
+  handleCardCreate,
+  handleCardDelete,
+  handleCardUpdate,
+  updateCard,
+} from '../../../actions';
+import api from '../../../api';
 import { createLocalId } from '../../../utils/local-id';
 
 export function* createCardService(listId, data) {
@@ -25,12 +33,33 @@ export function* createCardService(listId, data) {
     }),
   );
 
-  yield call(createCardRequest, boardId, localId, nextData);
+  let card;
+  try {
+    ({ item: card } = yield call(request, api.createCard, boardId, nextData));
+  } catch (error) {
+    yield put(createCard.failure(localId, error));
+    return;
+  }
+
+  yield put(createCard.success(localId, card));
+}
+
+export function* handleCardCreateService(card) {
+  yield put(handleCardCreate(card));
 }
 
 export function* updateCardService(id, data) {
   yield put(updateCard(id, data));
-  yield call(updateCardRequest, id, data);
+
+  let card;
+  try {
+    ({ item: card } = yield call(request, api.updateCard, id, data));
+  } catch (error) {
+    yield put(updateCard.failure(id, error));
+    return;
+  }
+
+  yield put(updateCard.success(card));
 }
 
 export function* updateCurrentCardService(data) {
@@ -62,9 +91,7 @@ export function* transferCardService(id, boardId, listId, index) {
     yield call(goToBoardService, currentBoardId);
   }
 
-  yield put(deleteCard(id));
-
-  yield call(updateCardRequest, id, {
+  yield call(updateCardService, id, {
     boardId,
     listId,
     position,
@@ -77,6 +104,10 @@ export function* transferCurrentCardService(boardId, listId, index) {
   yield call(transferCardService, cardId, boardId, listId, index);
 }
 
+export function* handleCardUpdateService(card) {
+  yield put(handleCardUpdate(card)); // TODO: handle card transfer
+}
+
 export function* deleteCardService(id) {
   const { cardId, boardId } = yield select(pathSelector);
 
@@ -85,7 +116,16 @@ export function* deleteCardService(id) {
   }
 
   yield put(deleteCard(id));
-  yield call(deleteCardRequest, id);
+
+  let card;
+  try {
+    ({ item: card } = yield call(request, api.deleteCard, id));
+  } catch (error) {
+    yield put(deleteCard.failure(id, error));
+    return;
+  }
+
+  yield put(deleteCard.success(card));
 }
 
 export function* deleteCurrentCardService() {
@@ -93,3 +133,13 @@ export function* deleteCurrentCardService() {
 
   yield call(deleteCardService, cardId);
 }
+
+export function* handleCardDeleteService(card) {
+  const { cardId, boardId } = yield select(pathSelector);
+
+  if (card.id === cardId) {
+    yield call(goToBoardService, boardId);
+  }
+
+  yield put(handleCardDelete(card));
+}

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

@@ -1,12 +1,9 @@
 import { call, put, select } from 'redux-saga/effects';
 
-import {
-  createCommentActionRequest,
-  deleteCommentActionRequest,
-  updateCommentActionRequest,
-} from '../requests';
+import request from '../request';
 import { currentUserIdSelector, pathSelector } from '../../../selectors';
 import { createCommentAction, deleteCommentAction, updateCommentAction } from '../../../actions';
+import api from '../../../api';
 import { createLocalId } from '../../../utils/local-id';
 import { ActionTypes } from '../../../constants/Enums';
 
@@ -24,7 +21,15 @@ export function* createCommentActionService(cardId, data) {
     }),
   );
 
-  yield call(createCommentActionRequest, cardId, localId, data);
+  let action;
+  try {
+    ({ item: action } = yield call(request, api.createCommentAction, cardId, data));
+  } catch (error) {
+    yield put(createCommentAction.failure(localId, error));
+    return;
+  }
+
+  yield put(createCommentAction.success(localId, action));
 }
 
 export function* createCommentActionInCurrentCardService(data) {
@@ -35,10 +40,28 @@ export function* createCommentActionInCurrentCardService(data) {
 
 export function* updateCommentActionService(id, data) {
   yield put(updateCommentAction(id, data));
-  yield call(updateCommentActionRequest, id, data);
+
+  let action;
+  try {
+    ({ item: action } = yield call(request, api.updateCommentAction, id, data));
+  } catch (error) {
+    yield put(updateCommentAction.failure(id, error));
+    return;
+  }
+
+  yield put(updateCommentAction.success(action));
 }
 
 export function* deleteCommentActionService(id) {
   yield put(deleteCommentAction(id));
-  yield call(deleteCommentActionRequest, id);
+
+  let action;
+  try {
+    ({ item: action } = yield call(request, api.deleteCommentAction, id));
+  } catch (error) {
+    yield put(deleteCommentAction.failure(id, error));
+    return;
+  }
+
+  yield put(deleteCommentAction.success(action));
 }

client/src/sagas/core/services/core.js

@@ -1,44 +1,50 @@
-import { call, put, select } from 'redux-saga/effects';
+import { call, put } from 'redux-saga/effects';
 
-import { runPathActionsService } from './router';
-import {
-  fetchCardRequest,
-  fetchCurrentUserRequest,
-  fetchNotificationsRequest,
-  fetchProjectsRequest,
-  fetchUsersRequest,
-} from '../requests';
-import { pathsMatchSelector } from '../../../selectors';
-import { coreInitialized } from '../../../actions';
+import { fetchCoreRequest } from '../requests';
+import { initializeCore } from '../../../actions';
 import i18n from '../../../i18n';
-import Paths from '../../../constants/Paths';
-
-export function* loadLocaleService(language) {
-  yield call(i18n.loadCoreLocale, language);
-}
 
+// eslint-disable-next-line import/prefer-default-export
 export function* initializeCoreService() {
   const {
-    payload: {
-      user: { isAdmin },
-    },
-  } = yield call(fetchCurrentUserRequest); // TODO: success check
+    user,
+    board,
+    users,
+    projects,
+    projectManagers,
+    boards,
+    boardMemberships,
+    labels,
+    lists,
+    cards,
+    cardMemberships,
+    cardLabels,
+    tasks,
+    attachments,
+    actions,
+    notifications,
+  } = yield call(fetchCoreRequest); // TODO: handle error
 
-  if (isAdmin) {
-    yield call(fetchUsersRequest);
-  }
+  yield call(i18n.loadCoreLocale, i18n.language);
 
-  yield call(fetchProjectsRequest);
-
-  const pathsMatch = yield select(pathsMatchSelector);
-
-  if (pathsMatch && pathsMatch.path === Paths.CARDS) {
-    yield call(fetchCardRequest, pathsMatch.params.id);
-  }
-
-  yield call(fetchNotificationsRequest);
-  yield call(runPathActionsService, pathsMatch);
-  yield call(loadLocaleService, i18n.language);
-
-  yield put(coreInitialized());
+  yield put(
+    initializeCore(
+      user,
+      board,
+      users,
+      projects,
+      projectManagers,
+      boards,
+      boardMemberships,
+      labels,
+      lists,
+      cards,
+      cardMemberships,
+      cardLabels,
+      tasks,
+      attachments,
+      actions,
+      notifications,
+    ),
+  );
 }

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

@@ -5,14 +5,15 @@ export * from './core';
 export * from './modal';
 export * from './user';
 export * from './project';
-export * from './project-membership';
+export * from './project-manager';
 export * from './board';
+export * from './board-membership';
 export * from './label';
 export * from './list';
 export * from './card';
 export * from './task';
 export * from './attachment';
 export * from './actions';
+export * from './action';
 export * from './comment-action';
-export * from './notifications';
 export * from './notification';

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

@@ -1,22 +1,22 @@
 import { call, put, select } from 'redux-saga/effects';
 
-import {
-  createCardLabelRequest,
-  createLabelRequest,
-  deleteCardLabelRequest,
-  deleteLabelRequest,
-  updateLabelRequest,
-} from '../requests';
+import request from '../request';
 import { pathSelector } from '../../../selectors';
 import {
   addLabelToBoardFilter,
   addLabelToCard,
   createLabel,
   deleteLabel,
+  handleLabelCreate,
+  handleLabelDelete,
+  handleLabelFromCardRemove,
+  handleLabelToCardAdd,
+  handleLabelUpdate,
   removeLabelFromBoardFilter,
   removeLabelFromCard,
   updateLabel,
 } from '../../../actions';
+import api from '../../../api';
 import { createLocalId } from '../../../utils/local-id';
 
 export function* createLabelService(boardId, data) {
@@ -30,7 +30,15 @@ export function* createLabelService(boardId, data) {
     }),
   );
 
-  yield call(createLabelRequest, boardId, localId, data);
+  let label;
+  try {
+    ({ item: label } = yield call(request, api.createLabel, boardId, data));
+  } catch (error) {
+    yield put(createLabel.failure(localId, error));
+    return;
+  }
+
+  yield put(createLabel.success(localId, label));
 }
 
 export function* createLabelInCurrentBoardService(data) {
@@ -39,19 +47,60 @@ export function* createLabelInCurrentBoardService(data) {
   yield call(createLabelService, boardId, data);
 }
 
+export function* handleLabelCreateService(label) {
+  yield put(handleLabelCreate(label));
+}
+
 export function* updateLabelService(id, data) {
   yield put(updateLabel(id, data));
-  yield call(updateLabelRequest, id, data);
+
+  let label;
+  try {
+    ({ item: label } = yield call(request, api.updateLabel, id, data));
+  } catch (error) {
+    yield put(updateLabel.failure(id, error));
+    return;
+  }
+
+  yield put(updateLabel.success(label));
+}
+
+export function* handleLabelUpdateService(label) {
+  yield put(handleLabelUpdate(label));
 }
 
 export function* deleteLabelService(id) {
   yield put(deleteLabel(id));
-  yield call(deleteLabelRequest, id);
+
+  let label;
+  try {
+    ({ item: label } = yield call(request, api.deleteLabel, id));
+  } catch (error) {
+    yield put(deleteLabel.failure(id, error));
+    return;
+  }
+
+  yield put(deleteLabel.success(label));
+}
+
+export function* handleLabelDeleteService(label) {
+  yield put(handleLabelDelete(label));
 }
 
 export function* addLabelToCardService(id, cardId) {
   yield put(addLabelToCard(id, cardId));
-  yield call(createCardLabelRequest, cardId, id);
+
+  let cardLabel;
+  try {
+    ({ item: cardLabel } = yield call(request, api.createCardLabel, cardId, {
+      labelId: id,
+    }));
+  } catch (error) {
+    yield put(addLabelToCard.failure(id, cardId, error));
+    return;
+  }
+
+  yield put(addLabelToCard.success(cardLabel));
 }
 
 export function* addLabelToCurrentCardService(id) {
@@ -60,9 +109,22 @@ export function* addLabelToCurrentCardService(id) {
   yield call(addLabelToCardService, id, cardId);
 }
 
+export function* handleLabelToCardAddService(cardLabel) {
+  yield put(handleLabelToCardAdd(cardLabel));
+}
+
 export function* removeLabelFromCardService(id, cardId) {
   yield put(removeLabelFromCard(id, cardId));
-  yield call(deleteCardLabelRequest, cardId, id);
+
+  let cardLabel;
+  try {
+    ({ item: cardLabel } = yield call(request, api.deleteCardLabel, cardId, id));
+  } catch (error) {
+    yield put(removeLabelFromCard.failure(id, cardId, error));
+    return;
+  }
+
+  yield put(removeLabelFromCard.success(cardLabel));
 }
 
 export function* removeLabelFromCurrentCardService(id) {
@@ -71,6 +133,10 @@ export function* removeLabelFromCurrentCardService(id) {
   yield call(removeLabelFromCardService, id, cardId);
 }
 
+export function* handleLabelFromCardRemoveService(cardLabel) {
+  yield put(handleLabelFromCardRemove(cardLabel));
+}
+
 export function* addLabelToBoardFilterService(id, boardId) {
   yield put(addLabelToBoardFilter(id, boardId));
 }

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

@@ -1,8 +1,16 @@
 import { call, put, select } from 'redux-saga/effects';
 
-import { createListRequest, deleteListRequest, updateListRequest } from '../requests';
+import request from '../request';
 import { listByIdSelector, nextListPositionSelector, pathSelector } from '../../../selectors';
-import { createList, deleteList, updateList } from '../../../actions';
+import {
+  createList,
+  deleteList,
+  handleListCreate,
+  handleListDelete,
+  handleListUpdate,
+  updateList,
+} from '../../../actions';
+import api from '../../../api';
 import { createLocalId } from '../../../utils/local-id';
 
 export function* createListService(boardId, data) {
@@ -21,7 +29,15 @@ export function* createListService(boardId, data) {
     }),
   );
 
-  yield call(createListRequest, boardId, localId, nextData);
+  let list;
+  try {
+    ({ item: list } = yield call(request, api.createList, boardId, nextData));
+  } catch (error) {
+    yield put(createList.failure(localId, error));
+    return;
+  }
+
+  yield put(createList.success(localId, list));
 }
 
 export function* createListInCurrentBoardService(data) {
@@ -30,9 +46,22 @@ export function* createListInCurrentBoardService(data) {
   yield call(createListService, boardId, data);
 }
 
+export function* handleListCreateService(label) {
+  yield put(handleListCreate(label));
+}
+
 export function* updateListService(id, data) {
   yield put(updateList(id, data));
-  yield call(updateListRequest, id, data);
+
+  let list;
+  try {
+    ({ item: list } = yield call(request, api.updateList, id, data));
+  } catch (error) {
+    yield put(updateList.failure(id, error));
+    return;
+  }
+
+  yield put(updateList.success(list));
 }
 
 export function* moveListService(id, index) {
@@ -44,7 +73,24 @@ export function* moveListService(id, index) {
   });
 }
 
+export function* handleListUpdateService(label) {
+  yield put(handleListUpdate(label));
+}
+
 export function* deleteListService(id) {
   yield put(deleteList(id));
-  yield call(deleteListRequest, id);
+
+  let list;
+  try {
+    ({ item: list } = yield call(request, api.deleteList, id));
+  } catch (error) {
+    yield put(deleteList.failure(id, error));
+    return;
+  }
+
+  yield put(deleteList.success(list));
+}
+
+export function* handleListDeleteService(label) {
+  yield put(handleListDelete(label));
 }

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

@@ -1,8 +1,9 @@
-import { put } from 'redux-saga/effects';
+import { put, take } from 'redux-saga/effects';
 
 import { logout } from '../../../actions';
 
 // eslint-disable-next-line import/prefer-default-export
 export function* logoutService() {
   yield put(logout());
+  yield take();
 }

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

@@ -1,8 +1,56 @@
-import { call } from 'redux-saga/effects';
+import { call, put, select } from 'redux-saga/effects';
 
-import { deleteNotificationsService } from './notifications';
+import request from '../request';
+import { pathSelector } from '../../../selectors';
+import {
+  deleteNotification,
+  handleNotificationCreate,
+  handleNotificationDelete,
+} from '../../../actions';
+import api from '../../../api';
 
-// eslint-disable-next-line import/prefer-default-export
-export function* deleteNotificationService(id) {
-  yield call(deleteNotificationsService, [id]);
+export function* handleNotificationCreateService(notification) {
+  const { cardId } = yield select(pathSelector);
+
+  if (notification.cardId === cardId) {
+    try {
+      yield call(request, api.updateNotifications, [notification.id], {
+        isRead: true,
+      });
+    } catch {} // eslint-disable-line no-empty
+  } else {
+    let users;
+    let cards;
+    let actions;
+
+    try {
+      ({
+        included: { users, cards, actions },
+      } = yield call(request, api.getNotification, notification.id));
+    } catch {
+      return;
+    }
+
+    yield put(handleNotificationCreate(notification, users, cards, actions));
+  }
+}
+
+export function* deleteNotificationService(id) {
+  yield put(deleteNotification(id));
+
+  let notifications;
+  try {
+    ({ items: notifications } = yield call(request, api.updateNotifications, [id], {
+      isRead: true,
+    }));
+  } catch (error) {
+    yield put(deleteNotification.failure(id, error));
+    return;
+  }
+
+  yield put(deleteNotification.success(notifications[0]));
+}
+
+export function* handleNotificationDeleteService(notification) {
+  yield put(handleNotificationDelete(notification));
 }

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

@@ -1,18 +0,0 @@
-import { call, put, select } from 'redux-saga/effects';
-
-import { deleteNotificationsRequest } from '../requests';
-import { notificationIdsForCurrentCardSelector } from '../../../selectors';
-import { deleteNotifications } from '../../../actions';
-
-export function* deleteNotificationsService(ids) {
-  yield put(deleteNotifications(ids));
-  yield call(deleteNotificationsRequest, ids);
-}
-
-export function* deleteNotificationsInCurrentCardService() {
-  const notificationIds = yield select(notificationIdsForCurrentCardSelector);
-
-  if (notificationIds && notificationIds.length > 0) {
-    yield call(deleteNotificationsService, notificationIds);
-  }
-}

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

@@ -0,0 +1,174 @@
+import { call, put, select } from 'redux-saga/effects';
+
+import request from '../request';
+import { fetchBoardByCurrentPathRequest } from '../requests';
+import {
+  currentUserIdSelector,
+  notificationsByCardIdSelector,
+  pathSelector,
+  projectManagerByIdSelector,
+} from '../../../selectors';
+import {
+  createProjectManager,
+  deleteProjectManager,
+  handleProjectManagerCreate,
+  handleProjectManagerDelete,
+} from '../../../actions';
+import api from '../../../api';
+import { createLocalId } from '../../../utils/local-id';
+import mergeRecords from '../../../utils/merge-records';
+
+export function* createProjectManagerService(projectId, data) {
+  const localId = yield call(createLocalId);
+
+  yield put(
+    createProjectManager({
+      ...data,
+      projectId,
+      id: localId,
+    }),
+  );
+
+  let projectManager;
+  try {
+    ({ item: projectManager } = yield call(request, api.createProjectManager, projectId, data));
+  } catch (error) {
+    yield put(createProjectManager.failure(localId, error));
+  }
+
+  yield put(createProjectManager.success(localId, projectManager));
+}
+
+export function* createManagerInCurrentProjectService(data) {
+  const { projectId } = yield select(pathSelector);
+
+  yield call(createProjectManagerService, projectId, data);
+}
+
+export function* handleProjectManagerCreateService(projectManager) {
+  const currentUserId = yield select(currentUserIdSelector);
+  const isCurrentUser = projectManager.userId === currentUserId;
+
+  let user;
+  let project;
+  let board;
+  let users1;
+  let users2;
+  let projectManagers;
+  let boards;
+  let boardMemberships1;
+  let boardMemberships2;
+  let labels;
+  let lists;
+  let cards;
+  let cardMemberships;
+  let cardLabels;
+  let tasks;
+  let attachments;
+  let notifications;
+
+  if (isCurrentUser) {
+    const { boardId } = yield select(pathSelector);
+
+    yield put(
+      handleProjectManagerCreate.fetchProject(projectManager.projectId, currentUserId, boardId),
+    );
+
+    try {
+      ({
+        item: project,
+        included: { users: users1, projectManagers, boards, boardMemberships: boardMemberships1 },
+      } = yield call(request, api.getProject, projectManager.projectId));
+    } catch {
+      return;
+    }
+
+    let body;
+    try {
+      body = yield call(fetchBoardByCurrentPathRequest);
+    } catch {} // eslint-disable-line no-empty
+
+    if (body && body.project && body.project.id === projectManager.projectId) {
+      ({
+        project,
+        board,
+        users: users2,
+        boardMemberships: boardMemberships2,
+        labels,
+        lists,
+        cards,
+        cardMemberships,
+        cardLabels,
+        tasks,
+        attachments,
+      } = body);
+
+      if (body.card) {
+        notifications = yield select(notificationsByCardIdSelector, body.card.id);
+      }
+    }
+  } else {
+    try {
+      ({ item: user } = yield call(request, api.getUser, projectManager.userId));
+    } catch {
+      return;
+    }
+  }
+
+  yield put(
+    handleProjectManagerCreate(
+      projectManager,
+      project,
+      board,
+      isCurrentUser ? mergeRecords(users1, users2) : [user],
+      projectManagers,
+      boards,
+      mergeRecords(boardMemberships1, boardMemberships2),
+      labels,
+      lists,
+      cards,
+      cardMemberships,
+      cardLabels,
+      tasks,
+      attachments,
+      notifications,
+    ),
+  );
+}
+
+export function* deleteProjectManagerService(id) {
+  let projectManager = yield select(projectManagerByIdSelector, id);
+
+  const currentUserId = yield select(currentUserIdSelector);
+  const { projectId } = yield select(pathSelector);
+
+  yield put(
+    deleteProjectManager(
+      id,
+      projectManager.userId === currentUserId,
+      projectManager.projectId === projectId,
+    ),
+  );
+
+  try {
+    ({ item: projectManager } = yield call(request, api.deleteProjectManager, id));
+  } catch (error) {
+    yield put(deleteProjectManager.failure(id, error));
+    return;
+  }
+
+  yield put(deleteProjectManager.success(projectManager));
+}
+
+export function* handleProjectManagerDeleteService(projectManager) {
+  const currentUserId = yield select(currentUserIdSelector);
+  const { projectId } = yield select(pathSelector);
+
+  yield put(
+    handleProjectManagerDelete(
+      projectManager,
+      projectManager.userId === currentUserId,
+      projectManager.projectId === projectId,
+    ),
+  );
+}

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

@@ -1,31 +0,0 @@
-import { call, put, select } from 'redux-saga/effects';
-
-import { createProjectMembershipRequest, deleteProjectMembershipRequest } from '../requests';
-import { pathSelector } from '../../../selectors';
-import { createProjectMembership, deleteProjectMembership } from '../../../actions';
-import { createLocalId } from '../../../utils/local-id';
-
-export function* createProjectMembershipService(projectId, data) {
-  const localId = yield call(createLocalId);
-
-  yield put(
-    createProjectMembership({
-      ...data,
-      projectId,
-      id: localId,
-    }),
-  );
-
-  yield call(createProjectMembershipRequest, projectId, localId, data);
-}
-
-export function* createMembershipInCurrentProjectService(data) {
-  const { projectId } = yield select(pathSelector);
-
-  yield call(createProjectMembershipService, projectId, data);
-}
-
-export function* deleteProjectMembershipService(id) {
-  yield put(deleteProjectMembership(id));
-  yield call(deleteProjectMembershipRequest, id);
-}

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

@@ -1,31 +1,69 @@
 import { call, put, select } from 'redux-saga/effects';
 
 import { goToProjectService, goToRootService } from './router';
-import {
-  createProjectRequest,
-  deleteProjectRequest,
-  updateProjectBackgroundImageRequest,
-  updateProjectRequest,
-} from '../requests';
+import request from '../request';
 import { pathSelector } from '../../../selectors';
-import { createProject, deleteProject, updateProject } from '../../../actions';
+import {
+  createProject,
+  deleteProject,
+  handleProjectCreate,
+  handleProjectDelete,
+  handleProjectUpdate,
+  updateProject,
+  updateProjectBackgroundImage,
+} from '../../../actions';
+import api from '../../../api';
 
 export function* createProjectService(data) {
   yield put(createProject(data));
 
-  const {
-    success,
-    payload: { project },
-  } = yield call(createProjectRequest, data);
+  let project;
+  let projectManagers;
 
-  if (success) {
-    yield call(goToProjectService, project.id);
+  try {
+    ({
+      item: project,
+      included: { projectManagers },
+    } = yield call(request, api.createProject, data));
+  } catch (error) {
+    yield put(createProject.failure(error));
+    return;
   }
+
+  yield put(createProject.success(project, projectManagers));
+  yield call(goToProjectService, project.id);
+}
+
+export function* handleProjectCreateService({ id }) {
+  let project;
+  let users;
+  let projectManagers;
+  let boards;
+  let boardMemberships;
+
+  try {
+    ({
+      item: project,
+      included: { users, projectManagers, boards, boardMemberships },
+    } = yield call(request, api.getProject, id));
+  } catch (error) {
+    return;
+  }
+
+  yield put(handleProjectCreate(project, users, projectManagers, boards, boardMemberships));
 }
 
 export function* updateProjectService(id, data) {
   yield put(updateProject(id, data));
-  yield call(updateProjectRequest, id, data);
+
+  let project;
+  try {
+    ({ item: project } = yield call(request, api.updateProject, id, data));
+  } catch (error) {
+    yield put(updateProject.failure(id, error));
+  }
+
+  yield put(updateProject.success(project));
 }
 
 export function* updateCurrentProjectService(data) {
@@ -34,8 +72,21 @@ export function* updateCurrentProjectService(data) {
   yield call(updateProjectService, projectId, data);
 }
 
+export function* handleProjectUpdateService(project) {
+  yield put(handleProjectUpdate(project));
+}
+
 export function* updateProjectBackgroundImageService(id, data) {
-  yield call(updateProjectBackgroundImageRequest, id, data);
+  yield put(updateProjectBackgroundImage(id));
+
+  let project;
+  try {
+    ({ item: project } = yield call(request, api.updateProjectBackgroundImage, id, data));
+  } catch (error) {
+    yield put(updateProjectBackgroundImage.failure(id, error));
+  }
+
+  yield put(updateProjectBackgroundImage.success(project));
 }
 
 export function* updateCurrentProjectBackgroundImageService(data) {
@@ -52,7 +103,15 @@ export function* deleteProjectService(id) {
   }
 
   yield put(deleteProject(id));
-  yield call(deleteProjectRequest, id);
+
+  let project;
+  try {
+    ({ item: project } = yield call(request, api.deleteProject, id));
+  } catch (error) {
+    yield put(deleteProject.failure(id, error));
+  }
+
+  yield put(deleteProject.success(project));
 }
 
 export function* deleteCurrentProjectService() {
@@ -60,3 +119,13 @@ export function* deleteCurrentProjectService() {
 
   yield call(deleteProjectService, projectId);
 }
+
+export function* handleProjectDeleteService(project) {
+  const { projectId } = yield select(pathSelector);
+
+  if (project.id === projectId) {
+    yield call(goToRootService);
+  }
+
+  yield put(handleProjectDelete(project));
+}

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

@@ -1,13 +1,16 @@
-import { call, put, select } from 'redux-saga/effects';
+import { call, put, select, take } from 'redux-saga/effects';
 import { push } from 'connected-react-router';
 
-import { deleteNotificationsInCurrentCardService } from './notifications';
-import { fetchBoardRequest } from '../requests';
+import request from '../request';
 import {
   currentBoardSelector,
   isCoreInitializingSelector,
+  notificationIdsForCurrentCardSelector,
   pathsMatchSelector,
 } from '../../../selectors';
+import { handleLocationChange } from '../../../actions';
+import api from '../../../api';
+import ActionTypes from '../../../constants/ActionTypes';
 import Paths from '../../../constants/Paths';
 
 export function* goToRootService() {
@@ -26,46 +29,103 @@ export function* goToCardService(cardId) {
   yield put(push(Paths.CARDS.replace(':id', cardId)));
 }
 
-export function* runPathActionsService(pathsMatch) {
+export function* handleLocationChangeService() {
+  const pathsMatch = yield select(pathsMatchSelector);
+
   if (!pathsMatch) {
     return;
   }
 
+  switch (pathsMatch.path) {
+    case Paths.LOGIN:
+      yield call(goToRootService);
+
+      break;
+    default:
+  }
+
+  const isCoreInitializing = yield select(isCoreInitializingSelector);
+
+  if (isCoreInitializing) {
+    yield take(ActionTypes.CORE_INITIALIZE);
+  }
+
+  let board;
+  let users;
+  let projects;
+  let boardMemberships;
+  let labels;
+  let lists;
+  let cards;
+  let cardMemberships;
+  let cardLabels;
+  let tasks;
+  let attachments;
+  let notifications;
+
   switch (pathsMatch.path) {
     case Paths.BOARDS:
     case Paths.CARDS: {
-      const currentBoard = yield select(currentBoardSelector); // TODO: move to services
+      const currentBoard = yield select(currentBoardSelector);
 
       if (currentBoard && currentBoard.isFetching === null) {
-        yield call(fetchBoardRequest, currentBoard.id);
+        yield put(handleLocationChange.fetchBoard(currentBoard.id));
+
+        try {
+          ({
+            item: board,
+            included: {
+              users,
+              projects,
+              boardMemberships,
+              labels,
+              lists,
+              cards,
+              cardMemberships,
+              cardLabels,
+              tasks,
+              attachments,
+            },
+          } = yield call(request, api.getBoard, currentBoard.id));
+        } catch (error) {} // eslint-disable-line no-empty
       }
 
       if (pathsMatch.path === Paths.CARDS) {
-        yield call(deleteNotificationsInCurrentCardService);
+        const notificationIds = yield select(notificationIdsForCurrentCardSelector);
+
+        if (notificationIds && notificationIds.length > 0) {
+          try {
+            ({ items: notifications } = yield call(
+              request,
+              api.updateNotifications,
+              notificationIds,
+              {
+                isRead: true,
+              },
+            ));
+          } catch (error) {} // eslint-disable-line no-empty
+        }
       }
 
       break;
     }
     default:
   }
-}
-
-export function* locationChangedService() {
-  const pathsMatch = yield select(pathsMatchSelector);
-
-  if (pathsMatch) {
-    switch (pathsMatch.path) {
-      case Paths.LOGIN:
-        yield call(goToRootService);
-
-        break;
-      default:
-    }
-  }
-
-  const isCoreInitializing = yield select(isCoreInitializingSelector);
-
-  if (!isCoreInitializing) {
-    yield call(runPathActionsService, pathsMatch);
-  }
+
+  yield put(
+    handleLocationChange(
+      board,
+      users,
+      projects,
+      boardMemberships,
+      labels,
+      lists,
+      cards,
+      cardMemberships,
+      cardLabels,
+      tasks,
+      attachments,
+      notifications,
+    ),
+  );
 }

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

@@ -1,252 +1,56 @@
 import { call, put, select } from 'redux-saga/effects';
 
-import { goToBoardService, goToProjectService, goToRootService } from './router';
-import { logoutService } from './login';
-import { closeModalService } from './modal';
-import { deleteNotificationsRequest, fetchUsersRequest } from '../requests';
-import {
-  currentModalSelector,
-  currentUserIdSelector,
-  currentUserSelector,
-  isAttachmentWithIdExistsSelector,
-  pathSelector,
-} from '../../../selectors';
-import {
-  createActionReceived,
-  createAttachmentReceived,
-  createBoardReceived,
-  createCardLabelReceived,
-  createCardMembershipReceived,
-  createCardReceived,
-  createLabelReceived,
-  createListReceived,
-  createNotificationReceived,
-  createProjectMembershipReceived,
-  createProjectReceived,
-  createTaskReceived,
-  createUserReceived,
-  deleteActionReceived,
-  deleteAttachmentReceived,
-  deleteCardLabelReceived,
-  deleteCardMembershipReceived,
-  deleteCardReceived,
-  deleteBoardReceived,
-  deleteLabelReceived,
-  deleteListReceived,
-  deleteNotificationReceived,
-  deleteProjectMembershipReceived,
-  deleteProjectReceived,
-  deleteTaskReceived,
-  deleteUserReceived,
-  socketDisconnected,
-  socketReconnected,
-  updateActionReceived,
-  updateAttachmentReceived,
-  updateBoardReceived,
-  updateCardReceived,
-  updateLabelReceived,
-  updateListReceived,
-  updateProjectReceived,
-  updateTaskReceived,
-  updateUserReceived,
-} from '../../../actions';
-import ModalTypes from '../../../constants/ModalTypes';
+import { fetchCoreRequest } from '../requests';
+import { currentUserIdSelector, pathSelector } from '../../../selectors';
+import { handleSocketDisconnect, handleSocketReconnect } from '../../../actions';
 
-export function* socketDisconnectedService() {
-  yield put(socketDisconnected());
+export function* handleSocketDisconnectService() {
+  yield put(handleSocketDisconnect());
 }
 
-// TODO: refetch state on reconnect
-export function* socketReconnectedService() {
-  yield put(socketReconnected());
-}
-
-export function* createUserReceivedService(user) {
-  yield put(createUserReceived(user));
-}
-
-export function* updateUserReceivedService(user) {
-  const currentUser = yield select(currentUserSelector);
-
-  if (user.id === currentUser.id) {
-    if (currentUser.isAdmin) {
-      if (!user.isAdmin) {
-        const currentModal = yield select(currentModalSelector);
-
-        if (currentModal === ModalTypes.USERS) {
-          yield call(closeModalService);
-        }
-      }
-    } else if (user.isAdmin) {
-      yield call(fetchUsersRequest);
-    }
-  }
-
-  yield put(updateUserReceived(user));
-}
-
-export function* deleteUserReceivedService(user) {
+export function* handleSocketReconnectService() {
   const currentUserId = yield select(currentUserIdSelector);
+  const { boardId } = yield select(pathSelector);
 
-  if (user.id === currentUserId) {
-    yield call(logoutService);
-  }
+  yield put(handleSocketReconnect.fetchCore(currentUserId, boardId));
 
-  yield put(deleteUserReceived(user));
-}
-
-export function* createProjectReceivedService(project, users, projectMemberships, boards) {
-  yield put(createProjectReceived(project, users, projectMemberships, boards));
-}
-
-export function* updateProjectReceivedService(project) {
-  yield put(updateProjectReceived(project));
-}
-
-export function* deleteProjectReceivedService(project) {
-  const { projectId } = yield select(pathSelector);
-
-  if (project.id === projectId) {
-    yield call(goToRootService);
-  }
-
-  yield put(deleteProjectReceived(project));
-}
-
-export function* createProjectMembershipReceivedService(projectMembership, user) {
-  yield put(createProjectMembershipReceived(projectMembership, user));
-}
-
-export function* deleteProjectMembershipReceivedService(projectMembership) {
-  yield put(deleteProjectMembershipReceived(projectMembership));
-}
-
-export function* createBoardReceivedService(board, lists, labels) {
-  yield put(createBoardReceived(board, lists, labels));
-}
-
-export function* updateBoardReceivedService(board) {
-  yield put(updateBoardReceived(board));
-}
-
-export function* deleteBoardReceivedService(board) {
-  const { boardId, projectId } = yield select(pathSelector);
-
-  if (board.id === boardId) {
-    yield call(goToProjectService, projectId);
-  }
-
-  yield put(deleteBoardReceived(board));
-}
-
-export function* createListReceivedService(list) {
-  yield put(createListReceived(list));
-}
-
-export function* updateListReceivedService(list) {
-  yield put(updateListReceived(list));
-}
-
-export function* deleteListReceivedService(list) {
-  yield put(deleteListReceived(list));
-}
-
-export function* createLabelReceivedService(label) {
-  yield put(createLabelReceived(label));
-}
-
-export function* updateLabelReceivedService(label) {
-  yield put(updateLabelReceived(label));
-}
-
-export function* deleteLabelReceivedService(label) {
-  yield put(deleteLabelReceived(label));
-}
-
-export function* createCardReceivedService(card, cardMemberships, cardLabels, tasks, attachments) {
-  yield put(createCardReceived(card, cardMemberships, cardLabels, tasks, attachments));
-}
-
-export function* updateCardReceivedService(card) {
-  yield put(updateCardReceived(card));
-}
-
-export function* deleteCardReceivedService(card) {
-  const { cardId, boardId } = yield select(pathSelector);
-
-  if (card.id === cardId) {
-    yield call(goToBoardService, boardId);
-  }
-
-  yield put(deleteCardReceived(card));
-}
-
-export function* createCardMembershipReceivedService(cardMembership) {
-  yield put(createCardMembershipReceived(cardMembership));
-}
-
-export function* deleteCardMembershipReceivedService(cardMembership) {
-  yield put(deleteCardMembershipReceived(cardMembership));
-}
-
-export function* createCardLabelReceivedService(cardLabel) {
-  yield put(createCardLabelReceived(cardLabel));
-}
-
-export function* deleteCardLabelReceivedService(cardLabel) {
-  yield put(deleteCardLabelReceived(cardLabel));
-}
-
-export function* createTaskReceivedService(task) {
-  yield put(createTaskReceived(task));
-}
-
-export function* updateTaskReceivedService(task) {
-  yield put(updateTaskReceived(task));
-}
-
-export function* deleteTaskReceivedService(task) {
-  yield put(deleteTaskReceived(task));
-}
-
-export function* createAttachmentReceivedService(attachment, requestId) {
-  const isExists = yield select(isAttachmentWithIdExistsSelector, requestId);
-
-  if (!isExists) {
-    yield put(createAttachmentReceived(attachment));
-  }
-}
-
-export function* updateAttachmentReceivedService(attachment) {
-  yield put(updateAttachmentReceived(attachment));
-}
-
-export function* deleteAttachmentReceivedService(attachment) {
-  yield put(deleteAttachmentReceived(attachment));
-}
-
-export function* createActionReceivedService(action) {
-  yield put(createActionReceived(action));
-}
-
-export function* updateActionReceivedService(action) {
-  yield put(updateActionReceived(action));
-}
-
-export function* deleteActionReceivedService(action) {
-  yield put(deleteActionReceived(action));
-}
-
-export function* createNotificationReceivedService(notification, user, card, action) {
-  const { cardId } = yield select(pathSelector);
-
-  if (card.id === cardId) {
-    yield call(deleteNotificationsRequest, [notification.id]);
-  } else {
-    yield put(createNotificationReceived(notification, user, card, action));
-  }
-}
-
-export function* deleteNotificationReceivedService(notification) {
-  yield put(deleteNotificationReceived(notification));
+  const {
+    user,
+    board,
+    users,
+    projects,
+    projectManagers,
+    boards,
+    boardMemberships,
+    labels,
+    lists,
+    cards,
+    cardMemberships,
+    cardLabels,
+    tasks,
+    attachments,
+    actions,
+    notifications,
+  } = yield call(fetchCoreRequest); // TODO: handle error
+
+  yield put(
+    handleSocketReconnect(
+      user,
+      board,
+      users,
+      projects,
+      projectManagers,
+      boards,
+      boardMemberships,
+      labels,
+      lists,
+      cards,
+      cardMemberships,
+      cardLabels,
+      tasks,
+      attachments,
+      actions,
+      notifications,
+    ),
+  );
 }

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

@@ -1,8 +1,16 @@
 import { call, put, select } from 'redux-saga/effects';
 
-import { createTaskRequest, deleteTaskRequest, updateTaskRequest } from '../requests';
+import request from '../request';
 import { pathSelector } from '../../../selectors';
-import { createTask, deleteTask, updateTask } from '../../../actions';
+import {
+  createTask,
+  deleteTask,
+  handleTaskCreate,
+  handleTaskDelete,
+  handleTaskUpdate,
+  updateTask,
+} from '../../../actions';
+import api from '../../../api';
 import { createLocalId } from '../../../utils/local-id';
 
 export function* createTaskService(cardId, data) {
@@ -16,7 +24,15 @@ export function* createTaskService(cardId, data) {
     }),
   );
 
-  yield call(createTaskRequest, cardId, localId, data);
+  let task;
+  try {
+    ({ item: task } = yield call(request, api.createTask, cardId, data));
+  } catch (error) {
+    yield put(createTask.failure(localId, error));
+    return;
+  }
+
+  yield put(createTask.success(localId, task));
 }
 
 export function* createTaskInCurrentCardService(data) {
@@ -25,12 +41,42 @@ export function* createTaskInCurrentCardService(data) {
   yield call(createTaskService, cardId, data);
 }
 
+export function* handleTaskCreateService(task) {
+  yield put(handleTaskCreate(task));
+}
+
 export function* updateTaskService(id, data) {
   yield put(updateTask(id, data));
-  yield call(updateTaskRequest, id, data);
+
+  let task;
+  try {
+    ({ item: task } = yield call(request, api.updateTask, id, data));
+  } catch (error) {
+    yield put(updateTask.failure(id, error));
+    return;
+  }
+
+  yield put(updateTask.success(task));
+}
+
+export function* handleTaskUpdateService(task) {
+  yield put(handleTaskUpdate(task));
 }
 
 export function* deleteTaskService(id) {
   yield put(deleteTask(id));
-  yield call(deleteTaskRequest, id);
+
+  let task;
+  try {
+    ({ item: task } = yield call(request, api.deleteTask, id));
+  } catch (error) {
+    yield put(deleteTask.failure(id, error));
+    return;
+  }
+
+  yield put(deleteTask.success(task));
+}
+
+export function* handleTaskDeleteService(task) {
+  yield put(handleTaskDelete(task));
 }

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

@@ -1,17 +1,8 @@
 import { call, put, select } from 'redux-saga/effects';
 
-import {
-  createCardMembershipRequest,
-  createUserRequest,
-  deleteCardMembershipRequest,
-  deleteUserRequest,
-  updateUserAvatarRequest,
-  updateUserEmailRequest,
-  updateUserPasswordRequest,
-  updateUserRequest,
-  updateUserUsernameRequest,
-} from '../requests';
-import { currentUserIdSelector, pathSelector } from '../../../selectors';
+import { logoutService } from './login';
+import request from '../request';
+import { currentUserIdSelector, currentUserSelector, pathSelector } from '../../../selectors';
 import {
   addUserToBoardFilter,
   addUserToCard,
@@ -21,14 +12,37 @@ import {
   clearUserUsernameUpdateError,
   createUser,
   deleteUser,
-  updateUser,
+  handleUserCreate,
+  handleUserDelete,
+  handleUserFromCardRemove,
+  handleUserToCardAdd,
+  handleUserUpdate,
   removeUserFromBoardFilter,
   removeUserFromCard,
+  updateUser,
+  updateUserAvatar,
+  updateUserEmail,
+  updateUserPassword,
+  updateUserUsername,
 } from '../../../actions';
+import api from '../../../api';
 
 export function* createUserService(data) {
   yield put(createUser(data));
-  yield call(createUserRequest, data);
+
+  let user;
+  try {
+    ({ item: user } = yield call(request, api.createUser, data));
+  } catch (error) {
+    yield put(createUser.failure(error));
+    return;
+  }
+
+  yield put(createUser.success(user));
+}
+
+export function* handleUserCreateService(user) {
+  yield put(handleUserCreate(user));
 }
 
 export function* clearUserCreateErrorService() {
@@ -37,7 +51,16 @@ export function* clearUserCreateErrorService() {
 
 export function* updateUserService(id, data) {
   yield put(updateUser(id, data));
-  yield call(updateUserRequest, id, data);
+
+  let user;
+  try {
+    ({ item: user } = yield call(request, api.updateUser, id, data));
+  } catch (error) {
+    yield put(updateUser.failure(id, error));
+    return;
+  }
+
+  yield put(updateUser.success(user));
 }
 
 export function* updateCurrentUserService(data) {
@@ -46,8 +69,30 @@ export function* updateCurrentUserService(data) {
   yield call(updateUserService, id, data);
 }
 
+export function* handleUserUpdateService(user) {
+  const currentUser = yield select(currentUserSelector);
+  const isCurrent = user.id === currentUser.id;
+
+  let users;
+  if (isCurrent && !currentUser.isAdmin && user.isAdmin) {
+    ({ items: users } = yield call(request, api.getUsers));
+  }
+
+  yield put(handleUserUpdate(user, users, isCurrent));
+}
+
 export function* updateUserEmailService(id, data) {
-  yield call(updateUserEmailRequest, id, data);
+  yield put(updateUserEmail(id, data));
+
+  let user;
+  try {
+    ({ item: user } = yield call(request, api.updateUserEmail, id, data));
+  } catch (error) {
+    yield put(updateUserEmail.failure(id, error));
+    return;
+  }
+
+  yield put(updateUserEmail.success(user));
 }
 
 export function* updateCurrentUserEmailService(data) {
@@ -67,7 +112,17 @@ export function* clearCurrentUserEmailUpdateErrorService() {
 }
 
 export function* updateUserPasswordService(id, data) {
-  yield call(updateUserPasswordRequest, id, data);
+  yield put(updateUserPassword(id, data));
+
+  let user;
+  try {
+    ({ item: user } = yield call(request, api.updateUserPassword, id, data));
+  } catch (error) {
+    yield put(updateUserPassword.failure(id, error));
+    return;
+  }
+
+  yield put(updateUserPassword.success(user));
 }
 
 export function* updateCurrentUserPasswordService(data) {
@@ -87,7 +142,17 @@ export function* clearCurrentUserPasswordUpdateErrorService() {
 }
 
 export function* updateUserUsernameService(id, data) {
-  yield call(updateUserUsernameRequest, id, data);
+  yield put(updateUserUsername(id, data));
+
+  let user;
+  try {
+    ({ item: user } = yield call(request, api.updateUserUsername, id, data));
+  } catch (error) {
+    yield put(updateUserUsername.failure(id, error));
+    return;
+  }
+
+  yield put(updateUserUsername.success(user));
 }
 
 export function* updateCurrentUserUsernameService(data) {
@@ -107,7 +172,17 @@ export function* clearCurrentUserUsernameUpdateErrorService() {
 }
 
 export function* updateUserAvatarService(id, data) {
-  yield call(updateUserAvatarRequest, id, data);
+  yield put(updateUserAvatar(id));
+
+  let user;
+  try {
+    ({ item: user } = yield call(request, api.updateUserAvatar, id, data));
+  } catch (error) {
+    yield put(updateUserAvatar.failure(id, error));
+    return;
+  }
+
+  yield put(updateUserAvatar.success(user));
 }
 
 export function* updateCurrentUserAvatarService(data) {
@@ -118,14 +193,44 @@ export function* updateCurrentUserAvatarService(data) {
 
 export function* deleteUserService(id) {
   yield put(deleteUser(id));
-  yield call(deleteUserRequest, id);
+
+  let user;
+  try {
+    ({ item: user } = yield call(request, api.deleteUser, id));
+  } catch (error) {
+    yield put(deleteUser.failure(id, error));
+    return;
+  }
+
+  yield put(deleteUser.success(user));
+}
+
+export function* handleUserDeleteService(user) {
+  const currentUserId = yield select(currentUserIdSelector);
+
+  if (user.id === currentUserId) {
+    yield call(logoutService);
+  }
+
+  yield put(handleUserDelete(user));
 }
 
 export function* addUserToCardService(id, cardId) {
   const currentUserId = yield select(currentUserIdSelector);
 
   yield put(addUserToCard(id, cardId, id === currentUserId));
-  yield call(createCardMembershipRequest, cardId, id);
+
+  let cardMembership;
+  try {
+    ({ item: cardMembership } = yield call(request, api.createCardMembership, cardId, {
+      userId: id,
+    }));
+  } catch (error) {
+    yield put(addUserToCard.failure(id, cardId, error));
+    return;
+  }
+
+  yield put(addUserToCard.success(cardMembership));
 }
 
 export function* addUserToCurrentCardService(id) {
@@ -134,9 +239,22 @@ export function* addUserToCurrentCardService(id) {
   yield call(addUserToCardService, id, cardId);
 }
 
+export function* handleUserToCardAddService(cardMembership) {
+  yield put(handleUserToCardAdd(cardMembership));
+}
+
 export function* removeUserFromCardService(id, cardId) {
   yield put(removeUserFromCard(id, cardId));
-  yield call(deleteCardMembershipRequest, cardId, id);
+
+  let cardMembership;
+  try {
+    ({ item: cardMembership } = yield call(request, api.deleteCardMembership, cardId, id));
+  } catch (error) {
+    yield put(removeUserFromCard.failure(id, cardId, error));
+    return;
+  }
+
+  yield put(removeUserFromCard.success(cardMembership));
 }
 
 export function* removeUserFromCurrentCardService(id) {
@@ -145,6 +263,10 @@ export function* removeUserFromCurrentCardService(id) {
   yield call(removeUserFromCardService, id, cardId);
 }
 
+export function* handleUserFromCardRemoveService(cardMembership) {
+  yield put(handleUserFromCardRemove(cardMembership));
+}
+
 export function* addUserToBoardFilterService(id, boardId) {
   yield put(addUserToBoardFilter(id, boardId));
 }