Background gradients, migrate from CSS to SCSS, remove !important

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

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

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

@@ -0,0 +1,22 @@
+import { all, takeLatest } from 'redux-saga/effects';
+
+import {
+  createAttachmentInCurrentCardService,
+  deleteAttachmentService,
+  updateAttachmentService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* () {
+  yield all([
+    takeLatest(EntryActionTypes.ATTACHMENT_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
+      createAttachmentInCurrentCardService(data),
+    ),
+    takeLatest(EntryActionTypes.ATTACHMENT_UPDATE, ({ payload: { id, data } }) =>
+      updateAttachmentService(id, data),
+    ),
+    takeLatest(EntryActionTypes.ATTACHMENT_DELETE, ({ payload: { id } }) =>
+      deleteAttachmentService(id),
+    ),
+  ]);
+}

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

@@ -0,0 +1,26 @@
+import { all, takeLatest } from 'redux-saga/effects';
+
+import {
+  createBoardInCurrentProjectService,
+  deleteBoardService,
+  fetchBoard,
+  moveBoardService,
+  updateBoardService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* () {
+  yield all([
+    takeLatest(EntryActionTypes.BOARD_IN_CURRENT_PROJECT_CREATE, ({ payload: { data } }) =>
+      createBoardInCurrentProjectService(data),
+    ),
+    takeLatest(EntryActionTypes.BOARD_FETCH, ({ payload: { id } }) => fetchBoard(id)),
+    takeLatest(EntryActionTypes.BOARD_UPDATE, ({ payload: { id, data } }) =>
+      updateBoardService(id, data),
+    ),
+    takeLatest(EntryActionTypes.BOARD_MOVE, ({ payload: { id, index } }) =>
+      moveBoardService(id, index),
+    ),
+    takeLatest(EntryActionTypes.BOARD_DELETE, ({ payload: { id } }) => deleteBoardService(id)),
+  ]);
+}

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

@@ -0,0 +1,42 @@
+import { all, takeLatest } from 'redux-saga/effects';
+
+import {
+  createCardService,
+  deleteCardService,
+  deleteCurrentCardService,
+  moveCardService,
+  moveCurrentCardService,
+  transferCardService,
+  transferCurrentCardService,
+  updateCardService,
+  updateCurrentCardService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* () {
+  yield all([
+    takeLatest(EntryActionTypes.CARD_CREATE, ({ payload: { listId, data } }) =>
+      createCardService(listId, data),
+    ),
+    takeLatest(EntryActionTypes.CARD_UPDATE, ({ payload: { id, data } }) =>
+      updateCardService(id, data),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_CARD_UPDATE, ({ payload: { data } }) =>
+      updateCurrentCardService(data),
+    ),
+    takeLatest(EntryActionTypes.CARD_MOVE, ({ payload: { id, listId, index } }) =>
+      moveCardService(id, listId, index),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_CARD_MOVE, ({ payload: { listId, index } }) =>
+      moveCurrentCardService(listId, index),
+    ),
+    takeLatest(EntryActionTypes.CARD_TRANSFER, ({ payload: { id, boardId, listId, index } }) =>
+      transferCardService(id, boardId, listId, index),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_CARD_TRANSFER, ({ payload: { boardId, listId, index } }) =>
+      transferCurrentCardService(boardId, listId, index),
+    ),
+    takeLatest(EntryActionTypes.CARD_DELETE, ({ payload: { id } }) => deleteCardService(id)),
+    takeLatest(EntryActionTypes.CURRENT_CARD_DELETE, () => deleteCurrentCardService()),
+  ]);
+}

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

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

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

@@ -0,0 +1,35 @@
+import router from './router';
+import socket from './socket';
+import login from './login';
+import modal from './modal';
+import user from './user';
+import project from './project';
+import projectMembership from './project-membership';
+import board from './board';
+import list from './list';
+import label from './label';
+import card from './card';
+import task from './task';
+import attachment from './attachment';
+import actions from './actions';
+import commentAction from './comment-action';
+import notification from './notification';
+
+export default [
+  router,
+  socket,
+  login,
+  modal,
+  user,
+  project,
+  projectMembership,
+  board,
+  list,
+  label,
+  card,
+  task,
+  attachment,
+  actions,
+  commentAction,
+  notification,
+];

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

@@ -0,0 +1,44 @@
+import { all, takeLatest } from 'redux-saga/effects';
+
+import {
+  addLabelToCardService,
+  addLabelToCurrentCardService,
+  addLabelToFilterInCurrentBoardService,
+  createLabelInCurrentBoardService,
+  deleteLabelService,
+  removeLabelFromCardService,
+  removeLabelFromCurrentCardService,
+  removeLabelFromFilterInCurrentBoardService,
+  updateLabelService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* () {
+  yield all([
+    takeLatest(EntryActionTypes.LABEL_IN_CURRENT_BOARD_CREATE, ({ payload: { data } }) =>
+      createLabelInCurrentBoardService(data),
+    ),
+    takeLatest(EntryActionTypes.LABEL_UPDATE, ({ payload: { id, data } }) =>
+      updateLabelService(id, data),
+    ),
+    takeLatest(EntryActionTypes.LABEL_DELETE, ({ payload: { id } }) => deleteLabelService(id)),
+    takeLatest(EntryActionTypes.LABEL_TO_CARD_ADD, ({ payload: { id, cardId } }) =>
+      addLabelToCardService(id, cardId),
+    ),
+    takeLatest(EntryActionTypes.LABEL_TO_CURRENT_CARD_ADD, ({ payload: { id } }) =>
+      addLabelToCurrentCardService(id),
+    ),
+    takeLatest(EntryActionTypes.LABEL_FROM_CARD_REMOVE, ({ payload: { id, cardId } }) =>
+      removeLabelFromCardService(id, cardId),
+    ),
+    takeLatest(EntryActionTypes.LABEL_FROM_CURRENT_CARD_REMOVE, ({ payload: { id } }) =>
+      removeLabelFromCurrentCardService(id),
+    ),
+    takeLatest(EntryActionTypes.LABEL_TO_FILTER_IN_CURRENT_BOARD_ADD, ({ payload: { id } }) =>
+      addLabelToFilterInCurrentBoardService(id),
+    ),
+    takeLatest(EntryActionTypes.LABEL_FROM_FILTER_IN_CURRENT_BOARD_REMOVE, ({ payload: { id } }) =>
+      removeLabelFromFilterInCurrentBoardService(id),
+    ),
+  ]);
+}

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

@@ -0,0 +1,24 @@
+import { all, takeLatest } from 'redux-saga/effects';
+
+import {
+  createListInCurrentBoardService,
+  deleteListService,
+  moveListService,
+  updateListService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* () {
+  yield all([
+    takeLatest(EntryActionTypes.LIST_IN_CURRENT_BOARD_CREATE, ({ payload: { data } }) =>
+      createListInCurrentBoardService(data),
+    ),
+    takeLatest(EntryActionTypes.LIST_UPDATE, ({ payload: { id, data } }) =>
+      updateListService(id, data),
+    ),
+    takeLatest(EntryActionTypes.LIST_MOVE, ({ payload: { id, index } }) =>
+      moveListService(id, index),
+    ),
+    takeLatest(EntryActionTypes.LIST_DELETE, ({ payload: { id } }) => deleteListService(id)),
+  ]);
+}

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { takeLatest } from 'redux-saga/effects';
+
+import { deleteNotificationService } from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* () {
+  yield takeLatest(EntryActionTypes.NOTIFICATION_DELETE, ({ payload: { id } }) =>
+    deleteNotificationService(id),
+  );
+}

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

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

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

@@ -0,0 +1,24 @@
+import { all, takeLatest } from 'redux-saga/effects';
+
+import {
+  createProjectService,
+  deleteCurrentProjectService,
+  updateCurrentProjectBackgroundImageService,
+  updateCurrentProjectService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* () {
+  yield all([
+    takeLatest(EntryActionTypes.PROJECT_CREATE, ({ payload: { data } }) =>
+      createProjectService(data),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_PROJECT_UPDATE, ({ payload: { data } }) =>
+      updateCurrentProjectService(data),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_PROJECT_BACKGROUND_IMAGE_UPDATE, ({ payload: { data } }) =>
+      updateCurrentProjectBackgroundImageService(data),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_PROJECT_DELETE, () => deleteCurrentProjectService()),
+  ]);
+}

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

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

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

@@ -0,0 +1,321 @@
+import { eventChannel } from 'redux-saga';
+import { call, cancelled, take } from 'redux-saga/effects';
+
+import {
+  createActionReceivedService,
+  createAttachmentReceivedService,
+  createBoardReceivedService,
+  createCardLabelReceivedService,
+  createCardMembershipReceivedService,
+  createCardReceivedService,
+  createLabelReceivedService,
+  createListReceivedService,
+  createNotificationReceivedService,
+  createProjectMembershipReceivedService,
+  createProjectReceivedService,
+  createTaskReceivedService,
+  createUserReceivedService,
+  deleteActionReceivedService,
+  deleteAttachmentReceivedService,
+  deleteCardLabelReceivedService,
+  deleteCardMembershipReceivedService,
+  deleteCardReceivedService,
+  deleteBoardReceivedService,
+  deleteLabelReceivedService,
+  deleteListReceivedService,
+  deleteNotificationReceivedService,
+  deleteProjectMembershipReceivedService,
+  deleteProjectReceivedService,
+  deleteTaskReceivedService,
+  deleteUserReceivedService,
+  socketDisconnectedService,
+  socketReconnectedService,
+  updateActionReceivedService,
+  updateAttachmentReceivedService,
+  updateBoardReceivedService,
+  updateCardReceivedService,
+  updateLabelReceivedService,
+  updateListReceivedService,
+  updateProjectReceivedService,
+  updateTaskReceivedService,
+  updateUserReceivedService,
+} from '../services';
+import api, { socket } from '../../../api';
+
+const createSocketEventsChannel = () =>
+  eventChannel((emit) => {
+    const handleReconnect = () => {
+      emit([socketReconnectedService]);
+    };
+
+    const handleUserCreate = ({ item }) => {
+      emit([createUserReceivedService, item]);
+    };
+
+    const handleUserUpdate = ({ item }) => {
+      emit([updateUserReceivedService, item]);
+    };
+
+    const handleUserDelete = ({ item }) => {
+      emit([deleteUserReceivedService, item]);
+    };
+
+    const handleProjectCreate = ({ item, included: { users, projectMemberships, boards } }) => {
+      emit([createProjectReceivedService, item, users, projectMemberships, boards]);
+    };
+
+    const handleProjectUpdate = ({ item }) => {
+      emit([updateProjectReceivedService, item]);
+    };
+
+    const handleProjectDelete = ({ item }) => {
+      emit([deleteProjectReceivedService, item]);
+    };
+
+    const handleProjectMembershipCreate = ({ item, included: { users } }) => {
+      emit([createProjectMembershipReceivedService, item, users[0]]);
+    };
+
+    const handleProjectMembershipDelete = ({ item }) => {
+      emit([deleteProjectMembershipReceivedService, item]);
+    };
+
+    const handleBoardCreate = ({ item, included: { lists, labels } }) => {
+      emit([createBoardReceivedService, item, lists, labels]);
+    };
+
+    const handleBoardUpdate = ({ item }) => {
+      emit([updateBoardReceivedService, item]);
+    };
+
+    const handleBoardDelete = ({ item }) => {
+      emit([deleteBoardReceivedService, item]);
+    };
+
+    const handleListCreate = ({ item }) => {
+      emit([createListReceivedService, item]);
+    };
+
+    const handleListUpdate = ({ item }) => {
+      emit([updateListReceivedService, item]);
+    };
+
+    const handleListDelete = ({ item }) => {
+      emit([deleteListReceivedService, item]);
+    };
+
+    const handleLabelCreate = ({ item }) => {
+      emit([createLabelReceivedService, item]);
+    };
+
+    const handleLabelUpdate = ({ item }) => {
+      emit([updateLabelReceivedService, item]);
+    };
+
+    const handleLabelDelete = ({ item }) => {
+      emit([deleteLabelReceivedService, item]);
+    };
+
+    const handleCardCreate = api.makeHandleCardCreate(
+      ({ item, included: { cardMemberships, cardLabels, tasks, attachments } }) => {
+        emit([createCardReceivedService, item, cardMemberships, cardLabels, tasks, attachments]);
+      },
+    );
+
+    const handleCardUpdate = api.makeHandleCardUpdate(({ item }) => {
+      emit([updateCardReceivedService, item]);
+    });
+
+    const handleCardDelete = api.makeHandleCardDelete(({ item }) => {
+      emit([deleteCardReceivedService, item]);
+    });
+
+    const handleCardMembershipCreate = ({ item }) => {
+      emit([createCardMembershipReceivedService, item]);
+    };
+
+    const handleCardMembershipDelete = ({ item }) => {
+      emit([deleteCardMembershipReceivedService, item]);
+    };
+
+    const handleCardLabelCreate = ({ item }) => {
+      emit([createCardLabelReceivedService, item]);
+    };
+
+    const handleCardLabelDelete = ({ item }) => {
+      emit([deleteCardLabelReceivedService, item]);
+    };
+
+    const handleTaskCreate = ({ item }) => {
+      emit([createTaskReceivedService, item]);
+    };
+
+    const handleTaskUpdate = ({ item }) => {
+      emit([updateTaskReceivedService, item]);
+    };
+
+    const handleTaskDelete = ({ item }) => {
+      emit([deleteTaskReceivedService, item]);
+    };
+
+    const handleAttachmentCreate = api.makeHandleAttachmentCreate(({ item, requestId }) => {
+      emit([createAttachmentReceivedService, item, requestId]);
+    });
+
+    const handleAttachmentUpdate = api.makeHandleAttachmentUpdate(({ item }) => {
+      emit([updateAttachmentReceivedService, item]);
+    });
+
+    const handleAttachmentDelete = api.makeHandleAttachmentDelete(({ item }) => {
+      emit([deleteAttachmentReceivedService, item]);
+    });
+
+    const handleActionCreate = api.makeHandleActionCreate(({ item }) => {
+      emit([createActionReceivedService, item]);
+    });
+
+    const handleActionUpdate = api.makeHandleActionUpdate(({ item }) => {
+      emit([updateActionReceivedService, item]);
+    });
+
+    const handleActionDelete = api.makeHandleActionDelete(({ item }) => {
+      emit([deleteActionReceivedService, item]);
+    });
+
+    const handleNotificationCreate = api.makeHandleNotificationCreate(
+      ({ item, included: { users, cards, actions } }) => {
+        emit([createNotificationReceivedService, item, users[0], cards[0], actions[0]]);
+      },
+    );
+
+    const handleNotificationDelete = ({ item }) => {
+      emit([deleteNotificationReceivedService, item]);
+    };
+
+    const handleDisconnect = () => {
+      socket.off('disconnect', handleDisconnect);
+
+      emit([socketDisconnectedService]);
+
+      socket.on('reconnect', handleReconnect);
+    };
+
+    socket.on('disconnect', handleDisconnect);
+
+    socket.on('userCreate', handleUserCreate);
+    socket.on('userUpdate', handleUserUpdate);
+    socket.on('userDelete', handleUserDelete);
+
+    socket.on('projectCreate', handleProjectCreate);
+    socket.on('projectUpdate', handleProjectUpdate);
+    socket.on('projectDelete', handleProjectDelete);
+
+    socket.on('projectMembershipCreate', handleProjectMembershipCreate);
+    socket.on('projectMembershipDelete', handleProjectMembershipDelete);
+
+    socket.on('boardCreate', handleBoardCreate);
+    socket.on('boardUpdate', handleBoardUpdate);
+    socket.on('boardDelete', handleBoardDelete);
+
+    socket.on('listCreate', handleListCreate);
+    socket.on('listUpdate', handleListUpdate);
+    socket.on('listDelete', handleListDelete);
+
+    socket.on('labelCreate', handleLabelCreate);
+    socket.on('labelUpdate', handleLabelUpdate);
+    socket.on('labelDelete', handleLabelDelete);
+
+    socket.on('cardCreate', handleCardCreate);
+    socket.on('cardUpdate', handleCardUpdate);
+    socket.on('cardDelete', handleCardDelete);
+
+    socket.on('cardMembershipCreate', handleCardMembershipCreate);
+    socket.on('cardMembershipDelete', handleCardMembershipDelete);
+
+    socket.on('cardLabelCreate', handleCardLabelCreate);
+    socket.on('cardLabelDelete', handleCardLabelDelete);
+
+    socket.on('taskCreate', handleTaskCreate);
+    socket.on('taskUpdate', handleTaskUpdate);
+    socket.on('taskDelete', handleTaskDelete);
+
+    socket.on('attachmentCreate', handleAttachmentCreate);
+    socket.on('attachmentUpdate', handleAttachmentUpdate);
+    socket.on('attachmentDelete', handleAttachmentDelete);
+
+    socket.on('actionCreate', handleActionCreate);
+    socket.on('actionUpdate', handleActionUpdate);
+    socket.on('actionDelete', handleActionDelete);
+
+    socket.on('notificationCreate', handleNotificationCreate);
+    socket.on('notificationUpdate', handleNotificationDelete);
+
+    return () => {
+      socket.off('disconnect', handleDisconnect);
+      socket.off('reconnect', handleReconnect);
+
+      socket.off('userCreate', handleUserCreate);
+      socket.off('userUpdate', handleUserUpdate);
+      socket.off('userDelete', handleUserDelete);
+
+      socket.off('projectCreate', handleProjectCreate);
+      socket.off('projectUpdate', handleProjectUpdate);
+      socket.off('projectDelete', handleProjectDelete);
+
+      socket.off('projectMembershipCreate', handleProjectMembershipCreate);
+      socket.off('projectMembershipDelete', handleProjectMembershipDelete);
+
+      socket.off('boardCreate', handleBoardCreate);
+      socket.off('boardUpdate', handleBoardUpdate);
+      socket.off('boardDelete', handleBoardDelete);
+
+      socket.off('listCreate', handleListCreate);
+      socket.off('listUpdate', handleListUpdate);
+      socket.off('listDelete', handleListDelete);
+
+      socket.off('labelCreate', handleLabelCreate);
+      socket.off('labelUpdate', handleLabelUpdate);
+      socket.off('labelDelete', handleLabelDelete);
+
+      socket.off('cardCreate', handleCardCreate);
+      socket.off('cardUpdate', handleCardUpdate);
+      socket.off('cardDelete', handleCardDelete);
+
+      socket.off('cardMembershipCreate', handleCardMembershipCreate);
+      socket.off('cardMembershipDelete', handleCardMembershipDelete);
+
+      socket.off('cardLabelCreate', handleCardLabelCreate);
+      socket.off('cardLabelDelete', handleCardLabelDelete);
+
+      socket.off('taskCreate', handleTaskCreate);
+      socket.off('taskUpdate', handleTaskUpdate);
+      socket.off('taskDelete', handleTaskDelete);
+
+      socket.off('attachmentCreate', handleAttachmentCreate);
+      socket.off('attachmentUpdate', handleAttachmentUpdate);
+      socket.off('attachmentDelete', handleAttachmentDelete);
+
+      socket.off('actionCreate', handleActionCreate);
+      socket.off('actionUpdate', handleActionUpdate);
+      socket.off('actionDelete', handleActionDelete);
+
+      socket.off('notificationCreate', handleNotificationCreate);
+      socket.off('notificationUpdate', handleNotificationDelete);
+    };
+  });
+
+export default function* () {
+  const socketEventsChannel = yield call(createSocketEventsChannel);
+
+  try {
+    while (true) {
+      const args = yield take(socketEventsChannel);
+
+      yield call(...args);
+    }
+  } finally {
+    if (yield cancelled()) {
+      socketEventsChannel.close();
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+import { all, takeLatest } from 'redux-saga/effects';
+
+import { createTaskInCurrentCardService, deleteTaskService, updateTaskService } from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* () {
+  yield all([
+    takeLatest(EntryActionTypes.TASK_IN_CURRENT_CARD_CREATE, ({ payload: { data } }) =>
+      createTaskInCurrentCardService(data),
+    ),
+    takeLatest(EntryActionTypes.TASK_UPDATE, ({ payload: { id, data } }) =>
+      updateTaskService(id, data),
+    ),
+    takeLatest(EntryActionTypes.TASK_DELETE, ({ payload: { id } }) => deleteTaskService(id)),
+  ]);
+}

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

@@ -0,0 +1,76 @@
+import { all, takeLatest } from 'redux-saga/effects';
+
+import {
+  addUserToCardService,
+  addUserToCurrentCardService,
+  addUserToFilterInCurrentBoardService,
+  clearCurrentUserEmailUpdateErrorService,
+  clearCurrentUserPasswordUpdateErrorService,
+  clearCurrentUserUsernameUpdateErrorService,
+  clearUserCreateErrorService,
+  createUserService,
+  deleteUserService,
+  removeUserFromCardService,
+  removeUserFromCurrentCardService,
+  removeUserFromFilterInCurrentBoardService,
+  updateUserService,
+  updateCurrentUserAvatarService,
+  updateCurrentUserEmailService,
+  updateCurrentUserPasswordService,
+  updateCurrentUserService,
+  updateCurrentUserUsernameService,
+} from '../services';
+import EntryActionTypes from '../../../constants/EntryActionTypes';
+
+export default function* () {
+  yield all([
+    takeLatest(EntryActionTypes.USER_CREATE, ({ payload: { data } }) => createUserService(data)),
+    takeLatest(EntryActionTypes.USER_CREATE_ERROR_CLEAR, () => clearUserCreateErrorService()),
+    takeLatest(EntryActionTypes.USER_UPDATE, ({ payload: { id, data } }) =>
+      updateUserService(id, data),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_USER_UPDATE, ({ payload: { data } }) =>
+      updateCurrentUserService(data),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_USER_EMAIL_UPDATE, ({ payload: { data } }) =>
+      updateCurrentUserEmailService(data),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_USER_EMAIL_UPDATE_ERROR_CLEAR, () =>
+      clearCurrentUserEmailUpdateErrorService(),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_USER_PASSWORD_UPDATE, ({ payload: { data } }) =>
+      updateCurrentUserPasswordService(data),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_USER_PASSWORD_UPDATE_ERROR_CLEAR, () =>
+      clearCurrentUserPasswordUpdateErrorService(),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_USER_USERNAME_UPDATE, ({ payload: { data } }) =>
+      updateCurrentUserUsernameService(data),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_USER_USERNAME_UPDATE_ERROR_CLEAR, () =>
+      clearCurrentUserUsernameUpdateErrorService(),
+    ),
+    takeLatest(EntryActionTypes.CURRENT_USER_AVATAR_UPDATE, ({ payload: { data } }) =>
+      updateCurrentUserAvatarService(data),
+    ),
+    takeLatest(EntryActionTypes.USER_DELETE, ({ payload: { id } }) => deleteUserService(id)),
+    takeLatest(EntryActionTypes.USER_TO_CARD_ADD, ({ payload: { id, cardId } }) =>
+      addUserToCardService(id, cardId),
+    ),
+    takeLatest(EntryActionTypes.USER_TO_CURRENT_CARD_ADD, ({ payload: { id } }) =>
+      addUserToCurrentCardService(id),
+    ),
+    takeLatest(EntryActionTypes.USER_FROM_CARD_REMOVE, ({ payload: { id, cardId } }) =>
+      removeUserFromCardService(id, cardId),
+    ),
+    takeLatest(EntryActionTypes.USER_FROM_CURRENT_CARD_REMOVE, ({ payload: { id } }) =>
+      removeUserFromCurrentCardService(id),
+    ),
+    takeLatest(EntryActionTypes.USER_TO_FILTER_IN_CURRENT_BOARD_ADD, ({ payload: { id } }) =>
+      addUserToFilterInCurrentBoardService(id),
+    ),
+    takeLatest(EntryActionTypes.USER_FROM_FILTER_IN_CURRENT_BOARD_REMOVE, ({ payload: { id } }) =>
+      removeUserFromFilterInCurrentBoardService(id),
+    ),
+  ]);
+}