fivemoons/planka-zh
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ref: Refactoring

Browse Source
This commit is contained in:
Maksim Eltyshev
2022-08-04 13:31:14 +02:00
parent 1f569bdb61
commit 3714bbc06f
189 changed files with 3781 additions and 3486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
client/src/sagas/core/index.js
View File

@@ -1,7 +1,7 @@
import { all, apply, call, fork, take } from 'redux-saga/effects';
import watchers from './watchers';
import { initializeCoreService } from './services';
import services from './services';
import { socket } from '../../api';
import { removeAccessToken } from '../../utils/access-token-storage';
import ActionTypes from '../../constants/ActionTypes';
@@ -11,7 +11,7 @@ export default function* coreSaga() {
yield all(watchers.map((watcher) => fork(watcher)));
yield apply(socket, socket.connect);
yield fork(initializeCoreService);
yield fork(services.initializeCore);
yield take(ActionTypes.LOGOUT);

4
client/src/sagas/core/request.js
View File

@@ -1,6 +1,6 @@
import { call, fork, join, put, take } from 'redux-saga/effects';
import { logout } from '../../actions';
import actions from '../../actions';
import ErrorCodes from '../../constants/ErrorCodes';
let lastRequestTask;
@@ -16,7 +16,7 @@ function* queueRequest(method, ...args) {
return yield call(method, ...args);
} catch (error) {
if (error.code === ErrorCodes.UNAUTHORIZED) {
yield put(logout()); // TODO: next url
yield put(actions.logout()); // TODO: next url
yield take();
}

11
client/src/sagas/core/requests/board.js → client/src/sagas/core/requests/boards.js
View File

@@ -1,13 +1,12 @@
import { call, select } from 'redux-saga/effects';
import request from '../request';
import { pathsMatchSelector } from '../../../selectors';
import selectors from '../../../selectors';
import api from '../../../api';
import Paths from '../../../constants/Paths';
// eslint-disable-next-line import/prefer-default-export
export function* fetchBoardByCurrentPathRequest() {
const pathsMatch = yield select(pathsMatchSelector);
export function* fetchBoardByCurrentPath() {
const pathsMatch = yield select(selectors.selectPathsMatch);
let board;
let card;
@@ -67,3 +66,7 @@ export function* fetchBoardByCurrentPathRequest() {
project: projects[0],
};
}
export default {
fetchBoardByCurrentPath,
};

15
client/src/sagas/core/requests/core.js
View File

@@ -1,12 +1,11 @@
import { call } from 'redux-saga/effects';
import { fetchBoardByCurrentPathRequest } from './board';
import { fetchBoardByCurrentPath } from './boards';
import request from '../request';
import api from '../../../api';
import mergeRecords from '../../../utils/merge-records';
// eslint-disable-next-line import/prefer-default-export
export function* fetchCoreRequest() {
export function* fetchCore() {
const { item: user } = yield call(request, api.getCurrentUser);
const { items: users1 } = yield call(request, api.getUsers);
@@ -42,7 +41,7 @@ export function* fetchCoreRequest() {
cardLabels,
tasks,
attachments,
} = yield call(fetchBoardByCurrentPathRequest));
} = yield call(fetchBoardByCurrentPath));
} catch {} // eslint-disable-line no-empty
const body = yield call(request, api.getNotifications);
@@ -50,7 +49,7 @@ export function* fetchCoreRequest() {
let { items: notifications } = body;
const {
included: { users: users3, cards: cards2, actions },
included: { users: users3, cards: cards2, activities },
} = body;
if (card) {
@@ -80,7 +79,7 @@ export function* fetchCoreRequest() {
cardLabels,
tasks,
attachments,
actions,
activities,
notifications,
users: mergeRecords(users1, users2, users3),
projects: mergeRecords(projects1, projects2),
@@ -88,3 +87,7 @@ export function* fetchCoreRequest() {
cards: mergeRecords(cards1, cards2),
};
}
export default {
fetchCore,
};

9
client/src/sagas/core/requests/index.js
View File

@@ -1,2 +1,7 @@
export * from './core';
export * from './board';
import core from './core';
import boards from './boards';
export default {
...core,
...boards,
};

15
client/src/sagas/core/services/action.js
View File

@@ -1,15 +0,0 @@
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));
}

66
client/src/sagas/core/services/actions.js
View File

@@ -1,66 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import { cardByIdSelector, lastActionIdByCardIdSelector, pathSelector } from '../../../selectors';
import { fetchActions, toggleActionsDetails } from '../../../actions';
import api from '../../../api';
export function* fetchActionsService(cardId) {
const { isActionsDetailsVisible } = yield select(cardByIdSelector, cardId);
const lastId = yield select(lastActionIdByCardIdSelector, cardId);
yield put(fetchActions(cardId));
let actions;
let users;
try {
({
items: actions,
included: { users },
} = yield call(request, api.getActions, cardId, {
beforeId: lastId,
withDetails: isActionsDetailsVisible,
}));
} catch (error) {
yield put(fetchActions.failure(cardId, error));
return;
}
yield put(fetchActions.success(cardId, actions, users));
}
export function* fetchActionsInCurrentCardService() {
const { cardId } = yield select(pathSelector);
yield call(fetchActionsService, cardId);
}
export function* toggleActionsDetailsService(cardId, isVisible) {
yield put(toggleActionsDetails(cardId, isVisible));
if (isVisible) {
let actions;
let users;
try {
({
items: actions,
included: { users },
} = yield call(request, api.getActions, cardId, {
withDetails: isVisible,
}));
} catch (error) {
yield put(toggleActionsDetails.failure(cardId, error));
return;
}
yield put(toggleActionsDetails.success(cardId, actions, users));
}
}
export function* toggleActionsDetailsInCurrentCardService(isVisible) {
const { cardId } = yield select(pathSelector);
yield call(toggleActionsDetailsService, cardId, isVisible);
}

88
client/src/sagas/core/services/activities.js Normal file
View File

@@ -0,0 +1,88 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
export function* fetchActivities(cardId) {
const { isActivitiesDetailsVisible } = yield select(selectors.selectCardById, cardId);
const lastId = yield select(selectors.selectLastActivityIdByCardId, cardId);
yield put(actions.fetchActivities(cardId));
let activities;
let users;
try {
({
items: activities,
included: { users },
} = yield call(request, api.getActivities, cardId, {
beforeId: lastId,
withDetails: isActivitiesDetailsVisible,
}));
} catch (error) {
yield put(actions.fetchActivities.failure(cardId, error));
return;
}
yield put(actions.fetchActivities.success(cardId, activities, users));
}
export function* fetchActivitiesInCurrentCard() {
const { cardId } = yield select(selectors.selectPath);
yield call(fetchActivities, cardId);
}
export function* toggleActivitiesDetails(cardId, isVisible) {
yield put(actions.toggleActivitiesDetails(cardId, isVisible));
if (isVisible) {
let activities;
let users;
try {
({
items: activities,
included: { users },
} = yield call(request, api.getActivities, cardId, {
withDetails: isVisible,
}));
} catch (error) {
yield put(actions.toggleActivitiesDetails.failure(cardId, error));
return;
}
yield put(actions.toggleActivitiesDetails.success(cardId, activities, users));
}
}
export function* toggleActivitiesDetailsInCurrentCard(isVisible) {
const { cardId } = yield select(selectors.selectPath);
yield call(toggleActivitiesDetails, cardId, isVisible);
}
export function* handleActivityCreate(activity) {
yield put(actions.handleActivityCreate(activity));
}
export function* handleActivityUpdate(activity) {
yield put(actions.handleActivityUpdate(activity));
}
export function* handleActivityDelete(activity) {
yield put(actions.handleActivityDelete(activity));
}
export default {
fetchActivities,
fetchActivitiesInCurrentCard,
toggleActivitiesDetails,
toggleActivitiesDetailsInCurrentCard,
handleActivityCreate,
handleActivityUpdate,
handleActivityDelete,
};

86
client/src/sagas/core/services/attachment.js
View File

@@ -1,86 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import { isAttachmentWithIdExistsSelector, pathSelector } from '../../../selectors';
import {
createAttachment,
deleteAttachment,
handleAttachmentCreate,
handleAttachmentDelete,
handleAttachmentUpdate,
updateAttachment,
} from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createAttachmentService(cardId, data) {
const localId = yield call(createLocalId);
yield put(
createAttachment({
cardId,
id: localId,
name: data.file.name,
}),
);
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) {
const { cardId } = yield select(pathSelector);
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));
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));
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));
}

89
client/src/sagas/core/services/attachments.js Normal file
View File

