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

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

Browse Source
This commit is contained in:
Maksim Eltyshev
2021-06-24 01:05:22 +05:00
parent d6cb1f6683
commit b39119ace4
478 changed files with 21226 additions and 19495 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
client/src/sagas/core/request.js Executable file
View File

@@ -0,0 +1,36 @@
import { call, fork, join, put, select, take } from 'redux-saga/effects';
import { accessTokenSelector } from '../../selectors';
import { logout } from '../../actions';
import ErrorCodes from '../../constants/ErrorCodes';
let lastRequestTask;
function* queueRequest(method, ...args) {
if (lastRequestTask) {
try {
yield join(lastRequestTask);
} catch {} // eslint-disable-line no-empty
}
const accessToken = yield select(accessTokenSelector);
try {
return yield call(method, ...args, {
Authorization: `Bearer ${accessToken}`,
});
} catch (error) {
if (error.code === ErrorCodes.UNAUTHORIZED) {
yield put(logout()); // TODO: next url
yield take();
}
throw error;
}
}
export default function* request(method, ...args) {
lastRequestTask = yield fork(queueRequest, method, ...args);
return yield join(lastRequestTask);
}

35
client/src/sagas/core/requests/actions.js
View File

@@ -1,35 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import { fetchActionsFailed, fetchActionsRequested, fetchActionsSucceeded } from '../../../actions';
import api from '../../../api';
// eslint-disable-next-line import/prefer-default-export
export function* fetchActionsRequest(cardId, beforeId) {
yield put(fetchActionsRequested(cardId));
try {
const {
items,
included: { users },
} = yield call(request, api.getActions, cardId, {
beforeId,
});
const action = fetchActionsSucceeded(cardId, items, users);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = fetchActionsFailed(cardId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

92
client/src/sagas/core/requests/attachment.js
View File

@@ -1,92 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createAttachmentFailed,
createAttachmentRequested,
createAttachmentSucceeded,
deleteAttachmentFailed,
deleteAttachmentRequested,
deleteAttachmentSucceeded,
updateAttachmentFailed,
updateAttachmentRequested,
updateAttachmentSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createAttachmentRequest(cardId, localId, data) {
yield put(
createAttachmentRequested(localId, {
...data,
cardId,
}),
);
try {
const { item } = yield call(request, api.createAttachment, cardId, data, localId);
const action = createAttachmentSucceeded(localId, item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createAttachmentFailed(localId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateAttachmentRequest(id, data) {
yield put(updateAttachmentRequested(id, data));
try {
const { item } = yield call(request, api.updateAttachment, id, data);
const action = updateAttachmentSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateAttachmentFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteAttachmentRequest(id) {
yield put(deleteAttachmentRequested(id));
try {
const { item } = yield call(request, api.deleteAttachment, id);
const action = deleteAttachmentSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteAttachmentFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

187
client/src/sagas/core/requests/board.js
View File

@@ -1,134 +1,69 @@
import { call, put } from 'redux-saga/effects';
import { call, select } from 'redux-saga/effects';
import request from './request';
import {
createBoardFailed,
createBoardRequested,
createBoardSucceeded,
deleteBoardFailed,
deleteBoardRequested,
deleteBoardSucceeded,
fetchBoardFailed,
fetchBoardRequested,
fetchBoardSucceeded,
updateBoardFailed,
updateBoardRequested,
updateBoardSucceeded,
} from '../../../actions';
import request from '../request';
import { pathsMatchSelector } from '../../../selectors';
import api from '../../../api';
import Paths from '../../../constants/Paths';
export function* createBoardRequest(projectId, localId, data) {
yield put(
createBoardRequested(localId, {
...data,
projectId,
}),
);
// eslint-disable-next-line import/prefer-default-export
export function* fetchBoardByCurrentPathRequest() {
const pathsMatch = yield select(pathsMatchSelector);
try {
const {
item,
included: { lists, labels },
} = yield call(request, api.createBoard, projectId, data);
let board;
let card;
let users;
let projects;
let boardMemberships;
let labels;
let lists;
let cards;
let cardMemberships;
let cardLabels;
let tasks;
let attachments;
const action = createBoardSucceeded(localId, item, lists, labels);
yield put(action);
if (pathsMatch) {
let boardId;
if (pathsMatch.path === Paths.BOARDS) {
boardId = pathsMatch.params.id;
} else if (pathsMatch.path === Paths.CARDS) {
({
item: card,
item: { boardId },
} = yield call(request, api.getCard, pathsMatch.params.id));
}
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createBoardFailed(localId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* fetchBoardRequest(id) {
yield put(fetchBoardRequested(id));
try {
const {
item,
included: { labels, lists, cards, cardMemberships, cardLabels, tasks, attachments },
} = yield call(request, api.getBoard, id);
const action = fetchBoardSucceeded(
item,
labels,
lists,
cards,
cardMemberships,
cardLabels,
tasks,
attachments,
);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = fetchBoardFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateBoardRequest(id, data) {
yield put(updateBoardRequested(id, data));
try {
const { item } = yield call(request, api.updateBoard, id, data);
const action = updateBoardSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateBoardFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteBoardRequest(id) {
yield put(deleteBoardRequested(id));
try {
const { item } = yield call(request, api.deleteBoard, id);
const action = deleteBoardSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteBoardFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
if (boardId) {
({
item: board,
included: {
users,
projects,
boardMemberships,
labels,
lists,
cards,
cardMemberships,
cardLabels,
tasks,
attachments,
},
} = yield call(request, api.getBoard, boardId));
}
}
return {
board,
card,
users,
boardMemberships,
labels,
lists,
cards,
cardMemberships,
cardLabels,
tasks,
attachments,
project: projects[0],
};
}

67
client/src/sagas/core/requests/card-label.js
View File

@@ -1,67 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createCardLabelFailed,
createCardLabelRequested,
createCardLabelSucceeded,
deleteCardLabelFailed,
deleteCardLabelRequested,
deleteCardLabelSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createCardLabelRequest(cardId, labelId) {
yield put(
createCardLabelRequested({
cardId,
labelId,
}),
);
try {
const { item } = yield call(request, api.createCardLabel, cardId, {
labelId,
});
const action = createCardLabelSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createCardLabelFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteCardLabelRequest(cardId, labelId) {
yield put(deleteCardLabelRequested(cardId, labelId));
try {
const { item } = yield call(request, api.deleteCardLabel, cardId, labelId);
const action = deleteCardLabelSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteCardLabelFailed(cardId, labelId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

67
client/src/sagas/core/requests/card-membership.js
View File

@@ -1,67 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createCardMembershipFailed,
createCardMembershipRequested,
createCardMembershipSucceeded,
deleteCardMembershipFailed,
deleteCardMembershipRequested,
deleteCardMembershipSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createCardMembershipRequest(cardId, userId) {
yield put(
createCardMembershipRequested({
cardId,
userId,
}),
);
try {
const { item } = yield call(request, api.createCardMembership, cardId, {
userId,
});
const action = createCardMembershipSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createCardMembershipFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteCardMembershipRequest(cardId, userId) {
yield put(deleteCardMembershipRequested(cardId, userId));
try {
const { item } = yield call(request, api.deleteCardMembership, cardId, userId);
const action = deleteCardMembershipSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteCardMembershipFailed(cardId, userId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

129
client/src/sagas/core/requests/card.js
View File

@@ -1,129 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createCardFailed,
createCardRequested,
createCardSucceeded,
deleteCardFailed,
deleteCardRequested,
deleteCardSucceeded,
fetchCardFailed,
fetchCardRequested,
fetchCardSucceeded,
updateCardFailed,
updateCardRequested,
updateCardSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createCardRequest(boardId, localId, data) {
yield put(
createCardRequested(localId, {
...data,
boardId,
}),
);
try {
const {
item,
included: { cardMemberships, cardLabels, tasks, attachments },
} = yield call(request, api.createCard, boardId, data);
const action = createCardSucceeded(
localId,
item,
cardMemberships,
cardLabels,
tasks,
attachments,
);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createCardFailed(localId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* fetchCardRequest(id) {
yield put(fetchCardRequested(id));
try {
const { item } = yield call(request, api.getCard, id);
const action = fetchCardSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = fetchCardFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateCardRequest(id, data) {
yield put(updateCardRequested(id, data));
try {
const { item } = yield call(request, api.updateCard, id, data);
const action = updateCardSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateCardFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteCardRequest(id) {
yield put(deleteCardRequested(id));
try {
const { item } = yield call(request, api.deleteCard, id);
const action = deleteCardSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteCardFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

96
client/src/sagas/core/requests/comment-action.js
View File

@@ -1,96 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createCommentActionFailed,
createCommentActionRequested,
createCommentActionSucceeded,
deleteCommentActionFailed,
deleteCommentActionRequested,
deleteCommentActionSucceeded,
updateCommentActionFailed,
updateCommentActionRequested,
updateCommentActionSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createCommentActionRequest(cardId, localId, data) {
yield put(
createCommentActionRequested(localId, {
...data,
cardId,
}),
);
try {
const { item } = yield call(request, api.createCommentAction, cardId, data);
const action = createCommentActionSucceeded(localId, item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createCommentActionFailed(localId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateCommentActionRequest(id, data) {
yield put(
updateCommentActionRequested(id, {
data,
}),
);
try {
const { item } = yield call(request, api.updateCommentAction, id, data);
const action = updateCommentActionSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateCommentActionFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteCommentActionRequest(id) {
yield put(deleteCommentActionRequested(id));
try {
const { item } = yield call(request, api.deleteCommentAction, id);
const action = deleteCommentActionSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteCommentActionFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

90
client/src/sagas/core/requests/core.js Normal file
View File

@@ -0,0 +1,90 @@
import { call } from 'redux-saga/effects';
import { fetchBoardByCurrentPathRequest } from './board';
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() {
const { item: user } = yield call(request, api.getCurrentUser);
const { items: users1 } = yield call(request, api.getUsers);
const {
items: projects1,
included: { projectManagers, boards, boardMemberships: boardMemberships1 },
} = yield call(request, api.getProjects);
let board;
let card;
let users2;
let projects2;
let boardMemberships2;
let labels;
let lists;
let cards1;
let cardMemberships;
let cardLabels;
let tasks;
let attachments;
try {
({
board,
card,
users: users2,
projects: projects2,
boardMemberships: boardMemberships2,
labels,
lists,
cards: cards1,
cardMemberships,
cardLabels,
tasks,
attachments,
} = yield call(fetchBoardByCurrentPathRequest));
} catch {} // eslint-disable-line no-empty
const body = yield call(request, api.getNotifications);
let { items: notifications } = body;
const {
included: { users: users3, cards: cards2, actions },
} = body;
if (card) {
const notificationIds = notifications.flatMap((notification) =>
notification.cardId === card.id ? [notification.id] : [],
);
if (notificationIds.length > 0) {
yield call(request, api.updateNotifications, notificationIds, {
isRead: true,
});
notifications = notifications.filter(
(notification) => !notificationIds.includes(notification.id),
);
}
}
return {
user,
board,
projectManagers,
boards,
labels,
lists,
cardMemberships,
cardLabels,
tasks,
attachments,
actions,
notifications,
users: mergeRecords(users1, users2, users3),
projects: mergeRecords(projects1, projects2),
boardMemberships: mergeRecords(boardMemberships1, boardMemberships2),
cards: mergeRecords(cards1, cards2),
};
}

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

@@ -1,16 +1,2 @@
export * from './users';
export * from './user';
export * from './projects';
export * from './project';
export * from './project-membership';
export * from './core';
export * from './board';
export * from './label';
export * from './list';
export * from './card';
export * from './card-membership';
export * from './card-label';
export * from './task';
export * from './attachment';
export * from './actions';
export * from './comment-action';
export * from './notifications';

92
client/src/sagas/core/requests/label.js
View File

@@ -1,92 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createLabelFailed,
createLabelRequested,
createLabelSucceeded,
deleteLabelFailed,
deleteLabelRequested,
deleteLabelSucceeded,
updateLabelFailed,
updateLabelRequested,
updateLabelSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createLabelRequest(boardId, localId, data) {
yield put(
createLabelRequested(localId, {
...data,
boardId,
}),
);
try {
const { item } = yield call(request, api.createLabel, boardId, data);
const action = createLabelSucceeded(localId, item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createLabelFailed(localId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateLabelRequest(id, data) {
yield put(updateLabelRequested(id, data));
try {
const { item } = yield call(request, api.updateLabel, id, data);
const action = updateLabelSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateLabelFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteLabelRequest(id) {
yield put(deleteLabelRequested(id));
try {
const { item } = yield call(request, api.deleteLabel, id);
const action = deleteLabelSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteLabelFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

92
client/src/sagas/core/requests/list.js
View File

@@ -1,92 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createListFailed,
createListRequested,
createListSucceeded,
deleteListFailed,
deleteListRequested,
deleteListSucceeded,
updateListFailed,
updateListRequested,
updateListSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createListRequest(boardId, localId, data) {
yield put(
createListRequested(localId, {
...data,
boardId,
}),
);
try {
const { item } = yield call(request, api.createList, boardId, data);
const action = createListSucceeded(localId, item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createListFailed(localId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateListRequest(id, data) {
yield put(updateListRequested(id, data));
try {
const { item } = yield call(request, api.updateList, id, data);
const action = updateListSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateListFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteListRequest(id) {
yield put(deleteListRequested(id));
try {
const { item } = yield call(request, api.deleteList, id);
const action = deleteListSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteListFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

65
client/src/sagas/core/requests/notifications.js
View File

@@ -1,65 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
deleteNotificationsFailed,
deleteNotificationsRequested,
deleteNotificationsSucceeded,
fetchNotificationsFailed,
fetchNotificationsRequested,
fetchNotificationsSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* fetchNotificationsRequest() {
yield put(fetchNotificationsRequested());
try {
const {
items,
included: { users, cards, actions },
} = yield call(request, api.getNotifications);
const action = fetchNotificationsSucceeded(items, users, cards, actions);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = fetchNotificationsFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteNotificationsRequest(ids) {
yield put(deleteNotificationsRequested(ids));
try {
const { items } = yield call(request, api.updateNotifications, ids, {
isRead: true,
});
const action = deleteNotificationsSucceeded(items);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteNotificationsFailed(ids, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

65
client/src/sagas/core/requests/project-membership.js
View File

@@ -1,65 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createProjectMembershipFailed,
createProjectMembershipRequested,
createProjectMembershipSucceeded,
deleteProjectMembershipFailed,
deleteProjectMembershipRequested,
deleteProjectMembershipSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createProjectMembershipRequest(projectId, localId, data) {
yield put(
createProjectMembershipRequested(localId, {
...data,
projectId,
}),
);
try {
const { item } = yield call(request, api.createProjectMembership, projectId, data);
const action = createProjectMembershipSucceeded(localId, item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createProjectMembershipFailed(localId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteProjectMembershipRequest(id) {
yield put(deleteProjectMembershipRequested(id));
try {
const { item } = yield call(request, api.deleteProjectMembership, id);
const action = deleteProjectMembershipSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteProjectMembershipFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

117
client/src/sagas/core/requests/project.js
View File

@@ -1,117 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createProjectFailed,
createProjectRequested,
createProjectSucceeded,
deleteProjectFailed,
deleteProjectRequested,
deleteProjectSucceeded,
updateProjectBackgroundImageFailed,
updateProjectBackgroundImageRequested,
updateProjectBackgroundImageSucceeded,
updateProjectFailed,
updateProjectRequested,
updateProjectSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createProjectRequest(data) {
yield put(createProjectRequested(data));
try {
const {
item,
included: { users, projectMemberships, boards },
} = yield call(request, api.createProject, data);
const action = createProjectSucceeded(item, users, projectMemberships, boards);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createProjectFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateProjectRequest(id, data) {
yield put(updateProjectRequested(id, data));
try {
const { item } = yield call(request, api.updateProject, id, data);
const action = updateProjectSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateProjectFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateProjectBackgroundImageRequest(id, data) {
yield put(updateProjectBackgroundImageRequested(id));
try {
const { item } = yield call(request, api.updateProjectBackgroundImage, id, data);
const action = updateProjectBackgroundImageSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateProjectBackgroundImageFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteProjectRequest(id) {
yield put(deleteProjectRequested(id));
try {
const { item } = yield call(request, api.deleteProject, id);
const action = deleteProjectSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteProjectFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

37
client/src/sagas/core/requests/projects.js
View File

@@ -1,37 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
fetchProjectsFailed,
fetchProjectsRequested,
fetchProjectsSucceeded,
} from '../../../actions';
import api from '../../../api';
// eslint-disable-next-line import/prefer-default-export
export function* fetchProjectsRequest() {
yield put(fetchProjectsRequested());
try {
const {
items,
included: { users, projectMemberships, boards },
} = yield call(request, api.getProjects);
const action = fetchProjectsSucceeded(items, users, projectMemberships, boards);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = fetchProjectsFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

22
client/src/sagas/core/requests/request.js
View File

@@ -1,22 +0,0 @@
import { call, put, select, take } from 'redux-saga/effects';
import { accessTokenSelector } from '../../../selectors';
import { logout } from '../../../actions';
import ErrorCodes from '../../../constants/ErrorCodes';
export default function* request(method, ...args) {
try {
const accessToken = yield select(accessTokenSelector);
return yield call(method, ...args, {
Authorization: `Bearer ${accessToken}`,
});
} catch (error) {
if (error.code === ErrorCodes.UNAUTHORIZED) {
yield put(logout()); // TODO: next url
yield take();
}
throw error;
}
}

92
client/src/sagas/core/requests/task.js
View File

@@ -1,92 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createTaskFailed,
createTaskRequested,
createTaskSucceeded,
deleteTaskFailed,
deleteTaskRequested,
deleteTaskSucceeded,
updateTaskFailed,
updateTaskRequested,
updateTaskSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createTaskRequest(cardId, localId, data) {
yield put(
createTaskRequested(localId, {
...data,
cardId,
}),
);
try {
const { item } = yield call(request, api.createTask, cardId, data);
const action = createTaskSucceeded(localId, item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createTaskFailed(localId, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateTaskRequest(id, data) {
yield put(updateTaskRequested(id, data));
try {
const { item } = yield call(request, api.updateTask, id, data);
const action = updateTaskSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateTaskFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteTaskRequest(id) {
yield put(deleteTaskRequested(id));
try {
const { item } = yield call(request, api.deleteTask, id);
const action = deleteTaskSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteTaskFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

222
client/src/sagas/core/requests/user.js
View File

@@ -1,222 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import {
createUserFailed,
createUserRequested,
createUserSucceeded,
deleteUserFailed,
deleteUserRequested,
deleteUserSucceeded,
fetchCurrentUserFailed,
fetchCurrentUserRequested,
fetchCurrentUserSucceeded,
updateUserAvatarFailed,
updateUserAvatarRequested,
updateUserAvatarSucceeded,
updateUserEmailFailed,
updateUserEmailRequested,
updateUserEmailSucceeded,
updateUserFailed,
updateUserPasswordFailed,
updateUserPasswordRequested,
updateUserPasswordSucceeded,
updateUserRequested,
updateUserSucceeded,
updateUserUsernameFailed,
updateUserUsernameRequested,
updateUserUsernameSucceeded,
} from '../../../actions';
import api from '../../../api';
export function* createUserRequest(data) {
yield put(createUserRequested(data));
try {
const { item } = yield call(request, api.createUser, data);
const action = createUserSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = createUserFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* fetchCurrentUserRequest() {
yield put(fetchCurrentUserRequested());
try {
const { item } = yield call(request, api.getCurrentUser);
const action = fetchCurrentUserSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = fetchCurrentUserFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateUserRequest(id, data) {
yield put(updateUserRequested(id, data));
try {
const { item } = yield call(request, api.updateUser, id, data);
const action = updateUserSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateUserFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateUserEmailRequest(id, data) {
yield put(updateUserEmailRequested(id, data));
try {
const { item } = yield call(request, api.updateUserEmail, id, data);
const action = updateUserEmailSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateUserEmailFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateUserPasswordRequest(id, data) {
yield put(updateUserPasswordRequested(id, data));
try {
const { item } = yield call(request, api.updateUserPassword, id, data);
const action = updateUserPasswordSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateUserPasswordFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateUserUsernameRequest(id, data) {
yield put(updateUserUsernameRequested(id, data));
try {
const { item } = yield call(request, api.updateUserUsername, id, data);
const action = updateUserUsernameSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateUserUsernameFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* updateUserAvatarRequest(id, data) {
yield put(updateUserAvatarRequested(id));
try {
const { item } = yield call(request, api.updateUserAvatar, id, data);
const action = updateUserAvatarSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = updateUserAvatarFailed(id, error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}
export function* deleteUserRequest(id) {
yield put(deleteUserRequested(id));
try {
const { item } = yield call(request, api.deleteUser, id);
const action = deleteUserSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = deleteUserFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

30
client/src/sagas/core/requests/users.js
View File

@@ -1,30 +0,0 @@
import { call, put } from 'redux-saga/effects';
import request from './request';
import { fetchUsersFailed, fetchUsersRequested, fetchUsersSucceeded } from '../../../actions';
import api from '../../../api';
// eslint-disable-next-line import/prefer-default-export
export function* fetchUsersRequest() {
yield put(fetchUsersRequested());
try {
const { items } = yield call(request, api.getUsers);
const action = fetchUsersSucceeded(items);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = fetchUsersFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

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

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

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

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

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

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

186
client/src/sagas/core/services/board-membership.js Normal file
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

58
client/src/sagas/core/services/notification.js
View File

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

18
client/src/sagas/core/services/notifications.js
View File

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

174
client/src/sagas/core/services/project-manager.js Normal file
View File

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

31
client/src/sagas/core/services/project-membership.js
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

20
client/src/sagas/core/watchers/attachment.js
View File

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

26
client/src/sagas/core/watchers/board-membership.js Normal file
View File

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

26
client/src/sagas/core/watchers/board.js
View File

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

32
client/src/sagas/core/watchers/card.js
View File

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

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

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

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

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

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

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

40
client/src/sagas/core/watchers/label.js
View File

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

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

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

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

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

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

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

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

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

26
client/src/sagas/core/watchers/project-manager.js Normal file
View File

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

18
client/src/sagas/core/watchers/project-membership.js
View File

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

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

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

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 { locationChangedService } from '../services';
import { handleLocationChangeService } from '../services';
export default function* routerWatchers() {
yield takeEvery(LOCATION_CHANGE, () => locationChangedService());
yield takeEvery(LOCATION_CHANGE, () => handleLocationChangeService());
}

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

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

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

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

58
client/src/sagas/core/watchers/user.js
View File

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

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

@@ -10,7 +10,7 @@ export default function* loginSaga() {
const {
payload: { accessToken },
} = yield take(ActionTypes.AUTHENTICATE_SUCCEEDED);
} = yield take(ActionTypes.AUTHENTICATE__SUCCESS);
yield cancel(watcherTasks);

1
client/src/sagas/login/requests/index.js
View File

@@ -1 +0,0 @@
export * from './login';

29
client/src/sagas/login/requests/login.js
View File

@@ -1,29 +0,0 @@
import { call, put } from 'redux-saga/effects';
import { authenticateFailed, authenticateRequested, authenticateSucceeded } from '../../../actions';
import api from '../../../api';
// eslint-disable-next-line import/prefer-default-export
export function* authenticateRequest(data) {
yield put(authenticateRequested(data));
try {
const { item } = yield call(api.createAccessToken, data);
const action = authenticateSucceeded(item);
yield put(action);
return {
success: true,
payload: action.payload,
};
} catch (error) {
const action = authenticateFailed(error);
yield put(action);
return {
success: false,
payload: action.payload,
};
}
}

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

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

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

@@ -12,7 +12,7 @@ export function* goToRootService() {
yield put(push(Paths.ROOT));
}
export function* locationChangedService() {
export function* handleLocationChangeService() {
const pathsMatch = yield select(pathsMatchSelector);
if (!pathsMatch) {

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

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

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 { locationChangedService } from '../services';
import { handleLocationChangeService } from '../services';
export default function* routerWatchers() {
yield takeEvery(LOCATION_CHANGE, () => locationChangedService());
yield takeEvery(LOCATION_CHANGE, () => handleLocationChangeService());
}