@@ -0,0 +1,89 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createAttachment(cardId, data) {
const localId = yield call(createLocalId);
yield put(
actions.createAttachment({
cardId,
id: localId,
name: data.file.name,
}),
);
let attachment;
try {
({ item: attachment } = yield call(request, api.createAttachment, cardId, data, localId));
} catch (error) {
yield put(actions.createAttachment.failure(localId, error));
return;
}
yield put(actions.createAttachment.success(localId, attachment));
}
export function* createAttachmentInCurrentCard(data) {
const { cardId } = yield select(selectors.selectPath);
yield call(createAttachment, cardId, data);
}
export function* handleAttachmentCreate(attachment, requestId) {
const isExists = yield select(selectors.selectIsAttachmentWithIdExists, requestId);
if (!isExists) {
yield put(actions.handleAttachmentCreate(attachment));
}
}
export function* updateAttachment(id, data) {
yield put(actions.updateAttachment(id, data));
let attachment;
try {
({ item: attachment } = yield call(request, api.updateAttachment, id, data));
} catch (error) {
yield put(actions.updateAttachment.failure(id, error));
return;
}
yield put(actions.updateAttachment.success(attachment));
}
export function* handleAttachmentUpdate(attachment) {
yield put(actions.handleAttachmentUpdate(attachment));
}
export function* deleteAttachment(id) {
yield put(actions.deleteAttachment(id));
let attachment;
try {
({ item: attachment } = yield call(request, api.deleteAttachment, id));
} catch (error) {
yield put(actions.deleteAttachment.failure(id, error));
return;
}
yield put(actions.deleteAttachment.success(attachment));
}
export function* handleAttachmentDelete(attachment) {
yield put(actions.handleAttachmentDelete(attachment));
}
export default {
createAttachment,
createAttachmentInCurrentCard,
handleAttachmentCreate,
updateAttachment,
handleAttachmentUpdate,
deleteAttachment,
handleAttachmentDelete,
};

95
client/src/sagas/core/services/board-membership.js → client/src/sagas/core/services/board-memberships.js
View File

@@ -1,30 +1,19 @@
import { call, put, select } from 'redux-saga/effects';
import { goToProjectService } from './router';
import { goToProject } 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 requests from '../requests';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
import mergeRecords from '../../../utils/merge-records';
export function* createBoardMembershipService(boardId, data) {
export function* createBoardMembership(boardId, data) {
const localId = yield call(createLocalId);
yield put(
createBoardMembership({
actions.createBoardMembership({
...data,
boardId,
id: localId,
@@ -35,21 +24,21 @@ export function* createBoardMembershipService(boardId, data) {
try {
({ item: boardMembership } = yield call(request, api.createBoardMembership, boardId, data));
} catch (error) {
yield put(createBoardMembership.failure(localId, error));
yield put(actions.createBoardMembership.failure(localId, error));
return;
}
yield put(createBoardMembership.success(localId, boardMembership));
yield put(actions.createBoardMembership.success(localId, boardMembership));
}
export function* createMembershipInCurrentBoardService(data) {
const { boardId } = yield select(pathSelector);
export function* createMembershipInCurrentBoard(data) {
const { boardId } = yield select(selectors.selectPath);
yield call(createBoardMembershipService, boardId, data);
yield call(createBoardMembership, boardId, data);
}
export function* handleBoardMembershipCreateService(boardMembership) {
const currentUserId = yield select(currentUserIdSelector);
export function* handleBoardMembershipCreate(boardMembership) {
const currentUserId = yield select(selectors.selectCurrentUserId);
const isCurrentUser = boardMembership.userId === currentUserId;
let user;
@@ -68,7 +57,7 @@ export function* handleBoardMembershipCreateService(boardMembership) {
let cardLabels;
let tasks;
let attachments;
let notifications;
let deletedNotifications;
if (isCurrentUser) {
let board2;
@@ -78,9 +67,11 @@ export function* handleBoardMembershipCreateService(boardMembership) {
return;
}
const { boardId } = yield select(pathSelector);
const { boardId } = yield select(selectors.selectPath);
yield put(handleBoardMembershipCreate.fetchProject(board2.projectId, currentUserId, boardId));
yield put(
actions.handleBoardMembershipCreate.fetchProject(board2.projectId, currentUserId, boardId),
);
try {
({
@@ -93,7 +84,7 @@ export function* handleBoardMembershipCreateService(boardMembership) {
let body;
try {
body = yield call(fetchBoardByCurrentPathRequest);
body = yield call(requests.fetchBoardByCurrentPathRequest);
} catch {} // eslint-disable-line no-empty
if (body && body.project && body.project.id === board2.projectId) {
@@ -112,7 +103,7 @@ export function* handleBoardMembershipCreateService(boardMembership) {
} = body);
if (body.card) {
notifications = yield select(notificationsByCardIdSelector, body.card.id);
deletedNotifications = yield select(selectors.selectNotificationsByCardId, body.card.id);
}
}
} else {
@@ -124,7 +115,7 @@ export function* handleBoardMembershipCreateService(boardMembership) {
}
yield put(
handleBoardMembershipCreate(
actions.handleBoardMembershipCreate(
boardMembership,
project,
board1,
@@ -139,48 +130,60 @@ export function* handleBoardMembershipCreateService(boardMembership) {
cardLabels,
tasks,
attachments,
notifications,
deletedNotifications,
),
);
}
export function* deleteBoardMembershipService(id) {
let boardMembership = yield select(boardMembershipByIdSelector, id);
export function* deleteBoardMembership(id) {
let boardMembership = yield select(selectors.selectBoardMembershipById, id);
const currentUserId = yield select(currentUserIdSelector);
const { boardId, projectId } = yield select(pathSelector);
const currentUserId = yield select(selectors.selectCurrentUserId);
const { boardId, projectId } = yield select(selectors.selectPath);
if (boardMembership.userId === currentUserId && boardMembership.boardId === boardId) {
const isCurrentUserManager = yield select(isCurrentUserManagerForCurrentProjectSelector);
const isCurrentUserManager = yield select(
selectors.selectIsCurrentUserManagerForCurrentProject,
);
if (!isCurrentUserManager) {
yield call(goToProjectService, projectId);
yield call(goToProject, projectId);
}
}
yield put(deleteBoardMembership(id));
yield put(actions.deleteBoardMembership(id));
try {
({ item: boardMembership } = yield call(request, api.deleteBoardMembership, id));
} catch (error) {
yield put(deleteBoardMembership.failure(id, error));
yield put(actions.deleteBoardMembership.failure(id, error));
return;
}
yield put(deleteBoardMembership.success(boardMembership));
yield put(actions.deleteBoardMembership.success(boardMembership));
}
export function* handleBoardMembershipDeleteService(boardMembership) {
const currentUserId = yield select(currentUserIdSelector);
const { boardId, projectId } = yield select(pathSelector);
export function* handleBoardMembershipDelete(boardMembership) {
const currentUserId = yield select(selectors.selectCurrentUserId);
const { boardId, projectId } = yield select(selectors.selectPath);
if (boardMembership.userId === currentUserId && boardMembership.boardId === boardId) {
const isCurrentUserManager = yield select(isCurrentUserManagerForCurrentProjectSelector);
const isCurrentUserManager = yield select(
selectors.selectIsCurrentUserManagerForCurrentProject,
);
if (!isCurrentUserManager) {
yield call(goToProjectService, projectId);
yield call(goToProject, projectId);
}
}
yield put(handleBoardMembershipDelete(boardMembership));
yield put(actions.handleBoardMembershipDelete(boardMembership));
}
export default {
createBoardMembership,
createMembershipInCurrentBoard,
handleBoardMembershipCreate,
deleteBoardMembership,
handleBoardMembershipDelete,
};

169
client/src/sagas/core/services/board.js
View File

@@ -1,169 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
import { goToBoardService, goToProjectService } from './router';
import request from '../request';
import { boardByIdSelector, nextBoardPositionSelector, pathSelector } from '../../../selectors';
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) {
const nextData = {
...data,
position: yield select(nextBoardPositionSelector, projectId),
};
const localId = yield call(createLocalId);
yield put(
createBoard({
...nextData,
projectId,
id: localId,
}),
);
let board;
let boardMemberships;
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) {
const { projectId } = yield select(pathSelector);
yield call(createBoardService, projectId, data);
}
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));
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) {
const { projectId } = yield select(boardByIdSelector, id);
const position = yield select(nextBoardPositionSelector, projectId, index, id);
yield call(updateBoardService, id, {
position,
});
}
export function* deleteBoardService(id) {
const { boardId, projectId } = yield select(pathSelector);
if (id === boardId) {
yield call(goToProjectService, projectId);
}
yield put(deleteBoard(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));
}

173
client/src/sagas/core/services/boards.js Normal file
View File

@@ -0,0 +1,173 @@
import { call, put, select } from 'redux-saga/effects';
import { goToBoard, goToProject } from './router';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createBoard(projectId, data) {
const nextData = {
...data,
position: yield select(selectors.selectNextBoardPosition, projectId),
};
const localId = yield call(createLocalId);
yield put(
actions.createBoard({
...nextData,
projectId,
id: localId,
}),
);
let board;
let boardMemberships;
try {
({
item: board,
included: { boardMemberships },
} = yield call(request, api.createBoard, projectId, nextData));
} catch (error) {
yield put(actions.createBoard.failure(localId, error));
return;
}
yield put(actions.createBoard.success(localId, board, boardMemberships));
yield call(goToBoard, board.id);
}
export function* createBoardInCurrentProject(data) {
const { projectId } = yield select(selectors.selectPath);
yield call(createBoard, projectId, data);
}
export function* handleBoardCreate(board) {
yield put(actions.handleBoardCreate(board));
}
export function* fetchBoard(id) {
yield put(actions.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(actions.fetchBoard.failure(id, error));
return;
}
yield put(
actions.fetchBoard.success(
board,
users,
projects,
boardMemberships,
labels,
lists,
cards,
cardMemberships,
cardLabels,
tasks,
attachments,
),
);
}
export function* updateBoard(id, data) {
yield put(actions.updateBoard(id, data));
let board;
try {
({ item: board } = yield call(request, api.updateBoard, id, data));
} catch (error) {
yield put(actions.updateBoard.failure(id, error));
return;
}
yield put(actions.updateBoard.success(board));
}
export function* handleBoardUpdate(board) {
yield put(actions.handleBoardUpdate(board));
}
export function* moveBoard(id, index) {
const { projectId } = yield select(selectors.selectBoardById, id);
const position = yield select(selectors.selectNextBoardPosition, projectId, index, id);
yield call(updateBoard, id, {
position,
});
}
export function* deleteBoard(id) {
const { boardId, projectId } = yield select(selectors.selectPath);
if (id === boardId) {
yield call(goToProject, projectId);
}
yield put(actions.deleteBoard(id));
let board;
try {
({ item: board } = yield call(request, api.deleteBoard, id));
} catch (error) {
yield put(actions.deleteBoard.failure(id, error));
return;
}
yield put(actions.deleteBoard.success(board));
}
export function* handleBoardDelete(board) {
const { boardId, projectId } = yield select(selectors.selectPath);
if (board.id === boardId) {
yield call(goToProject, projectId);
}
yield put(actions.handleBoardDelete(board));
}
export default {
createBoard,
createBoardInCurrentProject,
handleBoardCreate,
fetchBoard,
updateBoard,
handleBoardUpdate,
moveBoard,
deleteBoard,
handleBoardDelete,
};

145
client/src/sagas/core/services/card.js
View File

@@ -1,145 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
import { goToBoardService } from './router';
import request from '../request';
import { listByIdSelector, nextCardPositionSelector, pathSelector } from '../../../selectors';
import {
createCard,
deleteCard,
handleCardCreate,
handleCardDelete,
handleCardUpdate,
updateCard,
} from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createCardService(listId, data) {
const { boardId } = yield select(listByIdSelector, listId);
const nextData = {
...data,
listId,
position: yield select(nextCardPositionSelector, listId),
};
const localId = yield call(createLocalId);
yield put(
createCard({
...nextData,
boardId,
id: localId,
}),
);
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));
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) {
const { cardId } = yield select(pathSelector);
yield call(updateCardService, cardId, data);
}
export function* moveCardService(id, listId, index) {
const position = yield select(nextCardPositionSelector, listId, index, id);
yield call(updateCardService, id, {
listId,
position,
});
}
export function* moveCurrentCardService(listId, index) {
const { cardId } = yield select(pathSelector);
yield call(moveCardService, cardId, listId, index);
}
export function* transferCardService(id, boardId, listId, index) {
const { cardId: currentCardId, boardId: currentBoardId } = yield select(pathSelector);
const position = yield select(nextCardPositionSelector, listId, index, id);
if (id === currentCardId) {
yield call(goToBoardService, currentBoardId);
}
yield call(updateCardService, id, {
boardId,
listId,
position,
});
}
export function* transferCurrentCardService(boardId, listId, index) {
const { cardId } = yield select(pathSelector);
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);
if (id === cardId) {
yield call(goToBoardService, boardId);
}
yield put(deleteCard(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() {
const { cardId } = yield select(pathSelector);
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));
}

153
client/src/sagas/core/services/cards.js Normal file
View File

@@ -0,0 +1,153 @@
import { call, put, select } from 'redux-saga/effects';
import { goToBoard } from './router';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createCard(listId, data) {
const { boardId } = yield select(selectors.selectListById, listId);
const nextData = {
...data,
listId,
position: yield select(selectors.selectNextCardPosition, listId),
};
const localId = yield call(createLocalId);
yield put(
actions.createCard({
...nextData,
boardId,
id: localId,
}),
);
let card;
try {
({ item: card } = yield call(request, api.createCard, boardId, nextData));
} catch (error) {
yield put(actions.createCard.failure(localId, error));
return;
}
yield put(actions.createCard.success(localId, card));
}
export function* handleCardCreate(card) {
yield put(actions.handleCardCreate(card));
}
export function* updateCard(id, data) {
yield put(actions.updateCard(id, data));
let card;
try {
({ item: card } = yield call(request, api.updateCard, id, data));
} catch (error) {
yield put(actions.updateCard.failure(id, error));
return;
}
yield put(actions.updateCard.success(card));
}
export function* updateCurrentCard(data) {
const { cardId } = yield select(selectors.selectPath);
yield call(updateCard, cardId, data);
}
export function* handleCardUpdate(card) {
yield put(actions.handleCardUpdate(card)); // TODO: handle card transfer
}
export function* moveCard(id, listId, index) {
const position = yield select(selectors.selectNextCardPosition, listId, index, id);
yield call(updateCard, id, {
listId,
position,
});
}
export function* moveCurrentCard(listId, index) {
const { cardId } = yield select(selectors.selectPath);
yield call(moveCard, cardId, listId, index);
}
export function* transferCard(id, boardId, listId, index) {
const { cardId: currentCardId, boardId: currentBoardId } = yield select(selectors.selectPath);
const position = yield select(selectors.selectNextCardPosition, listId, index, id);
if (id === currentCardId) {
yield call(goToBoard, currentBoardId);
}
yield call(updateCard, id, {
boardId,
listId,
position,
});
}
export function* transferCurrentCard(boardId, listId, index) {
const { cardId } = yield select(selectors.selectPath);
yield call(transferCard, cardId, boardId, listId, index);
}
export function* deleteCard(id) {
const { cardId, boardId } = yield select(selectors.selectPath);
if (id === cardId) {
yield call(goToBoard, boardId);
}
yield put(actions.deleteCard(id));
let card;
try {
({ item: card } = yield call(request, api.deleteCard, id));
} catch (error) {
yield put(actions.deleteCard.failure(id, error));
return;
}
yield put(actions.deleteCard.success(card));
}
export function* deleteCurrentCard() {
const { cardId } = yield select(selectors.selectPath);
yield call(deleteCard, cardId);
}
export function* handleCardDelete(card) {
const { cardId, boardId } = yield select(selectors.selectPath);
if (card.id === cardId) {
yield call(goToBoard, boardId);
}
yield put(actions.handleCardDelete(card));
}
export default {
createCard,
handleCardCreate,
updateCard,
updateCurrentCard,
moveCard,
moveCurrentCard,
transferCard,
transferCurrentCard,
handleCardUpdate,
deleteCard,
deleteCurrentCard,
handleCardDelete,
};

67
client/src/sagas/core/services/comment-action.js
View File

@@ -1,67 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
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';
export function* createCommentActionService(cardId, data) {
const localId = yield call(createLocalId);
const userId = yield select(currentUserIdSelector);
yield put(
createCommentAction({
cardId,
userId,
data,
id: localId,
type: ActionTypes.COMMENT_CARD,
}),
);
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) {
const { cardId } = yield select(pathSelector);
yield call(createCommentActionService, cardId, data);
}
export function* updateCommentActionService(id, data) {
yield put(updateCommentAction(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));
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));
}

74
client/src/sagas/core/services/comment-activities.js Normal file
View File

@@ -0,0 +1,74 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
import { ActivityTypes } from '../../../constants/Enums';
export function* createCommentActivity(cardId, data) {
const localId = yield call(createLocalId);
const userId = yield select(selectors.selectCurrentUserId);
yield put(
actions.createCommentActivity({
cardId,
userId,
data,
id: localId,
type: ActivityTypes.COMMENT_CARD,
}),
);
let activity;
try {
({ item: activity } = yield call(request, api.createCommentActivity, cardId, data));
} catch (error) {
yield put(actions.createCommentActivity.failure(localId, error));
return;
}
yield put(actions.createCommentActivity.success(localId, activity));
}
export function* createCommentActivityInCurrentCard(data) {
const { cardId } = yield select(selectors.selectPath);
yield call(createCommentActivity, cardId, data);
}
export function* updateCommentActivity(id, data) {
yield put(actions.updateCommentActivity(id, data));
let activity;
try {
({ item: activity } = yield call(request, api.updateCommentActivity, id, data));
} catch (error) {
yield put(actions.updateCommentActivity.failure(id, error));
return;
}
yield put(actions.updateCommentActivity.success(activity));
}
export function* deleteCommentActivity(id) {
yield put(actions.deleteCommentActivity(id));
let activity;
try {
({ item: activity } = yield call(request, api.deleteCommentActivity, id));
} catch (error) {
yield put(actions.deleteCommentActivity.failure(id, error));
return;
}
yield put(actions.deleteCommentActivity.success(activity));
}
export default {
createCommentActivity,
createCommentActivityInCurrentCard,
updateCommentActivity,
deleteCommentActivity,
};

29
client/src/sagas/core/services/core.js
View File

@@ -1,10 +1,10 @@
import { call, put } from 'redux-saga/effects';
import { call, put, take } from 'redux-saga/effects';
import { fetchCoreRequest } from '../requests';
import { initializeCore } from '../../../actions';
import requests from '../requests';
import actions from '../../../actions';
import i18n from '../../../i18n';
export function* initializeCoreService() {
export function* initializeCore() {
const {
user,
board,
@@ -20,15 +20,15 @@ export function* initializeCoreService() {
cardLabels,
tasks,
attachments,
actions,
activities,
notifications,
} = yield call(fetchCoreRequest); // TODO: handle error
} = yield call(requests.fetchCore); // TODO: handle error
yield call(i18n.changeLanguage, user.language);
yield call(i18n.loadCoreLocale);
yield put(
initializeCore(
actions.initializeCore(
user,
board,
users,
@@ -43,13 +43,13 @@ export function* initializeCoreService() {
cardLabels,
tasks,
attachments,
actions,
activities,
notifications,
),
);
}
export function* changeCoreLanguageService(language) {
export function* changeCoreLanguage(language) {
if (language === null) {
yield call(i18n.detectLanguage);
yield call(i18n.loadCoreLocale);
@@ -59,3 +59,14 @@ export function* changeCoreLanguageService(language) {
yield call(i18n.changeLanguage, language);
}
}
export function* logout() {
yield put(actions.logout());
yield take();
}
export default {
initializeCore,
changeCoreLanguage,
logout,
};

56
client/src/sagas/core/services/index.js
View File

@@ -1,19 +1,37 @@
export * from './router';
export * from './socket';
export * from './login';
export * from './core';
export * from './modal';
export * from './user';
export * from './project';
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 './notification';
import router from './router';
import socket from './socket';
import core from './core';
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,
...core,
...modals,
...users,
...projects,
...projectManagers,
...boards,
...boardMemberships,
...labels,
...lists,
...cards,
...tasks,
...attachments,
...activities,
...commentActivities,
...notifications,
};

158
client/src/sagas/core/services/label.js
View File

@@ -1,158 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
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) {
const localId = yield call(createLocalId);
yield put(
createLabel({
...data,
boardId,
id: localId,
}),
);
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) {
const { boardId } = yield select(pathSelector);
yield call(createLabelService, boardId, data);
}
export function* handleLabelCreateService(label) {
yield put(handleLabelCreate(label));
}
export function* updateLabelService(id, data) {
yield put(updateLabel(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));
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));
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) {
const { cardId } = yield select(pathSelector);
yield call(addLabelToCardService, id, cardId);
}
export function* handleLabelToCardAddService(cardLabel) {
yield put(handleLabelToCardAdd(cardLabel));
}
export function* removeLabelFromCardService(id, cardId) {
yield put(removeLabelFromCard(id, cardId));
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) {
const { cardId } = yield select(pathSelector);
yield call(removeLabelFromCardService, id, cardId);
}
export function* handleLabelFromCardRemoveService(cardLabel) {
yield put(handleLabelFromCardRemove(cardLabel));
}
export function* addLabelToBoardFilterService(id, boardId) {
yield put(addLabelToBoardFilter(id, boardId));
}
export function* addLabelToFilterInCurrentBoardService(id) {
const { boardId } = yield select(pathSelector);
yield call(addLabelToBoardFilterService, id, boardId);
}
export function* removeLabelFromBoardFilterService(id, boardId) {
yield put(removeLabelFromBoardFilter(id, boardId));
}
export function* removeLabelFromFilterInCurrentBoardService(id) {
const { boardId } = yield select(pathSelector);
yield call(removeLabelFromBoardFilterService, id, boardId);
}

165
client/src/sagas/core/services/labels.js Normal file
View File

@@ -0,0 +1,165 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createLabel(boardId, data) {
const localId = yield call(createLocalId);
yield put(
actions.createLabel({
...data,
boardId,
id: localId,
}),
);
let label;
try {
({ item: label } = yield call(request, api.createLabel, boardId, data));
} catch (error) {
yield put(actions.createLabel.failure(localId, error));
return;
}
yield put(actions.createLabel.success(localId, label));
}
export function* createLabelInCurrentBoard(data) {
const { boardId } = yield select(selectors.selectPath);
yield call(createLabel, boardId, data);
}
export function* handleLabelCreate(label) {
yield put(actions.handleLabelCreate(label));
}
export function* updateLabel(id, data) {
yield put(actions.updateLabel(id, data));
let label;
try {
({ item: label } = yield call(request, api.updateLabel, id, data));
} catch (error) {
yield put(actions.updateLabel.failure(id, error));
return;
}
yield put(actions.updateLabel.success(label));
}
export function* handleLabelUpdate(label) {
yield put(actions.handleLabelUpdate(label));
}
export function* deleteLabel(id) {
yield put(actions.deleteLabel(id));
let label;
try {
({ item: label } = yield call(request, api.deleteLabel, id));
} catch (error) {
yield put(actions.deleteLabel.failure(id, error));
return;
}
yield put(actions.deleteLabel.success(label));
}
export function* handleLabelDelete(label) {
yield put(actions.handleLabelDelete(label));
}
export function* addLabelToCard(id, cardId) {
yield put(actions.addLabelToCard(id, cardId));
let cardLabel;
try {
({ item: cardLabel } = yield call(request, api.createCardLabel, cardId, {
labelId: id,
}));
} catch (error) {
yield put(actions.addLabelToCard.failure(id, cardId, error));
return;
}
yield put(actions.addLabelToCard.success(cardLabel));
}
export function* addLabelToCurrentCard(id) {
const { cardId } = yield select(selectors.selectPath);
yield call(addLabelToCard, id, cardId);
}
export function* handleLabelToCardAdd(cardLabel) {
yield put(actions.handleLabelToCardAdd(cardLabel));
}
export function* removeLabelFromCard(id, cardId) {
yield put(actions.removeLabelFromCard(id, cardId));
let cardLabel;
try {
({ item: cardLabel } = yield call(request, api.deleteCardLabel, cardId, id));
} catch (error) {
yield put(actions.removeLabelFromCard.failure(id, cardId, error));
return;
}
yield put(actions.removeLabelFromCard.success(cardLabel));
}
export function* removeLabelFromCurrentCard(id) {
const { cardId } = yield select(selectors.selectPath);
yield call(removeLabelFromCard, id, cardId);
}
export function* handleLabelFromCardRemove(cardLabel) {
yield put(actions.handleLabelFromCardRemove(cardLabel));
}
export function* addLabelToBoardFilter(id, boardId) {
yield put(actions.addLabelToBoardFilter(id, boardId));
}
export function* addLabelToFilterInCurrentBoard(id) {
const { boardId } = yield select(selectors.selectPath);
yield call(addLabelToBoardFilter, id, boardId);
}
export function* removeLabelFromBoardFilter(id, boardId) {
yield put(actions.removeLabelFromBoardFilter(id, boardId));
}
export function* removeLabelFromFilterInCurrentBoard(id) {
const { boardId } = yield select(selectors.selectPath);
yield call(removeLabelFromBoardFilter, id, boardId);
}
export default {
createLabel,
createLabelInCurrentBoard,
handleLabelCreate,
updateLabel,
handleLabelUpdate,
deleteLabel,
handleLabelDelete,
addLabelToCard,
addLabelToCurrentCard,
handleLabelToCardAdd,
removeLabelFromCard,
removeLabelFromCurrentCard,
handleLabelFromCardRemove,
addLabelToBoardFilter,
addLabelToFilterInCurrentBoard,
removeLabelFromBoardFilter,
removeLabelFromFilterInCurrentBoard,
};

96
client/src/sagas/core/services/list.js
View File

@@ -1,96 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import { listByIdSelector, nextListPositionSelector, pathSelector } from '../../../selectors';
import {
createList,
deleteList,
handleListCreate,
handleListDelete,
handleListUpdate,
updateList,
} from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createListService(boardId, data) {
const nextData = {
...data,
position: yield select(nextListPositionSelector, boardId),
};
const localId = yield call(createLocalId);
yield put(
createList({
...nextData,
boardId,
id: localId,
}),
);
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) {
const { boardId } = yield select(pathSelector);
yield call(createListService, boardId, data);
}
export function* handleListCreateService(label) {
yield put(handleListCreate(label));
}
export function* updateListService(id, data) {
yield put(updateList(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) {
const { boardId } = yield select(listByIdSelector, id);
const position = yield select(nextListPositionSelector, boardId, index, id);
yield call(updateListService, id, {
position,
});
}
export function* handleListUpdateService(label) {
yield put(handleListUpdate(label));
}
export function* deleteListService(id) {
yield put(deleteList(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));
}

100
client/src/sagas/core/services/lists.js Normal file
View File

@@ -0,0 +1,100 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createList(boardId, data) {
const nextData = {
...data,
position: yield select(selectors.selectNextListPosition, boardId),
};
const localId = yield call(createLocalId);
yield put(
actions.createList({
...nextData,
boardId,
id: localId,
}),
);
let list;
try {
({ item: list } = yield call(request, api.createList, boardId, nextData));
} catch (error) {
yield put(actions.createList.failure(localId, error));
return;
}
yield put(actions.createList.success(localId, list));
}
export function* createListInCurrentBoard(data) {
const { boardId } = yield select(selectors.selectPath);
yield call(createList, boardId, data);
}
export function* handleListCreate(label) {
yield put(actions.handleListCreate(label));
}
export function* updateList(id, data) {
yield put(actions.updateList(id, data));
let list;
try {
({ item: list } = yield call(request, api.updateList, id, data));
} catch (error) {
yield put(actions.updateList.failure(id, error));
return;
}
yield put(actions.updateList.success(list));
}
export function* handleListUpdate(label) {
yield put(actions.handleListUpdate(label));
}
export function* moveList(id, index) {
const { boardId } = yield select(selectors.selectListById, id);
const position = yield select(selectors.selectNextListPosition, boardId, index, id);
yield call(updateList, id, {
position,
});
}
export function* deleteList(id) {
yield put(actions.deleteList(id));
let list;
try {
({ item: list } = yield call(request, api.deleteList, id));
} catch (error) {
yield put(actions.deleteList.failure(id, error));
return;
}
yield put(actions.deleteList.success(list));
}
export function* handleListDelete(label) {
yield put(actions.handleListDelete(label));
}
export default {
createList,
createListInCurrentBoard,
handleListCreate,
updateList,
handleListUpdate,
moveList,
deleteList,
handleListDelete,
};

9
client/src/sagas/core/services/login.js
View File

@@ -1,9 +0,0 @@
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();
}

11
client/src/sagas/core/services/modal.js
View File

@@ -1,11 +0,0 @@
import { put } from 'redux-saga/effects';
import { closeModal, openModal } from '../../../actions';
export function* openModalService(type) {
yield put(openModal(type));
}
export function* closeModalService() {
yield put(closeModal());
}

16
client/src/sagas/core/services/modals.js Normal file
View File

@@ -0,0 +1,16 @@
import { put } from 'redux-saga/effects';
import actions from '../../../actions';
export function* openModal(type) {
yield put(actions.openModal(type));
}
export function* closeModal() {
yield put(actions.closeModal());
}
export default {
openModal,
closeModal,
};

36
client/src/sagas/core/services/notification.js → client/src/sagas/core/services/notifications.js
View File

@@ -1,16 +1,12 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import { pathSelector } from '../../../selectors';
import {
deleteNotification,
handleNotificationCreate,
handleNotificationDelete,
} from '../../../actions';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
export function* handleNotificationCreateService(notification) {
const { cardId } = yield select(pathSelector);
export function* handleNotificationCreate(notification) {
const { cardId } = yield select(selectors.selectPath);
if (notification.cardId === cardId) {
try {
@@ -21,22 +17,22 @@ export function* handleNotificationCreateService(notification) {
} else {
let users;
let cards;
let actions;
let activities;
try {
({
included: { users, cards, actions },
included: { users, cards, activities },
} = yield call(request, api.getNotification, notification.id));
} catch {
return;
}
yield put(handleNotificationCreate(notification, users, cards, actions));
yield put(actions.handleNotificationCreate(notification, users, cards, activities));
}
}
export function* deleteNotificationService(id) {
yield put(deleteNotification(id));
export function* deleteNotification(id) {
yield put(actions.deleteNotification(id));
let notifications;
try {
@@ -44,13 +40,19 @@ export function* deleteNotificationService(id) {
isRead: true,
}));
} catch (error) {
yield put(deleteNotification.failure(id, error));
yield put(actions.deleteNotification.failure(id, error));
return;
}
yield put(deleteNotification.success(notifications[0]));
yield put(actions.deleteNotification.success(notifications[0]));
}
export function* handleNotificationDeleteService(notification) {
yield put(handleNotificationDelete(notification));
export function* handleNotificationDelete(notification) {
yield put(actions.handleNotificationDelete(notification));
}
export default {
handleNotificationCreate,
deleteNotification,
handleNotificationDelete,
};

82
client/src/sagas/core/services/project-manager.js → client/src/sagas/core/services/project-managers.js
View File

@@ -1,28 +1,18 @@
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 requests from '../requests';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
import mergeRecords from '../../../utils/merge-records';
export function* createProjectManagerService(projectId, data) {
export function* createProjectManager(projectId, data) {
const localId = yield call(createLocalId);
yield put(
createProjectManager({
actions.createProjectManager({
...data,
projectId,
id: localId,
@@ -33,20 +23,20 @@ export function* createProjectManagerService(projectId, data) {
try {
({ item: projectManager } = yield call(request, api.createProjectManager, projectId, data));
} catch (error) {
yield put(createProjectManager.failure(localId, error));
yield put(actions.createProjectManager.failure(localId, error));
}
yield put(createProjectManager.success(localId, projectManager));
yield put(actions.createProjectManager.success(localId, projectManager));
}
export function* createManagerInCurrentProjectService(data) {
const { projectId } = yield select(pathSelector);
export function* createManagerInCurrentProject(data) {
const { projectId } = yield select(selectors.selectPath);
yield call(createProjectManagerService, projectId, data);
yield call(createProjectManager, projectId, data);
}
export function* handleProjectManagerCreateService(projectManager) {
const currentUserId = yield select(currentUserIdSelector);
export function* handleProjectManagerCreate(projectManager) {
const currentUserId = yield select(selectors.selectCurrentUserId);
const isCurrentUser = projectManager.userId === currentUserId;
let user;
@@ -65,13 +55,17 @@ export function* handleProjectManagerCreateService(projectManager) {
let cardLabels;
let tasks;
let attachments;
let notifications;
let deletedNotifications;
if (isCurrentUser) {
const { boardId } = yield select(pathSelector);
const { boardId } = yield select(selectors.selectPath);
yield put(
handleProjectManagerCreate.fetchProject(projectManager.projectId, currentUserId, boardId),
actions.handleProjectManagerCreate.fetchProject(
projectManager.projectId,
currentUserId,
boardId,
),
);
try {
@@ -85,7 +79,7 @@ export function* handleProjectManagerCreateService(projectManager) {
let body;
try {
body = yield call(fetchBoardByCurrentPathRequest);
body = yield call(requests.fetchBoardByCurrentPath);
} catch {} // eslint-disable-line no-empty
if (body && body.project && body.project.id === projectManager.projectId) {
@@ -104,7 +98,7 @@ export function* handleProjectManagerCreateService(projectManager) {
} = body);
if (body.card) {
notifications = yield select(notificationsByCardIdSelector, body.card.id);
deletedNotifications = yield select(selectors.selectNotificationsByCardId, body.card.id);
}
}
} else {
@@ -116,7 +110,7 @@ export function* handleProjectManagerCreateService(projectManager) {
}
yield put(
handleProjectManagerCreate(
actions.handleProjectManagerCreate(
projectManager,
project,
board,
@@ -131,19 +125,19 @@ export function* handleProjectManagerCreateService(projectManager) {
cardLabels,
tasks,
attachments,
notifications,
deletedNotifications,
),
);
}
export function* deleteProjectManagerService(id) {
let projectManager = yield select(projectManagerByIdSelector, id);
export function* deleteProjectManager(id) {
let projectManager = yield select(selectors.selectProjectManagerById, id);
const currentUserId = yield select(currentUserIdSelector);
const { projectId } = yield select(pathSelector);
const currentUserId = yield select(selectors.selectCurrentUserId);
const { projectId } = yield select(selectors.selectPath);
yield put(
deleteProjectManager(
actions.deleteProjectManager(
id,
projectManager.userId === currentUserId,
projectManager.projectId === projectId,
@@ -153,22 +147,30 @@ export function* deleteProjectManagerService(id) {
try {
({ item: projectManager } = yield call(request, api.deleteProjectManager, id));
} catch (error) {
yield put(deleteProjectManager.failure(id, error));
yield put(actions.deleteProjectManager.failure(id, error));
return;
}
yield put(deleteProjectManager.success(projectManager));
yield put(actions.deleteProjectManager.success(projectManager));
}
export function* handleProjectManagerDeleteService(projectManager) {
const currentUserId = yield select(currentUserIdSelector);
const { projectId } = yield select(pathSelector);
export function* handleProjectManagerDelete(projectManager) {
const currentUserId = yield select(selectors.selectCurrentUserId);
const { projectId } = yield select(selectors.selectPath);
yield put(
handleProjectManagerDelete(
actions.handleProjectManagerDelete(
projectManager,
projectManager.userId === currentUserId,
projectManager.projectId === projectId,
),
);
}
export default {
createProjectManager,
createManagerInCurrentProject,
handleProjectManagerCreate,
deleteProjectManager,
handleProjectManagerDelete,
};

131
client/src/sagas/core/services/project.js
View File

@@ -1,131 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
import { goToProjectService, goToRootService } from './router';
import request from '../request';
import { pathSelector } from '../../../selectors';
import {
createProject,
deleteProject,
handleProjectCreate,
handleProjectDelete,
handleProjectUpdate,
updateProject,
updateProjectBackgroundImage,
} from '../../../actions';
import api from '../../../api';
export function* createProjectService(data) {
yield put(createProject(data));
let project;
let projectManagers;
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));
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) {
const { projectId } = yield select(pathSelector);
yield call(updateProjectService, projectId, data);
}
export function* handleProjectUpdateService(project) {
yield put(handleProjectUpdate(project));
}
export function* updateProjectBackgroundImageService(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) {
const { projectId } = yield select(pathSelector);
yield call(updateProjectBackgroundImageService, projectId, data);
}
export function* deleteProjectService(id) {
const { projectId } = yield select(pathSelector);
if (id === projectId) {
yield call(goToRootService);
}
yield put(deleteProject(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() {
const { projectId } = yield select(pathSelector);
yield call(deleteProjectService, projectId);
}
export function* handleProjectDeleteService(project) {
const { projectId } = yield select(pathSelector);
if (project.id === projectId) {
yield call(goToRootService);
}
yield put(handleProjectDelete(project));
}

136
client/src/sagas/core/services/projects.js Normal file
View File

@@ -0,0 +1,136 @@
import { call, put, select } from 'redux-saga/effects';
import { goToProject, goToRoot } from './router';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
export function* createProject(data) {
yield put(actions.createProject(data));
let project;
let projectManagers;
try {
({
item: project,
included: { projectManagers },
} = yield call(request, api.createProject, data));
} catch (error) {
yield put(actions.createProject.failure(error));
return;
}
yield put(actions.createProject.success(project, projectManagers));
yield call(goToProject, project.id);
}
export function* handleProjectCreate({ 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(actions.handleProjectCreate(project, users, projectManagers, boards, boardMemberships));
}
export function* updateProject(id, data) {
yield put(actions.updateProject(id, data));
let project;
try {
({ item: project } = yield call(request, api.updateProject, id, data));
} catch (error) {
yield put(actions.updateProject.failure(id, error));
}
yield put(actions.updateProject.success(project));
}
export function* updateCurrentProject(data) {
const { projectId } = yield select(selectors.selectPath);
yield call(updateProject, projectId, data);
}
export function* handleProjectUpdate(project) {
yield put(actions.handleProjectUpdate(project));
}
export function* updateProjectBackgroundImage(id, data) {
yield put(actions.updateProjectBackgroundImage(id));
let project;
try {
({ item: project } = yield call(request, api.updateProjectBackgroundImage, id, data));
} catch (error) {
yield put(actions.updateProjectBackgroundImage.failure(id, error));
}
yield put(actions.updateProjectBackgroundImage.success(project));
}
export function* updateCurrentProjectBackgroundImage(data) {
const { projectId } = yield select(selectors.selectPath);
yield call(updateProjectBackgroundImage, projectId, data);
}
export function* deleteProject(id) {
const { projectId } = yield select(selectors.selectPath);
if (id === projectId) {
yield call(goToRoot);
}
yield put(actions.deleteProject(id));
let project;
try {
({ item: project } = yield call(request, api.deleteProject, id));
} catch (error) {
yield put(actions.deleteProject.failure(id, error));
}
yield put(actions.deleteProject.success(project));
}
export function* deleteCurrentProject() {
const { projectId } = yield select(selectors.selectPath);
yield call(deleteProject, projectId);
}
export function* handleProjectDelete(project) {
const { projectId } = yield select(selectors.selectPath);
if (project.id === projectId) {
yield call(goToRoot);
}
yield put(actions.handleProjectDelete(project));
}
export default {
createProject,
handleProjectCreate,
updateProject,
updateCurrentProject,
handleProjectUpdate,
updateProjectBackgroundImage,
updateCurrentProjectBackgroundImage,
deleteProject,
deleteCurrentProject,
handleProjectDelete,
};

47
client/src/sagas/core/services/router.js
View File

@@ -2,35 +2,30 @@ import { call, put, select, take } from 'redux-saga/effects';
import { push } from 'connected-react-router';
import request from '../request';
import {
currentBoardSelector,
isCoreInitializingSelector,
notificationIdsForCurrentCardSelector,
pathsMatchSelector,
} from '../../../selectors';
import { handleLocationChange } from '../../../actions';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import ActionTypes from '../../../constants/ActionTypes';
import Paths from '../../../constants/Paths';
export function* goToRootService() {
export function* goToRoot() {
yield put(push(Paths.ROOT));
}
export function* goToProjectService(projectId) {
export function* goToProject(projectId) {
yield put(push(Paths.PROJECTS.replace(':id', projectId)));
}
export function* goToBoardService(boardId) {
export function* goToBoard(boardId) {
yield put(push(Paths.BOARDS.replace(':id', boardId)));
}
export function* goToCardService(cardId) {
export function* goToCard(cardId) {
yield put(push(Paths.CARDS.replace(':id', cardId)));
}
export function* handleLocationChangeService() {
const pathsMatch = yield select(pathsMatchSelector);
export function* handleLocationChange() {
const pathsMatch = yield select(selectors.selectPathsMatch);
if (!pathsMatch) {
return;
@@ -38,13 +33,13 @@ export function* handleLocationChangeService() {
switch (pathsMatch.path) {
case Paths.LOGIN:
yield call(goToRootService);
yield call(goToRoot);
break;
default:
}
const isCoreInitializing = yield select(isCoreInitializingSelector);
const isCoreInitializing = yield select(selectors.selectIsCoreInitializing);
if (isCoreInitializing) {
yield take(ActionTypes.CORE_INITIALIZE);
@@ -61,15 +56,15 @@ export function* handleLocationChangeService() {
let cardLabels;
let tasks;
let attachments;
let notifications;
let deletedNotifications;
switch (pathsMatch.path) {
case Paths.BOARDS:
case Paths.CARDS: {
const currentBoard = yield select(currentBoardSelector);
const currentBoard = yield select(selectors.selectCurrentBoard);
if (currentBoard && currentBoard.isFetching === null) {
yield put(handleLocationChange.fetchBoard(currentBoard.id));
yield put(actions.handleLocationChange.fetchBoard(currentBoard.id));
try {
({
@@ -91,11 +86,11 @@ export function* handleLocationChangeService() {
}
if (pathsMatch.path === Paths.CARDS) {
const notificationIds = yield select(notificationIdsForCurrentCardSelector);
const notificationIds = yield select(selectors.selectNotificationIdsForCurrentCard);
if (notificationIds && notificationIds.length > 0) {
try {
({ items: notifications } = yield call(
({ items: deletedNotifications } = yield call(
request,
api.updateNotifications,
notificationIds,
@@ -113,7 +108,7 @@ export function* handleLocationChangeService() {
}
yield put(
handleLocationChange(
actions.handleLocationChange(
board,
users,
projects,
@@ -125,7 +120,15 @@ export function* handleLocationChangeService() {
cardLabels,
tasks,
attachments,
notifications,
deletedNotifications,
),
);
}
export default {
goToRoot,
goToProject,
goToBoard,
goToCard,
handleLocationChange,
};

31
client/src/sagas/core/services/socket.js
View File

@@ -1,18 +1,18 @@
import { call, put, select } from 'redux-saga/effects';
import { fetchCoreRequest } from '../requests';
import { currentUserIdSelector, pathSelector } from '../../../selectors';
import { handleSocketDisconnect, handleSocketReconnect } from '../../../actions';
import requests from '../requests';
import selectors from '../../../selectors';
import actions from '../../../actions';
export function* handleSocketDisconnectService() {
yield put(handleSocketDisconnect());
export function* handleSocketDisconnect() {
yield put(actions.handleSocketDisconnect());
}
export function* handleSocketReconnectService() {
const currentUserId = yield select(currentUserIdSelector);
const { boardId } = yield select(pathSelector);
export function* handleSocketReconnect() {
const currentUserId = yield select(selectors.selectCurrentUserId);
const { boardId } = yield select(selectors.selectPath);
yield put(handleSocketReconnect.fetchCore(currentUserId, boardId));
yield put(actions.handleSocketReconnect.fetchCore(currentUserId, boardId));
const {
user,
@@ -29,12 +29,12 @@ export function* handleSocketReconnectService() {
cardLabels,
tasks,
attachments,
actions,
activities,
notifications,
} = yield call(fetchCoreRequest); // TODO: handle error
} = yield call(requests.fetchCore); // TODO: handle error
yield put(
handleSocketReconnect(
actions.handleSocketReconnect(
user,
board,
users,
@@ -49,8 +49,13 @@ export function* handleSocketReconnectService() {
cardLabels,
tasks,
attachments,
actions,
activities,
notifications,
),
);
}
export default {
handleSocketDisconnect,
handleSocketReconnect,
};

96
client/src/sagas/core/services/task.js
View File

@@ -1,96 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import { nextTaskPositionSelector, pathSelector, taskByIdSelector } from '../../../selectors';
import {
createTask,
deleteTask,
handleTaskCreate,
handleTaskDelete,
handleTaskUpdate,
updateTask,
} from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createTaskService(cardId, data) {
const nextData = {
...data,
position: yield select(nextTaskPositionSelector, cardId),
};
const localId = yield call(createLocalId);
yield put(
createTask({
...nextData,
cardId,
id: localId,
}),
);
let task;
try {
({ item: task } = yield call(request, api.createTask, cardId, nextData));
} catch (error) {
yield put(createTask.failure(localId, error));
return;
}
yield put(createTask.success(localId, task));
}
export function* createTaskInCurrentCardService(data) {
const { cardId } = yield select(pathSelector);
yield call(createTaskService, cardId, data);
}
export function* handleTaskCreateService(task) {
yield put(handleTaskCreate(task));
}
export function* updateTaskService(id, data) {
yield put(updateTask(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* moveTaskService(id, index) {
const { cardId } = yield select(taskByIdSelector, id);
const position = yield select(nextTaskPositionSelector, cardId, index, id);
yield call(updateTaskService, id, {
position,
});
}
export function* deleteTaskService(id) {
yield put(deleteTask(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));
}

100
client/src/sagas/core/services/tasks.js Normal file
View File

@@ -0,0 +1,100 @@
import { call, put, select } from 'redux-saga/effects';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
import { createLocalId } from '../../../utils/local-id';
export function* createTask(cardId, data) {
const nextData = {
...data,
position: yield select(selectors.selectNextTaskPosition, cardId),
};
const localId = yield call(createLocalId);
yield put(
actions.createTask({
...nextData,
cardId,
id: localId,
}),
);
let task;
try {
({ item: task } = yield call(request, api.createTask, cardId, nextData));
} catch (error) {
yield put(actions.createTask.failure(localId, error));
return;
}
yield put(actions.createTask.success(localId, task));
}
export function* createTaskInCurrentCard(data) {
const { cardId } = yield select(selectors.selectPath);
yield call(createTask, cardId, data);
}
export function* handleTaskCreate(task) {
yield put(actions.handleTaskCreate(task));
}
export function* updateTask(id, data) {
yield put(actions.updateTask(id, data));
let task;
try {
({ item: task } = yield call(request, api.updateTask, id, data));
} catch (error) {
yield put(actions.updateTask.failure(id, error));
return;
}
yield put(actions.updateTask.success(task));
}
export function* handleTaskUpdate(task) {
yield put(actions.handleTaskUpdate(task));
}
export function* moveTask(id, index) {
const { cardId } = yield select(selectors.selectTaskById, id);
const position = yield select(selectors.selectNextTaskPosition, cardId, index, id);
yield call(updateTask, id, {
position,
});
}
export function* deleteTask(id) {
yield put(actions.deleteTask(id));
let task;
try {
({ item: task } = yield call(request, api.deleteTask, id));
} catch (error) {
yield put(actions.deleteTask.failure(id, error));
return;
}
yield put(actions.deleteTask.success(task));
}
export function* handleTaskDelete(task) {
yield put(actions.handleTaskDelete(task));
}
export default {
createTask,
createTaskInCurrentCard,
handleTaskCreate,
updateTask,
handleTaskUpdate,
moveTask,
deleteTask,
handleTaskDelete,
};

304
client/src/sagas/core/services/user.js
View File

@@ -1,304 +0,0 @@
import { call, put, select } from 'redux-saga/effects';
import { logoutService } from './login';
import { changeCoreLanguageService } from './core';
import request from '../request';
import { currentUserIdSelector, currentUserSelector, pathSelector } from '../../../selectors';
import {
addUserToBoardFilter,
addUserToCard,
clearUserCreateError,
clearUserEmailUpdateError,
clearUserPasswordUpdateError,
clearUserUsernameUpdateError,
createUser,
deleteUser,
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));
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() {
yield put(clearUserCreateError());
}
export function* updateUserService(id, data) {
yield put(updateUser(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) {
const id = yield select(currentUserIdSelector);
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));
}
// TODO: add loading state
export function* updateUserLanguageService(id, language) {
yield call(changeCoreLanguageService, language);
yield call(updateUserService, id, {
language,
});
}
export function* updateCurrentUserLanguageService(language) {
const id = yield select(currentUserIdSelector);
yield call(updateUserLanguageService, id, language);
}
export function* updateUserEmailService(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) {
const id = yield select(currentUserIdSelector);
yield call(updateUserEmailService, id, data);
}
export function* clearUserEmailUpdateErrorService(id) {
yield put(clearUserEmailUpdateError(id));
}
export function* clearCurrentUserEmailUpdateErrorService() {
const id = yield select(currentUserIdSelector);
yield call(clearUserEmailUpdateErrorService, id);
}
export function* updateUserPasswordService(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) {
const id = yield select(currentUserIdSelector);
yield call(updateUserPasswordService, id, data);
}
export function* clearUserPasswordUpdateErrorService(id) {
yield put(clearUserPasswordUpdateError(id));
}
export function* clearCurrentUserPasswordUpdateErrorService() {
const id = yield select(currentUserIdSelector);
yield call(clearUserPasswordUpdateErrorService, id);
}
export function* updateUserUsernameService(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) {
const id = yield select(currentUserIdSelector);
yield call(updateUserUsernameService, id, data);
}
export function* clearUserUsernameUpdateErrorService(id) {
yield put(clearUserUsernameUpdateError(id));
}
export function* clearCurrentUserUsernameUpdateErrorService() {
const id = yield select(currentUserIdSelector);
yield call(clearUserUsernameUpdateErrorService, id);
}
export function* updateUserAvatarService(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) {
const id = yield select(currentUserIdSelector);
yield call(updateUserAvatarService, id, data);
}
export function* deleteUserService(id) {
yield put(deleteUser(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));
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) {
const { cardId } = yield select(pathSelector);
yield call(addUserToCardService, id, cardId);
}
export function* handleUserToCardAddService(cardMembership) {
yield put(handleUserToCardAdd(cardMembership));
}
export function* removeUserFromCardService(id, cardId) {
yield put(removeUserFromCard(id, cardId));
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) {
const { cardId } = yield select(pathSelector);
yield call(removeUserFromCardService, id, cardId);
}
export function* handleUserFromCardRemoveService(cardMembership) {
yield put(handleUserFromCardRemove(cardMembership));
}
export function* addUserToBoardFilterService(id, boardId) {
yield put(addUserToBoardFilter(id, boardId));
}
export function* addUserToFilterInCurrentBoardService(id) {
const { boardId } = yield select(pathSelector);
yield call(addUserToBoardFilterService, id, boardId);
}
export function* removeUserFromBoardFilterService(id, boardId) {
yield put(removeUserFromBoardFilter(id, boardId));
}
export function* removeUserFromFilterInCurrentBoardService(id) {
const { boardId } = yield select(pathSelector);
yield call(removeUserFromBoardFilterService, id, boardId);
}

319
client/src/sagas/core/services/users.js Normal file
View File

@@ -0,0 +1,319 @@
import { call, put, select } from 'redux-saga/effects';
import { changeCoreLanguage, logout } from './core';
import request from '../request';
import selectors from '../../../selectors';
import actions from '../../../actions';
import api from '../../../api';
export function* createUser(data) {
yield put(actions.createUser(data));
let user;
try {
({ item: user } = yield call(request, api.createUser, data));
} catch (error) {
yield put(actions.createUser.failure(error));
return;
}
yield put(actions.createUser.success(user));
}
export function* handleUserCreate(user) {
yield put(actions.handleUserCreate(user));
}
export function* clearUserCreateError() {
yield put(actions.clearUserCreateError());
}
export function* updateUser(id, data) {
yield put(actions.updateUser(id, data));
let user;
try {
({ item: user } = yield call(request, api.updateUser, id, data));
} catch (error) {
yield put(actions.updateUser.failure(id, error));
return;
}
yield put(actions.updateUser.success(user));
}
export function* updateCurrentUser(data) {
const id = yield select(selectors.selectCurrentUserId);
yield call(updateUser, id, data);
}
export function* handleUserUpdate(user) {
const currentUser = yield select(selectors.selectCurrentUser);
const isCurrent = user.id === currentUser.id;
let users;
if (isCurrent && !currentUser.isAdmin && user.isAdmin) {
({ items: users } = yield call(request, api.getUsers));
}
yield put(actions.handleUserUpdate(user, users, isCurrent));
}
// TODO: add loading state
export function* updateUserLanguage(id, language) {
yield call(changeCoreLanguage, language);
yield call(updateUser, id, {
language,
});
}
export function* updateCurrentUserLanguage(language) {
const id = yield select(selectors.selectCurrentUserId);
yield call(updateUserLanguage, id, language);
}
export function* updateUserEmail(id, data) {
yield put(actions.updateUserEmail(id, data));
let user;
try {
({ item: user } = yield call(request, api.updateUserEmail, id, data));
} catch (error) {
yield put(actions.updateUserEmail.failure(id, error));
return;
}
yield put(actions.updateUserEmail.success(user));
}
export function* updateCurrentUserEmail(data) {
const id = yield select(selectors.selectCurrentUserId);
yield call(updateUserEmail, id, data);
}
export function* clearUserEmailUpdateError(id) {
yield put(actions.clearUserEmailUpdateError(id));
}
export function* clearCurrentUserEmailUpdateError() {
const id = yield select(selectors.selectCurrentUserId);
yield call(clearUserEmailUpdateError, id);
}
export function* updateUserPassword(id, data) {
yield put(actions.updateUserPassword(id, data));
let user;
try {
({ item: user } = yield call(request, api.updateUserPassword, id, data));
} catch (error) {
yield put(actions.updateUserPassword.failure(id, error));
return;
}
yield put(actions.updateUserPassword.success(user));
}
export function* updateCurrentUserPassword(data) {
const id = yield select(selectors.selectCurrentUserId);
yield call(updateUserPassword, id, data);
}
export function* clearUserPasswordUpdateError(id) {
yield put(actions.clearUserPasswordUpdateError(id));
}
export function* clearCurrentUserPasswordUpdateError() {
const id = yield select(selectors.selectCurrentUserId);
yield call(clearUserPasswordUpdateError, id);
}
export function* updateUserUsername(id, data) {
yield put(actions.updateUserUsername(id, data));
let user;
try {
({ item: user } = yield call(request, api.updateUserUsername, id, data));
} catch (error) {
yield put(actions.updateUserUsername.failure(id, error));
return;
}
yield put(actions.updateUserUsername.success(user));
}
export function* updateCurrentUserUsername(data) {
const id = yield select(selectors.selectCurrentUserId);
yield call(updateUserUsername, id, data);
}
export function* clearUserUsernameUpdateError(id) {
yield put(actions.clearUserUsernameUpdateError(id));
}
export function* clearCurrentUserUsernameUpdateError() {
const id = yield select(selectors.selectCurrentUserId);
yield call(clearUserUsernameUpdateError, id);
}
export function* updateUserAvatar(id, data) {
yield put(actions.updateUserAvatar(id));
let user;
try {
({ item: user } = yield call(request, api.updateUserAvatar, id, data));
} catch (error) {
yield put(actions.updateUserAvatar.failure(id, error));
return;
}
yield put(actions.updateUserAvatar.success(user));
}
export function* updateCurrentUserAvatar(data) {
const id = yield select(selectors.selectCurrentUserId);
yield call(updateUserAvatar, id, data);
}
export function* deleteUser(id) {
yield put(actions.deleteUser(id));
let user;
try {
({ item: user } = yield call(request, api.deleteUser, id));
} catch (error) {
yield put(actions.deleteUser.failure(id, error));
return;
}
yield put(actions.deleteUser.success(user));
}
export function* handleUserDelete(user) {
const currentUserId = yield select(selectors.selectCurrentUserId);
if (user.id === currentUserId) {
yield call(logout);
}
yield put(actions.handleUserDelete(user));
}
export function* addUserToCard(id, cardId) {
const currentUserId = yield select(selectors.selectCurrentUserId);
yield put(actions.addUserToCard(id, cardId, id === currentUserId));
let cardMembership;
try {
({ item: cardMembership } = yield call(request, api.createCardMembership, cardId, {
userId: id,
}));
} catch (error) {
yield put(actions.addUserToCard.failure(id, cardId, error));
return;
}
yield put(actions.addUserToCard.success(cardMembership));
}
export function* addUserToCurrentCard(id) {
const { cardId } = yield select(selectors.selectPath);
yield call(addUserToCard, id, cardId);
}
export function* handleUserToCardAdd(cardMembership) {
yield put(actions.handleUserToCardAdd(cardMembership));
}
export function* removeUserFromCard(id, cardId) {
yield put(actions.removeUserFromCard(id, cardId));
let cardMembership;
try {
({ item: cardMembership } = yield call(request, api.deleteCardMembership, cardId, id));
} catch (error) {
yield put(actions.removeUserFromCard.failure(id, cardId, error));
return;
}
yield put(actions.removeUserFromCard.success(cardMembership));
}
export function* removeUserFromCurrentCard(id) {
const { cardId } = yield select(selectors.selectPath);
yield call(removeUserFromCard, id, cardId);
}
export function* handleUserFromCardRemove(cardMembership) {
yield put(actions.handleUserFromCardRemove(cardMembership));
}
export function* addUserToBoardFilter(id, boardId) {
yield put(actions.addUserToBoardFilter(id, boardId));
}
export function* addUserToFilterInCurrentBoard(id) {
const { boardId } = yield select(selectors.selectPath);
yield call(addUserToBoardFilter, id, boardId);
}
export function* removeUserFromBoardFilter(id, boardId) {
yield put(actions.removeUserFromBoardFilter(id, boardId));
}
export function* removeUserFromFilterInCurrentBoard(id) {
const { boardId } = yield select(selectors.selectPath);
yield call(removeUserFromBoardFilter, id, boardId);
}
export default {
createUser,
handleUserCreate,
clearUserCreateError,
updateUser,
updateCurrentUser,
handleUserUpdate,
updateUserLanguage,
updateCurrentUserLanguage,
updateUserEmail,
updateCurrentUserEmail,
clearUserEmailUpdateError,
clearCurrentUserEmailUpdateError,
updateUserPassword,
updateCurrentUserPassword,
clearUserPasswordUpdateError,
clearCurrentUserPasswordUpdateError,
updateUserUsername,
updateCurrentUserUsername,
clearUserUsernameUpdateError,
clearCurrentUserUsernameUpdateError,
updateUserAvatar,
updateCurrentUserAvatar,
deleteUser,
handleUserDelete,
addUserToCard,
addUserToCurrentCard,
handleUserToCardAdd,
removeUserFromCard,
removeUserFromCurrentCard,
handleUserFromCardRemove,
addUserToBoardFilter,
addUserToFilterInCurrentBoard,
removeUserFromBoardFilter,
removeUserFromFilterInCurrentBoard,
};

22
client/src/sagas/core/watchers/action.js
View File

@@ -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),
),
]);
}

19
client/src/sagas/core/watchers/actions.js
View File

@@ -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),
),
]);
}

25
client/src/sagas/core/watchers/activities.js Normal file
View File

@@ -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),
),
]);
}

23
client/src/sagas/core/watchers/attachment.js → client/src/sagas/core/watchers/attachments.js
View File

@@ -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),
),
]);
}

17
client/src/sagas/core/watchers/board-membership.js → client/src/sagas/core/watchers/board-memberships.js
View File

@@ -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),
),
]);
}

29
client/src/sagas/core/watchers/board.js → client/src/sagas/core/watchers/boards.js
View File

@@ -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),
),
]);
}

41
client/src/sagas/core/watchers/card.js → client/src/sagas/core/watchers/cards.js
View File

@@ -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),
),
]);
}

22
client/src/sagas/core/watchers/comment-action.js
View File

@@ -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),
),
]);
}

18
client/src/sagas/core/watchers/comment-activities.js Normal file
View File

@@ -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),
),
]);
}

9
client/src/sagas/core/watchers/core.js
View File

@@ -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()),
]);
}

60
client/src/sagas/core/watchers/index.js
View File

@@ -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,
];

47
client/src/sagas/core/watchers/label.js → client/src/sagas/core/watchers/labels.js
View File

@@ -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),
),
]);
}

26
client/src/sagas/core/watchers/list.js → client/src/sagas/core/watchers/lists.js
View File

@@ -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),
),
]);
}

8
client/src/sagas/core/watchers/login.js
View File

@@ -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());
}

11
client/src/sagas/core/watchers/modal.js
View File

@@ -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()),
]);
}

11
client/src/sagas/core/watchers/modals.js Normal file
View File

@@ -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()),
]);
}

14
client/src/sagas/core/watchers/notification.js → client/src/sagas/core/watchers/notifications.js
View File

@@ -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),
),
]);
}

17
client/src/sagas/core/watchers/project-manager.js → client/src/sagas/core/watchers/project-managers.js
View File

@@ -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),
),
]);
}

26
client/src/sagas/core/watchers/project.js → client/src/sagas/core/watchers/projects.js
View File

@@ -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),
),
]);
}

4
client/src/sagas/core/watchers/router.js
View File

@@ -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());
}

158
client/src/sagas/core/watchers/socket.js
View File

@@ -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);

26
client/src/sagas/core/watchers/task.js → client/src/sagas/core/watchers/tasks.js
View File

@@ -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),
),
]);
}

95
client/src/sagas/core/watchers/user.js → client/src/sagas/core/watchers/users.js
View File

@@ -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),
),
]);
}

4
client/src/sagas/login/index.js
View File

@@ -1,7 +1,7 @@
import { all, call, cancel, fork, take } from 'redux-saga/effects';
import watchers from './watchers';
import { goToRootService } from './services';
import services from './services';
import { setAccessToken } from '../../utils/access-token-storage';
import ActionTypes from '../../constants/ActionTypes';
@@ -15,5 +15,5 @@ export default function* loginSaga() {
yield cancel(watcherTasks);
yield call(setAccessToken, accessToken);
yield call(goToRootService);
yield call(services.goToRoot);
}

9
client/src/sagas/login/services/index.js
View File

@@ -1,2 +1,7 @@
export * from './router';
export * from './login';
import router from './router';
import login from './login';
export default {
...router,
...login,
};

19
client/src/sagas/login/services/login.js
View File

@@ -1,22 +1,27 @@
import { call, put } from 'redux-saga/effects';
import { authenticate, clearAuthenticateError } from '../../../actions';
import actions from '../../../actions';
import api from '../../../api';
export function* authenticateService(data) {
yield put(authenticate(data));
export function* authenticate(data) {
yield put(actions.authenticate(data));
let accessToken;
try {
({ item: accessToken } = yield call(api.createAccessToken, data));
} catch (error) {
yield put(authenticate.failure(error));
yield put(actions.authenticate.failure(error));
return;
}
yield put(authenticate.success(accessToken));
yield put(actions.authenticate.success(accessToken));
}
export function* clearAuthenticateErrorService() {
yield put(clearAuthenticateError());
export function* clearAuthenticateError() {
yield put(actions.clearAuthenticateError());
}
export default {
authenticate,
clearAuthenticateError,
};

18
client/src/sagas/login/services/router.js
View File

@@ -1,19 +1,19 @@
import { call, put, select } from 'redux-saga/effects';
import { push } from 'connected-react-router';
import { pathsMatchSelector } from '../../../selectors';
import selectors from '../../../selectors';
import Paths from '../../../constants/Paths';
export function* goToLoginService() {
export function* goToLogin() {
yield put(push(Paths.LOGIN));
}
export function* goToRootService() {
export function* goToRoot() {
yield put(push(Paths.ROOT));
}
export function* handleLocationChangeService() {
const pathsMatch = yield select(pathsMatchSelector);
export function* handleLocationChange() {
const pathsMatch = yield select(selectors.selectPathsMatch);
if (!pathsMatch) {
return;
@@ -24,9 +24,15 @@ export function* handleLocationChangeService() {
case Paths.PROJECTS:
case Paths.BOARDS:
case Paths.CARDS:
yield call(goToLoginService);
yield call(goToLogin);
break;
default:
}
}
export default {
goToLogin,
goToRoot,
handleLocationChange,
};

8
client/src/sagas/login/watchers/login.js
View File

@@ -1,11 +1,13 @@
import { all, takeEvery } from 'redux-saga/effects';
import { authenticateService, clearAuthenticateErrorService } from '../services';
import services from '../services';
import EntryActionTypes from '../../../constants/EntryActionTypes';
export default function* loginWatchers() {
yield all([
takeEvery(EntryActionTypes.AUTHENTICATE, ({ payload: { data } }) => authenticateService(data)),
takeEvery(EntryActionTypes.AUTHENTICATE_ERROR_CLEAR, () => clearAuthenticateErrorService()),
takeEvery(EntryActionTypes.AUTHENTICATE, ({ payload: { data } }) =>
services.authenticate(data),
),
takeEvery(EntryActionTypes.AUTHENTICATE_ERROR_CLEAR, () => services.clearAuthenticateError()),
]);
}

4
client/src/sagas/login/watchers/router.js
View File

@@ -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());
}