Docker/planka
Docker/planka
1
0
Fork 0
mirror of https://github.com/plankanban/planka.git synced 2025-07-18 20:59:44 +02:00
Code Issues Releases 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 7956503a46
commit fe91b5241e
478 changed files with 21226 additions and 19495 deletions
Download patch file Download diff file Expand all files Collapse all files

2
server/.env
View file

@ -1,4 +1,4 @@
TZ=UTC
BASE_URL=http://localhost:1337
DATABASE_URL=postgresql://postgres@localhost/planka
DATABASE_URL=postgresql://ghostly@localhost/planka
SECRET_KEY=notsecretkey

10
server/api/controllers/access-tokens/create.js
View file

@ -37,8 +37,8 @@ module.exports = {
},
},
async fn(inputs, exits) {
const user = await sails.helpers.getUserByEmailOrUsername(inputs.emailOrUsername);
async fn(inputs) {
const user = await sails.helpers.users.getOneByEmailOrUsername(inputs.emailOrUsername);
if (!user) {
throw Errors.INVALID_EMAIL_OR_USERNAME;
@ -48,8 +48,8 @@ module.exports = {
throw Errors.INVALID_PASSWORD;
}
return exits.success({
item: sails.helpers.signToken(user.id),
});
return {
item: sails.helpers.utils.signToken(user.id),
};
},
};

32
server/api/controllers/actions/index.js
View file

@ -23,32 +23,36 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { project } = await sails.helpers
.getCardToProjectPath(inputs.cardId)
const { card, project } = await sails.helpers.cards
.getProjectPath(inputs.cardId)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
if (!isUserMemberForProject) {
throw Errors.CARD_NOT_FOUND; // Forbidden
if (!isBoardMember) {
const isProjectManager = await sails.helpers.users.isProjectManager(
currentUser.id,
project.id,
);
if (!isProjectManager) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
}
const actions = await sails.helpers.getActionsForCard(inputs.cardId, inputs.beforeId);
const actions = await sails.helpers.cards.getActions(card.id, inputs.beforeId);
const userIds = sails.helpers.mapRecords(actions, 'userId', true);
const users = await sails.helpers.getUsers(userIds, true);
const userIds = sails.helpers.utils.mapRecords(actions, 'userId', true);
const users = await sails.helpers.users.getMany(userIds, true);
return exits.success({
return {
items: actions,
included: {
users,
},
});
};
},
};

59
server/api/controllers/attachments/create.js
View file

@ -29,46 +29,45 @@ module.exports = {
async fn(inputs, exits) {
const { currentUser } = this.req;
const { card, project } = await sails.helpers
.getCardToProjectPath(inputs.cardId)
const { card } = await sails.helpers.cards
.getProjectPath(inputs.cardId)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
this.req.file('file').upload(sails.helpers.createAttachmentReceiver(), async (error, files) => {
if (error) {
return exits.uploadError(error.message);
}
this.req
.file('file')
.upload(sails.helpers.utils.createAttachmentReceiver(), async (error, files) => {
if (error) {
return exits.uploadError(error.message);
}
if (files.length === 0) {
return exits.uploadError('No file was uploaded');
}
if (files.length === 0) {
return exits.uploadError('No file was uploaded');
}
const file = files[0];
const file = files[0];
const attachment = await sails.helpers.createAttachment(
card,
currentUser,
{
dirname: file.extra.dirname,
filename: file.filename,
isImage: file.extra.isImage,
name: file.extra.name,
},
inputs.requestId,
this.req,
);
const attachment = await sails.helpers.attachments.createOne(
{
dirname: file.extra.dirname,
filename: file.filename,
isImage: file.extra.isImage,
name: file.extra.name,
},
currentUser,
card,
inputs.requestId,
this.req,
);
return exits.success({
item: attachment.toJSON(),
return exits.success({
item: attachment.toJSON(),
});
});
});
},
};

23
server/api/controllers/attachments/delete.js
View file

@ -19,33 +19,30 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const attachmentToProjectPath = await sails.helpers
.getAttachmentToProjectPath(inputs.id)
const path = await sails.helpers.attachments
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.ATTACHMENT_NOT_FOUND);
let { attachment } = attachmentToProjectPath;
const { card, board, project } = attachmentToProjectPath;
let { attachment } = path;
const { card, board } = path;
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.ATTACHMENT_NOT_FOUND; // Forbidden
}
attachment = await sails.helpers.deleteAttachment(attachment, card, board, this.req);
attachment = await sails.helpers.attachments.deleteOne(attachment, board, card, this.req);
if (!attachment) {
throw Errors.ATTACHMENT_NOT_FOUND;
}
return exits.success({
return {
item: attachment,
});
};
},
};

23
server/api/controllers/attachments/update.js
View file

@ -23,34 +23,31 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const attachmentToProjectPath = await sails.helpers
.getAttachmentToProjectPath(inputs.id)
const path = await sails.helpers.attachments
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.ATTACHMENT_NOT_FOUND);
let { attachment } = attachmentToProjectPath;
const { board, project } = attachmentToProjectPath;
let { attachment } = path;
const { board } = path;
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.ATTACHMENT_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['name']);
attachment = await sails.helpers.updateAttachment(attachment, values, board, this.req);
attachment = await sails.helpers.attachments.updateOne(attachment, values, board, this.req);
if (!attachment) {
throw Errors.ATTACHMENT_NOT_FOUND;
}
return exits.success({
return {
item: attachment,
});
};
},
};

69
server/api/controllers/board-memberships/create.js Executable file
View file

@ -0,0 +1,69 @@
const Errors = {
BOARD_NOT_FOUND: {
boardNotFound: 'Board not found',
},
USER_NOT_FOUND: {
userNotFound: 'User not found',
},
USER_ALREADY_BOARD_MEMBER: {
userAlreadyBoardMember: 'User already board member',
},
};
module.exports = {
inputs: {
boardId: {
type: 'string',
regex: /^[0-9]+$/,
required: true,
},
userId: {
type: 'string',
regex: /^[0-9]+$/,
required: true,
},
},
exits: {
boardNotFound: {
responseType: 'notFound',
},
userNotFound: {
responseType: 'notFound',
},
userAlreadyBoardMember: {
responseType: 'conflict',
},
},
async fn(inputs) {
const { currentUser } = this.req;
const { board } = await sails.helpers.boards
.getProjectPath(inputs.boardId)
.intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
const isProjectManager = await sails.helpers.users.isProjectManager(
currentUser.id,
board.projectId,
);
if (!isProjectManager) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
const user = await sails.helpers.users.getOne(inputs.userId);
if (!user) {
throw Error.USER_NOT_FOUND;
}
const boardMembership = await sails.helpers.boardMemberships
.createOne(user, board, this.req)
.intercept('userAlreadyBoardMember', () => Errors.USER_ALREADY_BOARD_MEMBER);
return {
item: boardMembership,
};
},
};

57
server/api/controllers/board-memberships/delete.js Executable file
View file

@ -0,0 +1,57 @@
const Errors = {
BOARD_MEMBERSHIP_NOT_FOUND: {
boardMembershipNotFound: 'Board membership not found',
},
};
module.exports = {
inputs: {
id: {
type: 'string',
regex: /^[0-9]+$/,
required: true,
},
},
exits: {
boardMembershipNotFound: {
responseType: 'notFound',
},
},
async fn(inputs) {
const { currentUser } = this.req;
const path = await sails.helpers.boardMemberships
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.BOARD_MEMBERSHIP_NOT_FOUND);
let { boardMembership } = path;
const { project } = path;
if (boardMembership.userId !== currentUser.id) {
const isProjectManager = await sails.helpers.users.isProjectManager(
currentUser.id,
project.id,
);
if (!isProjectManager) {
throw Errors.BOARD_MEMBERSHIP_NOT_FOUND;
}
}
boardMembership = await sails.helpers.boardMemberships.deleteOne(
boardMembership,
project,
this.req,
);
if (!boardMembership) {
throw Errors.BOARD_MEMBERSHIP_NOT_FOUND;
}
return {
item: boardMembership,
};
},
};

27
server/api/controllers/boards/create.js
View file

@ -13,7 +13,7 @@ module.exports = {
},
type: {
type: 'string',
isIn: Board.TYPES,
isIn: Object.values(Board.Types),
required: true,
},
position: {
@ -32,29 +32,42 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
// TODO: allow over HTTP without subscription
if (!this.req.isSocket) {
return this.res.badRequest();
}
const { currentUser } = this.req;
const project = await Project.findOne(inputs.projectId);
if (!project) {
throw Errors.PROJECT_NOT_FOUND;
}
const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
if (!isProjectManager) {
throw Errors.PROJECT_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['type', 'position', 'name']);
const board = await sails.helpers.createBoard(project, values, this.req);
const { board, boardMembership } = await sails.helpers.boards.createOne(
values,
currentUser,
project,
this.req,
);
sails.sockets.join(this.req, `board:${board.id}`); // TODO: only when subscription needed
return exits.success({
return {
item: board,
included: {
lists: [],
labels: [],
boardMemberships: [boardMembership],
},
});
};
},
};

21
server/api/controllers/boards/delete.js
View file

@ -19,21 +19,32 @@ module.exports = {
},
},
async fn(inputs, exits) {
let board = await Board.findOne(inputs.id);
async fn(inputs) {
let { board } = await sails.helpers.boards
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
if (!board) {
throw Errors.BOARD_NOT_FOUND;
}
board = await sails.helpers.deleteBoard(board, this.req);
const isProjectManager = await sails.helpers.users.isProjectManager(
currentUser.id,
board.projectId,
);
if (!isProjectManager) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
board = await sails.helpers.boards.deleteOne(board, this.req);
if (!board) {
throw Errors.BOARD_NOT_FOUND;
}
return exits.success({
return {
item: board,
});
};
},
};

64
server/api/controllers/boards/show.js
View file

@ -19,7 +19,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
// TODO: allow over HTTP without subscription
if (!this.req.isSocket) {
return this.res.badRequest();
@ -27,35 +27,43 @@ module.exports = {
const { currentUser } = this.req;
const { board, project } = await sails.helpers
.getBoardToProjectPath(inputs.id)
const { board, project } = await sails.helpers.boards
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
if (!isBoardMember) {
const isProjectManager = await sails.helpers.users.isProjectManager(
currentUser.id,
project.id,
);
if (!isProjectManager) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
}
const labels = await sails.helpers.getLabelsForBoard(board.id);
const lists = await sails.helpers.getListsForBoard(board.id);
const boardMemberships = await sails.helpers.boards.getBoardMemberships(board.id);
const cards = await sails.helpers.getCardsForBoard(board);
const cardIds = sails.helpers.mapRecords(cards);
const userIds = sails.helpers.utils.mapRecords(boardMemberships, 'userId');
const users = await sails.helpers.users.getMany(userIds);
const cardSubscriptions = await sails.helpers.getSubscriptionsByUserForCard(
cardIds,
currentUser.id,
);
const labels = await sails.helpers.boards.getLabels(board.id);
const lists = await sails.helpers.boards.getLists(board.id);
const cardMemberships = await sails.helpers.getMembershipsForCard(cardIds);
const cardLabels = await sails.helpers.getCardLabelsForCard(cardIds);
const cards = await sails.helpers.boards.getCards(board);
const cardIds = sails.helpers.utils.mapRecords(cards);
const tasks = await sails.helpers.getTasksForCard(cardIds);
const attachments = await sails.helpers.getAttachmentsForCard(cardIds);
const cardSubscriptions = await sails.helpers.cardSubscriptions.getMany({
cardId: cardIds,
userId: currentUser.id,
});
const cardMemberships = await sails.helpers.cards.getCardMemberships(cardIds);
const cardLabels = await sails.helpers.cards.getCardLabels(cardIds);
const tasks = await sails.helpers.cards.getTasks(cardIds);
const attachments = await sails.helpers.cards.getAttachments(cardIds);
const isSubscribedByCardId = cardSubscriptions.reduce(
(result, cardSubscription) => ({
@ -65,16 +73,17 @@ module.exports = {
{},
);
cards.map((card) => ({
...card,
isSubscribed: isSubscribedByCardId[card.id] || false,
}));
cards.forEach((card) => {
card.isSubscribed = isSubscribedByCardId[card.id] || false; // eslint-disable-line no-param-reassign
});
sails.sockets.join(this.req, `board:${board.id}`); // TODO: only when subscription needed
return exits.success({
return {
item: board,
included: {
users,
boardMemberships,
labels,
lists,
cards,
@ -82,7 +91,8 @@ module.exports = {
cardLabels,
tasks,
attachments,
projects: [project],
},
});
};
},
};

23
server/api/controllers/boards/update.js
View file

@ -26,22 +26,35 @@ module.exports = {
},
},
async fn(inputs, exits) {
let board = await Board.findOne(inputs.id);
async fn(inputs) {
const { currentUser } = this.req;
let { board } = await sails.helpers.boards
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
if (!board) {
throw Errors.BOARD_NOT_FOUND;
}
const isProjectManager = await sails.helpers.users.isProjectManager(
currentUser.id,
board.projectId,
);
if (!isProjectManager) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['position', 'name']);
board = await sails.helpers.updateBoard(board, values, this.req);
board = await sails.helpers.boards.updateOne(board, values, this.req);
if (!board) {
throw Errors.BOARD_NOT_FOUND;
}
return exits.success({
return {
item: board,
});
};
},
};

21
server/api/controllers/card-labels/create.js
View file

@ -36,19 +36,16 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { card, project } = await sails.helpers
.getCardToProjectPath(inputs.cardId)
const { card } = await sails.helpers.cards
.getProjectPath(inputs.cardId)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
@ -61,12 +58,12 @@ module.exports = {
throw Errors.LABEL_NOT_FOUND;
}
const cardLabel = await sails.helpers
.createCardLabel(card, label, this.req)
const cardLabel = await sails.helpers.cardLabels
.createOne(label, card, this.req)
.intercept('labelAlreadyInCard', () => Errors.LABEL_ALREADY_IN_CARD);
return exits.success({
return {
item: cardLabel,
});
};
},
};

19
server/api/controllers/card-labels/delete.js
View file

@ -30,19 +30,16 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { board, project } = await sails.helpers
.getCardToProjectPath(inputs.cardId)
const { board } = await sails.helpers.cards
.getProjectPath(inputs.cardId)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
@ -55,14 +52,14 @@ module.exports = {
throw Errors.LABEL_NOT_IN_CARD;
}
cardLabel = await sails.helpers.deleteCardLabel(cardLabel, board, this.req);
cardLabel = await sails.helpers.cardLabels.deleteOne(cardLabel, board, this.req);
if (!cardLabel) {
throw Errors.LABEL_NOT_IN_CARD;
}
return exits.success({
return {
item: cardLabel,
});
};
},
};

25
server/api/controllers/card-memberships/create.js
View file

@ -36,34 +36,31 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { card, project } = await sails.helpers
.getCardToProjectPath(inputs.cardId)
const { card } = await sails.helpers.cards
.getProjectPath(inputs.cardId)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
let isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
let isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
isUserMemberForProject = await sails.helpers.isUserMemberForProject(project.id, inputs.userId);
isBoardMember = await sails.helpers.users.isBoardMember(inputs.userId, card.boardId);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.USER_NOT_FOUND;
}
const cardMembership = await sails.helpers
.createCardMembership(card, inputs.userId, this.req)
const cardMembership = await sails.helpers.cardMemberships
.createOne(inputs.userId, card, this.req)
.intercept('userAlreadyCardMember', () => Errors.USER_ALREADY_CARD_MEMBER);
return exits.success({
return {
item: cardMembership,
});
};
},
};

19
server/api/controllers/card-memberships/delete.js
View file

@ -30,19 +30,16 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { board, project } = await sails.helpers
.getCardToProjectPath(inputs.cardId)
const { board } = await sails.helpers.cards
.getProjectPath(inputs.cardId)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
@ -55,14 +52,14 @@ module.exports = {
throw Errors.USER_NOT_CARD_MEMBER;
}
cardMembership = await sails.helpers.deleteCardMembership(cardMembership, board, this.req);
cardMembership = await sails.helpers.cardMemberships.deleteOne(cardMembership, board, this.req);
if (!cardMembership) {
throw Errors.USER_NOT_CARD_MEMBER;
}
return exits.success({
return {
item: cardMembership,
});
};
},
};

29
server/api/controllers/cards/create.js
View file

@ -81,20 +81,17 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { board, project } = await sails.helpers
.getBoardToProjectPath(inputs.boardId)
const { board } = await sails.helpers.boards
.getProjectPath(inputs.boardId)
.intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
throw Errors.LIST_NOT_FOUND; // Forbidden
if (!isBoardMember) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
let list;
@ -111,19 +108,13 @@ module.exports = {
const values = _.pick(inputs, ['position', 'name', 'description', 'dueDate', 'timer']);
const card = await sails.helpers
.createCard(board, list, values, currentUser, this.req)
const card = await sails.helpers.cards
.createOne(values, currentUser, board, list, this.req)
.intercept('listMustBePresent', () => Errors.LIST_MUST_BE_PRESENT)
.intercept('positionMustBeInValues', () => Errors.POSITION_MUST_BE_PRESENT);
return exits.success({
return {
item: card,
included: {
cardMemberships: [],
cardLabels: [],
tasks: [],
attachments: [],
},
});
};
},
};

22
server/api/controllers/cards/delete.js
View file

@ -19,33 +19,27 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const cardToProjectPath = await sails.helpers
.getCardToProjectPath(inputs.id)
let { card } = await sails.helpers.cards
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
let { card } = cardToProjectPath;
const { project } = cardToProjectPath;
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
card = await sails.helpers.deleteCard(card, this.req);
card = await sails.helpers.cards.deleteOne(card, this.req);
if (!card) {
throw Errors.CARD_NOT_FOUND;
}
return exits.success({
return {
item: card,
});
};
},
};

41
server/api/controllers/cards/index.js
View file

@ -26,32 +26,23 @@ module.exports = {
async fn(inputs, exits) {
const { currentUser } = this.req;
const { board, project } = await sails.helpers
.getBoardToProjectPath(inputs.boardId)
const { board } = await sails.helpers.boards
.getProjectPath(inputs.boardId)
.intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
const cards = await sails.helpers.getCardsForBoard(board, inputs.beforeId);
const cardIds = sails.helpers.mapRecords(cards);
const cards = await sails.helpers.boards.getCards(board, inputs.beforeId);
const cardIds = sails.helpers.utils.mapRecords(cards);
const cardSubscriptions = await sails.helpers.getSubscriptionsByUserForCard(
cardIds,
currentUser.id,
);
const cardMemberships = await sails.helpers.getMembershipsForCard(cardIds);
const cardLabels = await sails.helpers.getCardLabelsForCard(cardIds);
const tasks = await sails.helpers.getTasksForCard(cardIds);
const attachments = await sails.helpers.getAttachmentsForCard(cardIds);
const cardSubscriptions = await sails.helpers.cardSubscriptions.getMany({
cardId: cardIds,
userId: currentUser.id,
});
const isSubscribedByCardId = cardSubscriptions.reduce(
(result, cardSubscription) => ({
@ -61,10 +52,14 @@ module.exports = {
{},
);
cards.map((card) => ({
...card,
isSubscribed: isSubscribedByCardId[card.id] || false,
}));
cards.forEach((card) => {
card.isSubscribed = isSubscribedByCardId[card.id] || false; // eslint-disable-line no-param-reassign
});
const cardMemberships = await sails.helpers.cards.getCardMemberships(cardIds);
const cardLabels = await sails.helpers.cards.getCardLabels(cardIds);
const tasks = await sails.helpers.cards.getTasks(cardIds);
const attachments = await sails.helpers.cards.getAttachments(cardIds);
return exits.success({
items: cards,

39
server/api/controllers/cards/show.js
View file

@ -19,24 +19,41 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { card, project } = await sails.helpers
.getCardToProjectPath(inputs.id)
const { card, project } = await sails.helpers.cards
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
if (!isUserMemberForProject) {
throw Errors.CARD_NOT_FOUND; // Forbidden
if (!isBoardMember) {
const isProjectManager = await sails.helpers.users.isProjectManager(
currentUser.id,
project.id,
);
if (!isProjectManager) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
}
return exits.success({
card.isSubscribed = await sails.helpers.users.isCardSubscriber(currentUser.id, card.id);
const cardMemberships = await sails.helpers.cards.getCardMemberships(card.id);
const cardLabels = await sails.helpers.cards.getCardLabels(card.id);
const tasks = await sails.helpers.cards.getTasks(card.id);
const attachments = await sails.helpers.cards.getAttachments(card.id);
return {
item: card,
});
included: {
cardMemberships,
cardLabels,
tasks,
attachments,
},
};
},
};

48
server/api/controllers/cards/update.js
View file

@ -100,49 +100,43 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const cardToProjectPath = await sails.helpers
.getCardToProjectPath(inputs.id)
const path = await sails.helpers.cards
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
let { card, project } = cardToProjectPath;
const { list, board } = cardToProjectPath;
let { card } = path;
const { list, board } = path;
let isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
let isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
let toBoard;
let nextBoard;
if (!_.isUndefined(inputs.boardId)) {
({ board: toBoard, project } = await sails.helpers
.getBoardToProjectPath(inputs.boardId)
({ board: nextBoard } = await sails.helpers.boards
.getProjectPath(inputs.boardId)
.intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND));
isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, nextBoard.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
}
let toList;
let nextList;
if (!_.isUndefined(inputs.listId)) {
toList = await List.findOne({
nextList = await List.findOne({
id: inputs.listId,
boardId: (toBoard || board).id,
boardId: (nextBoard || board).id,
});
if (!toList) {
if (!nextList) {
throw Errors.LIST_NOT_FOUND; // Forbidden
}
}
@ -157,17 +151,17 @@ module.exports = {
'isSubscribed',
]);
card = await sails.helpers
.updateCard(card, toBoard, toList, values, board, list, currentUser, this.req)
.intercept('toListMustBePresent', () => Errors.LIST_MUST_BE_PRESENT)
card = await sails.helpers.cards
.updateOne(card, values, nextBoard, nextList, currentUser, board, list, this.req)
.intercept('nextListMustBePresent', () => Errors.LIST_MUST_BE_PRESENT)
.intercept('positionMustBeInValues', () => Errors.POSITION_MUST_BE_PRESENT);
if (!card) {
throw Errors.CARD_NOT_FOUND;
}
return exits.success({
return {
item: card,
});
};
},
};

21
server/api/controllers/comment-actions/create.js
View file

@ -23,31 +23,28 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { card, project } = await sails.helpers
.getCardToProjectPath(inputs.cardId)
const { card } = await sails.helpers.cards
.getProjectPath(inputs.cardId)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
const values = {
type: 'commentCard',
type: Action.Types.COMMENT_CARD,
data: _.pick(inputs, ['text']),
};
const action = await sails.helpers.createAction(card, currentUser, values, this.req);
const action = await sails.helpers.actions.createOne(values, currentUser, card, this.req);
return exits.success({
return {
item: action,
});
};
},
};

45
server/api/controllers/comment-actions/delete.js
View file

@ -19,42 +19,41 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const criteria = {
id: inputs.id,
type: 'commentCard',
};
if (!currentUser.isAdmin) {
criteria.userId = currentUser.id;
}
const actionToProjectPath = await sails.helpers
.getActionToProjectPath(criteria)
const path = await sails.helpers.actions
.getProjectPath({
id: inputs.id,
type: Action.Types.COMMENT_CARD,
})
.intercept('pathNotFound', () => Errors.COMMENT_ACTION_NOT_FOUND);
let { action } = actionToProjectPath;
const { board, project } = actionToProjectPath;
let { action } = path;
const { board, project } = path;
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
if (!isUserMemberForProject) {
throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
if (!isProjectManager) {
if (action.userId !== currentUser.id) {
throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
}
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isBoardMember) {
throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
}
}
action = await sails.helpers.deleteAction(action, board, this.req);
action = await sails.helpers.actions.deleteOne(action, board, this.req);
if (!action) {
throw Errors.COMMENT_ACTION_NOT_FOUND;
}
return exits.success({
return {
item: action,
});
};
},
};

36
server/api/controllers/comment-actions/update.js
View file

@ -23,41 +23,45 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const actionToProjectPath = await sails.helpers
.getActionToProjectPath({
const path = await sails.helpers.actions
.getProjectPath({
id: inputs.id,
type: 'commentCard',
userId: currentUser.id,
type: Action.Types.COMMENT_CARD,
})
.intercept('pathNotFound', () => Errors.COMMENT_ACTION_NOT_FOUND);
let { action } = actionToProjectPath;
const { board, project } = actionToProjectPath;
let { action } = path;
const { board, project } = path;
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
if (!isUserMemberForProject) {
throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
if (!isProjectManager) {
if (action.userId !== currentUser.id) {
throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
}
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isBoardMember) {
throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
}
}
const values = {
data: _.pick(inputs, ['text']),
};
action = await sails.helpers.updateAction(action, values, board, this.req);
action = await sails.helpers.actions.updateOne(action, values, board, this.req);
if (!action) {
throw Errors.COMMENT_ACTION_NOT_FOUND;
}
return exits.success({
return {
item: action,
});
};
},
};

19
server/api/controllers/labels/create.js
View file

@ -29,27 +29,24 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { board, project } = await sails.helpers
.getBoardToProjectPath(inputs.boardId)
const { board } = await sails.helpers.boards
.getProjectPath(inputs.boardId)
.intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['name', 'color']);
const label = await sails.helpers.createLabel(board, values, this.req);
const label = await sails.helpers.labels.createOne(values, board, this.req);
return exits.success({
return {
item: label,
});
};
},
};

22
server/api/controllers/labels/delete.js
View file

@ -19,33 +19,27 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const labelToProjectPath = await sails.helpers
.getLabelToProjectPath(inputs.id)
let { label } = await sails.helpers.labels
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.LABEL_NOT_FOUND);
let { label } = labelToProjectPath;
const { project } = labelToProjectPath;
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, label.boardId);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.LABEL_NOT_FOUND; // Forbidden
}
label = await sails.helpers.deleteLabel(label, this.req);
label = await sails.helpers.labels.deleteOne(label, this.req);
if (!label) {
throw Errors.LABEL_NOT_FOUND;
}
return exits.success({
return {
item: label,
});
};
},
};

22
server/api/controllers/labels/update.js
View file

@ -29,30 +29,24 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const labelToProjectPath = await sails.helpers
.getLabelToProjectPath(inputs.id)
let { label } = await sails.helpers.labels
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.LABEL_NOT_FOUND);
let { label } = labelToProjectPath;
const { project } = labelToProjectPath;
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, label.boardId);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.LABEL_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['name', 'color']);
label = await sails.helpers.updateLabel(label, values, this.req);
label = await sails.helpers.labels.updateOne(label, values, this.req);
return exits.success({
return {
item: label,
});
};
},
};

19
server/api/controllers/lists/create.js
View file

@ -27,27 +27,24 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { board, project } = await sails.helpers
.getBoardToProjectPath(inputs.boardId)
const { board } = await sails.helpers.boards
.getProjectPath(inputs.boardId)
.intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.BOARD_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['position', 'name']);
const list = await sails.helpers.createList(board, values, this.req);
const list = await sails.helpers.lists.createOne(values, board, this.req);
return exits.success({
return {
item: list,
});
};
},
};

22
server/api/controllers/lists/delete.js
View file

@ -19,33 +19,27 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const listToProjectPath = await sails.helpers
.getListToProjectPath(inputs.id)
let { list } = await sails.helpers.lists
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.LIST_NOT_FOUND);
let { list } = listToProjectPath;
const { project } = listToProjectPath;
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, list.boardId);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.LIST_NOT_FOUND; // Forbidden
}
list = await sails.helpers.deleteList(list, this.req);
list = await sails.helpers.lists.deleteOne(list, this.req);
if (!list) {
throw Errors.LIST_NOT_FOUND;
}
return exits.success({
return {
item: list,
});
};
},
};

22
server/api/controllers/lists/update.js
View file

@ -26,34 +26,28 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const listToProjectPath = await sails.helpers
.getListToProjectPath(inputs.id)
let { list } = await sails.helpers.lists
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.LIST_NOT_FOUND);
let { list } = listToProjectPath;
const { project } = listToProjectPath;
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, list.boardId);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.LIST_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['position', 'name']);
list = await sails.helpers.updateList(list, values, this.req);
list = await sails.helpers.lists.updateOne(list, values, this.req);
if (!list) {
throw Errors.LIST_NOT_FOUND;
}
return exits.success({
return {
item: list,
});
};
},
};

20
server/api/controllers/notifications/index.js
View file

@ -1,25 +1,25 @@
module.exports = {
async fn(inputs, exits) {
async fn() {
const { currentUser } = this.req;
const notifications = await sails.helpers.getNotificationsForUser(currentUser.id);
const notifications = await sails.helpers.users.getNotifications(currentUser.id);
const actionIds = sails.helpers.mapRecords(notifications, 'actionId');
const actions = await sails.helpers.getActions(actionIds);
const actionIds = sails.helpers.utils.mapRecords(notifications, 'actionId');
const actions = await sails.helpers.actions.getMany(actionIds);
const cardIds = sails.helpers.mapRecords(notifications, 'cardId');
const cards = await sails.helpers.getCards(cardIds);
const userIds = sails.helpers.utils.mapRecords(actions, 'userId', true);
const users = await sails.helpers.users.getMany(userIds, true);
const userIds = sails.helpers.mapRecords(actions, 'userId', true);
const users = await sails.helpers.getUsers(userIds);
const cardIds = sails.helpers.utils.mapRecords(notifications, 'cardId');
const cards = await sails.helpers.cards.getMany(cardIds);
return exits.success({
return {
items: notifications,
included: {
users,
cards,
actions,
},
});
};
},
};

48
server/api/controllers/notifications/show.js Normal file
View file

@ -0,0 +1,48 @@
const Errors = {
NOTIFICATION_NOT_FOUND: {
notificationNotFound: 'Notification not found',
},
};
module.exports = {
inputs: {
id: {
type: 'string',
regex: /^[0-9]+$/,
required: true,
},
},
exits: {
notificationNotFound: {
responseType: 'notFound',
},
},
async fn(inputs) {
const { currentUser } = this.req;
const notification = await Notification.findOne({
id: inputs.id,
isRead: false,
userId: currentUser.id,
});
if (!notification) {
throw Errors.NOTIFICATION_NOT_FOUND;
}
const action = await Action.findOne(notification.actionId);
const user = await sails.helpers.users.getOne(action.userId, true);
const card = await Card.findOne(notification.cardId);
return {
item: notification,
included: {
users: [user],
cards: [card],
actions: [action],
},
};
},
};

10
server/api/controllers/notifications/update.js
View file

@ -10,20 +10,20 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const values = _.pick(inputs, ['isRead']);
const notifications = await sails.helpers.updateNotificationsForUser(
const notifications = await sails.helpers.notifications.updateMany(
inputs.ids.split(','),
currentUser,
values,
currentUser,
this.req,
);
return exits.success({
return {
items: notifications,
});
};
},
};

33
server/api/controllers/project-memberships/create.js → server/api/controllers/project-managers/create.js
View file

@ -5,8 +5,8 @@ const Errors = {
USER_NOT_FOUND: {
userNotFound: 'User not found',
},
USER_ALREADY_PROJECT_MEMBER: {
userAlreadyProjectMember: 'User already project member',
USER_ALREADY_PROJECT_MANAGER: {
userAlreadyProjectManager: 'User already project manager',
},
};
@ -31,33 +31,38 @@ module.exports = {
userNotFound: {
responseType: 'notFound',
},
userAlreadyProjectMember: {
userAlreadyProjectManager: {
responseType: 'conflict',
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const project = await Project.findOne(inputs.projectId);
if (!project) {
throw Errors.PROJECT_NOT_FOUND;
}
const user = await sails.helpers.getUser(inputs.userId);
const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
if (!isProjectManager) {
throw Errors.PROJECT_NOT_FOUND; // Forbidden
}
const user = await sails.helpers.users.getOne(inputs.userId);
if (!user) {
throw Error.USER_NOT_FOUND;
}
const projectMembership = await sails.helpers
.createProjectMembership(project, user, this.req)
.intercept('userAlreadyProjectMember', () => Errors.USER_ALREADY_PROJECT_MEMBER);
const projectManager = await sails.helpers.projectManagers
.createOne(user, project, this.req)
.intercept('userAlreadyProjectManager', () => Errors.USER_ALREADY_PROJECT_MANAGER);
return exits.success({
item: projectMembership,
included: {
users: [user],
},
});
return {
item: projectManager,
};
},
};

51
server/api/controllers/project-managers/delete.js Executable file
View file

@ -0,0 +1,51 @@
const Errors = {
PROJECT_MANAGER_NOT_FOUND: {
projectManagerNotFound: 'Project manager not found',
},
};
module.exports = {
inputs: {
id: {
type: 'string',
regex: /^[0-9]+$/,
required: true,
},
},
exits: {
projectManagerNotFound: {
responseType: 'notFound',
},
},
async fn(inputs) {
const { currentUser } = this.req;
let projectManager = await ProjectManager.findOne(inputs.id);
if (!projectManager) {
throw Errors.PROJECT_MANAGER_NOT_FOUND;
}
const isProjectManager = await sails.helpers.users.isProjectManager(
currentUser.id,
projectManager.projectId,
);
if (!isProjectManager) {
throw Errors.PROJECT_MANAGER_NOT_FOUND; // Forbidden
}
// TODO: check if the last one
projectManager = await sails.helpers.projectManagers.deleteOne(projectManager, this.req);
if (!projectManager) {
throw Errors.PROJECT_MANAGER_NOT_FOUND;
}
return {
item: projectManager,
};
},
};

39
server/api/controllers/project-memberships/delete.js
View file

@ -1,39 +0,0 @@
const Errors = {
PROJECT_MEMBERSHIP_NOT_FOUND: {
projectMembershipNotFound: 'Project membership not found',
},
};
module.exports = {
inputs: {
id: {
type: 'string',
regex: /^[0-9]+$/,
required: true,
},
},
exits: {
projectMembershipNotFound: {
responseType: 'notFound',
},
},
async fn(inputs, exits) {
let projectMembership = await ProjectMembership.findOne(inputs.id);
if (!projectMembership) {
throw Errors.PROJECT_MEMBERSHIP_NOT_FOUND;
}
projectMembership = await sails.helpers.deleteProjectMembership(projectMembership, this.req);
if (!projectMembership) {
throw Errors.PROJECT_MEMBERSHIP_NOT_FOUND;
}
return exits.success({
item: projectMembership,
});
},
};

15
server/api/controllers/projects/create.js
View file

@ -6,25 +6,22 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const values = _.pick(inputs, ['name']);
const { project, projectMembership } = await sails.helpers.createProject(
currentUser,
const { project, projectManager } = await sails.helpers.projects.createOne(
values,
currentUser,
this.req,
true,
);
return exits.success({
return {
item: project,
included: {
users: [currentUser],
projectMemberships: [projectMembership],
boards: [],
projectManagers: [projectManager],
},
});
};
},
};

16
server/api/controllers/projects/delete.js
View file

@ -19,21 +19,29 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
let project = await Project.findOne(inputs.id);
if (!project) {
throw Errors.PROJECT_NOT_FOUND;
}
project = await sails.helpers.deleteProject(project, this.req);
const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
if (!isProjectManager) {
throw Errors.PROJECT_NOT_FOUND; // Forbidden
}
project = await sails.helpers.projects.deleteOne(project, this.req);
if (!project) {
throw Errors.PROJECT_NOT_FOUND;
}
return exits.success({
return {
item: project,
});
};
},
};

39
server/api/controllers/projects/index.js
View file

@ -1,25 +1,44 @@
module.exports = {
async fn(inputs, exits) {
async fn() {
const { currentUser } = this.req;
const projectIds = await sails.helpers.getMembershipProjectIdsForUser(currentUser.id);
const projects = await sails.helpers.getProjects(projectIds);
const managerProjectIds = await sails.helpers.users.getManagerProjectIds(currentUser.id);
const { userIds, projectMemberships } = await sails.helpers.getMembershipUserIdsForProject(
projectIds,
const boardMemberships = await sails.helpers.users.getBoardMemberships(currentUser.id);
const membershipBoardIds = await sails.helpers.utils.mapRecords(boardMemberships, 'boardId');
const membershipBoards = await sails.helpers.boards.getMany({
id: membershipBoardIds,
projectId: {
'!=': managerProjectIds,
},
});
const membershipProjectIds = sails.helpers.utils.mapRecords(
membershipBoards,
'projectId',
true,
);
const users = await sails.helpers.getUsers(userIds);
const boards = await sails.helpers.getBoardsForProject(projectIds);
const projectIds = [...managerProjectIds, ...membershipProjectIds];
const projects = await sails.helpers.projects.getMany(projectIds);
return exits.success({
const projectManagers = await sails.helpers.projects.getProjectManagers(projectIds);
const userIds = sails.helpers.utils.mapRecords(projectManagers, 'userId', true);
const users = await sails.helpers.users.getMany(userIds);
const managerBoards = await sails.helpers.projects.getBoards(managerProjectIds);
const boards = [...managerBoards, ...membershipBoards];
return {
items: projects,
included: {
users,
projectMemberships,
projectManagers,
boards,
boardMemberships,
},
});
};
},
};

65
server/api/controllers/projects/show.js Normal file
View file

@ -0,0 +1,65 @@
const Errors = {
PROJECT_NOT_FOUND: {
projectNotFound: 'Project not found',
},
};
module.exports = {
inputs: {
id: {
type: 'string',
regex: /^[0-9]+$/,
required: true,
},
},
exits: {
projectNotFound: {
responseType: 'notFound',
},
},
async fn(inputs) {
const { currentUser } = this.req;
const project = await Project.findOne(inputs.id);
if (!project) {
throw Errors.PROJECT_NOT_FOUND;
}
let boards = await sails.helpers.projects.getBoards(project.id);
let boardIds = sails.helpers.utils.mapRecords(boards);
const boardMemberships = await sails.helpers.boardMemberships.getMany({
boardId: boardIds,
userId: currentUser.id,
});
const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
if (!isProjectManager) {
if (boardMemberships.length === 0) {
throw Errors.PROJECT_NOT_FOUND; // Forbidden
}
boardIds = sails.helpers.utils.mapRecords(boardMemberships, 'boardId');
boards = boards.filter((board) => boardIds.includes(board.id));
}
const projectManagers = await sails.helpers.projects.getProjectManagers(project.id);
const userIds = sails.helpers.utils.mapRecords(projectManagers, 'userId');
const users = await sails.helpers.users.getMany(userIds);
return {
item: project,
included: {
users,
projectManagers,
boards,
boardMemberships,
},
};
},
};

12
server/api/controllers/projects/update-background-image.js
View file

@ -23,15 +23,23 @@ module.exports = {
},
async fn(inputs, exits) {
const { currentUser } = this.req;
let project = await Project.findOne(inputs.id);
if (!project) {
throw Errors.PROJECT_NOT_FOUND;
}
const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
if (!isProjectManager) {
throw Errors.PROJECT_NOT_FOUND; // Forbidden
}
this.req
.file('file')
.upload(sails.helpers.createProjectBackgroundImageReceiver(), async (error, files) => {
.upload(sails.helpers.utils.createProjectBackgroundImageReceiver(), async (error, files) => {
if (error) {
return exits.uploadError(error.message);
}
@ -40,7 +48,7 @@ module.exports = {
return exits.uploadError('No file was uploaded');
}
project = await sails.helpers.updateProject(
project = await sails.helpers.projects.updateOne(
project,
{
backgroundImageDirname: files[0].extra.dirname,

22
server/api/controllers/projects/update.js
View file

@ -26,19 +26,19 @@ module.exports = {
return false;
}
if (!Project.BACKGROUND_TYPES.includes(value.type)) {
if (!Object.values(Project.BackgroundTypes).includes(value.type)) {
return false;
}
if (
value.type === 'gradient' &&
value.type === Project.BackgroundTypes.GRADIENT &&
_.size(value) === 2 &&
Project.BACKGROUND_GRADIENTS.includes(value.name)
) {
return true;
}
if (value.type === 'image' && _.size(value) === 1) {
if (value.type === Project.BackgroundTypes.IMAGE && _.size(value) === 1) {
return true;
}
@ -57,22 +57,30 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
let project = await Project.findOne(inputs.id);
if (!project) {
throw Errors.PROJECT_NOT_FOUND;
}
const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
if (!isProjectManager) {
throw Errors.PROJECT_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['name', 'background', 'backgroundImage']);
project = await sails.helpers.updateProject(project, values, this.req);
project = await sails.helpers.projects.updateOne(project, values, this.req);
if (!project) {
throw Errors.PROJECT_NOT_FOUND;
}
return exits.success({
return {
item: project,
});
};
},
};

19
server/api/controllers/tasks/create.js
View file

@ -26,27 +26,24 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const { card, project } = await sails.helpers
.getCardToProjectPath(inputs.cardId)
const { card } = await sails.helpers.cards
.getProjectPath(inputs.cardId)
.intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.CARD_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['name', 'isCompleted']);
const task = await sails.helpers.createTask(card, values, this.req);
const task = await sails.helpers.tasks.createOne(values, card, this.req);
return exits.success({
return {
item: task,
});
};
},
};

23
server/api/controllers/tasks/delete.js
View file

@ -19,33 +19,30 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const taskToProjectPath = await sails.helpers
.getTaskToProjectPath(inputs.id)
const path = await sails.helpers.tasks
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.TASK_NOT_FOUND);
let { task } = taskToProjectPath;
const { board, project } = taskToProjectPath;
let { task } = path;
const { board } = path;
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.TASK_NOT_FOUND; // Forbidden
}
task = await sails.helpers.deleteTask(task, board, this.req);
task = await sails.helpers.tasks.deleteOne(task, board, this.req);
if (!task) {
throw Errors.TASK_NOT_FOUND;
}
return exits.success({
return {
item: task,
});
};
},
};

23
server/api/controllers/tasks/update.js
View file

@ -26,34 +26,31 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
const taskToProjectPath = await sails.helpers
.getTaskToProjectPath(inputs.id)
const path = await sails.helpers.tasks
.getProjectPath(inputs.id)
.intercept('pathNotFound', () => Errors.TASK_NOT_FOUND);
let { task } = taskToProjectPath;
const { board, project } = taskToProjectPath;
let { task } = path;
const { board } = path;
const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
project.id,
currentUser.id,
);
const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
if (!isUserMemberForProject) {
if (!isBoardMember) {
throw Errors.TASK_NOT_FOUND; // Forbidden
}
const values = _.pick(inputs, ['name', 'isCompleted']);
task = await sails.helpers.updateTask(task, values, board, this.req);
task = await sails.helpers.tasks.updateOne(task, values, board, this.req);
if (!task) {
throw Errors.TASK_NOT_FOUND;
}
return exits.success({
return {
item: task,
});
};
},
};

10
server/api/controllers/users/create.js
View file

@ -54,7 +54,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const values = _.pick(inputs, [
'email',
'password',
@ -65,13 +65,13 @@ module.exports = {
'subscribeToOwnCards',
]);
const user = await sails.helpers
.createUser(values, this.req)
const user = await sails.helpers.users
.createOne(values, this.req)
.intercept('emailAlreadyInUse', () => Errors.EMAIL_ALREADY_IN_USE)
.intercept('usernameAlreadyInUse', () => Errors.USERNAME_ALREADY_IN_USE);
return exits.success({
return {
item: user,
});
};
},
};

10
server/api/controllers/users/delete.js
View file

@ -19,21 +19,21 @@ module.exports = {
},
},
async fn(inputs, exits) {
let user = await sails.helpers.getUser(inputs.id);
async fn(inputs) {
let user = await sails.helpers.users.getOne(inputs.id);
if (!user) {
throw Errors.USER_NOT_FOUND;
}
user = await sails.helpers.deleteUser(user, this.req);
user = await sails.helpers.users.deleteOne(user, this.req);
if (!user) {
throw Errors.USER_NOT_FOUND;
}
return exits.success({
return {
item: user,
});
};
},
};

8
server/api/controllers/users/index.js
View file

@ -1,9 +1,9 @@
module.exports = {
async fn(inputs, exits) {
const users = await sails.helpers.getUsers();
async fn() {
const users = await sails.helpers.users.getMany();
return exits.success({
return {
items: users,
});
};
},
};

56
server/api/controllers/users/show.js
View file

@ -1,16 +1,44 @@
module.exports = {
async fn(inputs, exits) {
// TODO: allow over HTTP without subscription
if (!this.req.isSocket) {
return this.res.badRequest();
}
const { currentUser } = this.req;
sails.sockets.join(this.req, `user:${currentUser.id}`); // TODO: only when subscription needed
return exits.success({
item: currentUser,
});
const Errors = {
USER_NOT_FOUND: {
userNotFound: 'User not found',
},
};
const CURRENT_USER_ID = 'me';
module.exports = {
inputs: {
id: {
type: 'string',
regex: /^[0-9]+|me$/,
required: true,
},
},
exits: {
boardNotFound: {
responseType: 'notFound',
},
},
async fn(inputs) {
let user;
if (inputs.id === CURRENT_USER_ID) {
({ currentUser: user } = this.req);
if (this.req.isSocket) {
sails.sockets.join(this.req, `user:${user.id}`); // TODO: only when subscription needed
}
} else {
user = await sails.helpers.users.getOne(inputs.id);
if (!user) {
throw Errors.USER_NOT_FOUND;
}
}
return {
item: user,
};
},
};

44
server/api/controllers/users/update-avatar.js
View file

@ -27,7 +27,7 @@ module.exports = {
let user;
if (currentUser.isAdmin) {
user = await sails.helpers.getUser(inputs.id);
user = await sails.helpers.users.getOne(inputs.id);
if (!user) {
throw Errors.USER_NOT_FOUND;
@ -38,30 +38,32 @@ module.exports = {
user = currentUser;
}
this.req.file('file').upload(sails.helpers.createUserAvatarReceiver(), async (error, files) => {
if (error) {
return exits.uploadError(error.message);
}
this.req
.file('file')
.upload(sails.helpers.utils.createUserAvatarReceiver(), async (error, files) => {
if (error) {
return exits.uploadError(error.message);
}
if (files.length === 0) {
return exits.uploadError('No file was uploaded');
}
if (files.length === 0) {
return exits.uploadError('No file was uploaded');
}
user = await sails.helpers.updateUser(
user,
{
avatarDirname: files[0].extra.dirname,
},
this.req,
);
user = await sails.helpers.users.updateOne(
user,
{
avatarDirname: files[0].extra.dirname,
},
this.req,
);
if (!user) {
throw Errors.USER_NOT_FOUND;
}
if (!user) {
throw Errors.USER_NOT_FOUND;
}
return exits.success({
item: user.toJSON(),
return exits.success({
item: user.toJSON(),
});
});
});
},
};

12
server/api/controllers/users/update-email.js
View file

@ -42,7 +42,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
if (inputs.id === currentUser.id) {
@ -53,7 +53,7 @@ module.exports = {
throw Errors.USER_NOT_FOUND; // Forbidden
}
let user = await sails.helpers.getUser(inputs.id);
let user = await sails.helpers.users.getOne(inputs.id);
if (!user) {
throw Errors.USER_NOT_FOUND;
@ -68,16 +68,16 @@ module.exports = {
const values = _.pick(inputs, ['email']);
user = await sails.helpers
.updateUser(user, values, this.req)
user = await sails.helpers.users
.update(user, values, this.req)
.intercept('emailAlreadyInUse', () => Errors.EMAIL_ALREADY_IN_USE);
if (!user) {
throw Errors.USER_NOT_FOUND;
}
return exits.success({
return {
item: user,
});
};
},
};

10
server/api/controllers/users/update-password.js
View file

@ -35,7 +35,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
if (inputs.id === currentUser.id) {
@ -46,7 +46,7 @@ module.exports = {
throw Errors.USER_NOT_FOUND; // Forbidden
}
let user = await sails.helpers.getUser(inputs.id);
let user = await sails.helpers.users.getOne(inputs.id);
if (!user) {
throw Errors.USER_NOT_FOUND;
@ -60,14 +60,14 @@ module.exports = {
}
const values = _.pick(inputs, ['password']);
user = await sails.helpers.updateUser(user, values, this.req);
user = await sails.helpers.users.updateOne(user, values, this.req);
if (!user) {
throw Errors.USER_NOT_FOUND;
}
return exits.success({
return {
item: user,
});
};
},
};

12
server/api/controllers/users/update-username.js
View file

@ -44,7 +44,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
if (inputs.id === currentUser.id) {
@ -55,7 +55,7 @@ module.exports = {
throw Errors.USER_NOT_FOUND; // Forbidden
}
let user = await sails.helpers.getUser(inputs.id);
let user = await sails.helpers.users.getOne(inputs.id);
if (!user) {
throw Errors.USER_NOT_FOUND;
@ -70,16 +70,16 @@ module.exports = {
const values = _.pick(inputs, ['username']);
user = await sails.helpers
.updateUser(user, values, this.req)
user = await sails.helpers.users
.update(user, values, this.req)
.intercept('usernameAlreadyInUse', () => Errors.USERNAME_ALREADY_IN_USE);
if (!user) {
throw Errors.USER_NOT_FOUND;
}
return exits.success({
return {
item: user,
});
};
},
};

10
server/api/controllers/users/update.js
View file

@ -43,7 +43,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const { currentUser } = this.req;
if (!currentUser.isAdmin) {
@ -54,7 +54,7 @@ module.exports = {
delete inputs.isAdmin; // eslint-disable-line no-param-reassign
}
let user = await sails.helpers.getUser(inputs.id);
let user = await sails.helpers.users.getOne(inputs.id);
if (!user) {
throw Errors.USER_NOT_FOUND;
@ -69,14 +69,14 @@ module.exports = {
'subscribeToOwnCards',
]);
user = await sails.helpers.updateUser(user, values, this.req);
user = await sails.helpers.users.updateOne(user, values, this.req);
if (!user) {
throw Errors.USER_NOT_FOUND;
}
return exits.success({
return {
item: user,
});
};
},
};

47
server/api/helpers/actions/create-one.js Normal file
View file

@ -0,0 +1,47 @@
module.exports = {
inputs: {
values: {
type: 'json',
required: true,
},
user: {
type: 'ref',
required: true,
},
card: {
type: 'ref',
required: true,
},
request: {
type: 'ref',
},
},
async fn(inputs) {
const action = await Action.create({
...inputs.values,
cardId: inputs.card.id,
userId: inputs.user.id,
}).fetch();
sails.sockets.broadcast(
`board:${inputs.card.boardId}`,
'actionCreate',
{
item: action,
},
inputs.request,
);
const subscriptionUserIds = await sails.helpers.cards.getSubscriptionUserIds(
action.cardId,
action.userId,
);
subscriptionUserIds.forEach(async (userId) => {
await sails.helpers.notifications.createOne(userId, action);
});
return action;
},
};

4
server/api/helpers/delete-action.js → server/api/helpers/actions/delete-one.js
View file

@ -13,7 +13,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const action = await Action.archiveOne(inputs.record.id);
if (action) {
@ -27,6 +27,6 @@ module.exports = {
);
}
return exits.success(action);
return action;
},
};

6
server/api/helpers/get-actions.js → server/api/helpers/actions/get-many.js
View file

@ -9,9 +9,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
const actions = await Action.find(inputs.criteria).sort('id DESC').limit(inputs.limit);
return exits.success(actions);
async fn(inputs) {
return Action.find(inputs.criteria).sort('id DESC').limit(inputs.limit);
},
};

10
server/api/helpers/get-action-to-project-path.js → server/api/helpers/actions/get-project-path.js Executable file → Normal file
View file

@ -10,15 +10,15 @@ module.exports = {
pathNotFound: {},
},
async fn(inputs, exits) {
async fn(inputs) {
const action = await Action.findOne(inputs.criteria);
if (!action) {
throw 'pathNotFound';
}
const path = await sails.helpers
.getCardToProjectPath(action.cardId)
const path = await sails.helpers.cards
.getProjectPath(action.cardId)
.intercept('pathNotFound', (nodes) => ({
pathNotFound: {
action,
@ -26,9 +26,9 @@ module.exports = {
},
}));
return exits.success({
return {
action,
...path,
});
};
},
};

4
server/api/helpers/update-action.js → server/api/helpers/actions/update-one.js
View file

@ -17,7 +17,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const action = await Action.updateOne(inputs.record.id).set(inputs.values);
if (action) {
@ -31,6 +31,6 @@ module.exports = {
);
}
return exits.success(action);
return action;
},
};

23
server/api/helpers/create-attachment.js → server/api/helpers/attachments/create-one.js
View file

@ -1,33 +1,31 @@
module.exports = {
inputs: {
card: {
type: 'ref',
values: {
type: 'json',
required: true,
},
user: {
type: 'ref',
required: true,
},
values: {
type: 'json',
card: {
type: 'ref',
required: true,
},
requestId: {
type: 'string',
isNotEmptyString: true,
allowNull: true,
defaultsTo: null,
},
request: {
type: 'ref',
},
},
async fn(inputs, exits) {
async fn(inputs) {
const attachment = await Attachment.create({
...inputs.values,
cardId: inputs.card.id,
userId: inputs.user.id,
creatorUserId: inputs.user.id,
}).fetch();
sails.sockets.broadcast(
@ -41,14 +39,11 @@ module.exports = {
);
if (!inputs.card.coverAttachmentId && attachment.isImage) {
await sails.helpers.updateCard.with({
record: inputs.card,
values: {
coverAttachmentId: attachment.id,
},
await sails.helpers.cards.updateOne(inputs.card, {
coverAttachmentId: attachment.id,
});
}
return exits.success(attachment);
return attachment;
},
};

10
server/api/helpers/delete-attachment.js → server/api/helpers/attachments/delete-one.js
View file

@ -7,11 +7,11 @@ module.exports = {
type: 'ref',
required: true,
},
card: {
board: {
type: 'ref',
required: true,
},
board: {
card: {
type: 'ref',
required: true,
},
@ -20,9 +20,9 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
if (inputs.record.id === inputs.card.coverAttachmentId) {
await sails.helpers.updateCard.with({
await sails.helpers.cards.updateOne.with({
record: inputs.card,
values: {
coverAttachmentId: null,
@ -50,6 +50,6 @@ module.exports = {
);
}
return exits.success(attachment);
return attachment;
},
};

6
server/api/helpers/get-tasks.js → server/api/helpers/attachments/get-many.js
View file

@ -6,9 +6,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
const tasks = await Task.find(inputs.criteria).sort('id');
return exits.success(tasks);
async fn(inputs) {
return Attachment.find(inputs.criteria).sort('id');
},
};

10
server/api/helpers/get-attachment-to-project-path.js → server/api/helpers/attachments/get-project-path.js Executable file → Normal file
View file

@ -10,15 +10,15 @@ module.exports = {
pathNotFound: {},
},
async fn(inputs, exits) {
async fn(inputs) {
const attachment = await Attachment.findOne(inputs.criteria);
if (!attachment) {
throw 'pathNotFound';
}
const path = await sails.helpers
.getCardToProjectPath(attachment.cardId)
const path = await sails.helpers.cards
.getProjectPath(attachment.cardId)
.intercept('pathNotFound', (nodes) => ({
pathNotFound: {
attachment,
@ -26,9 +26,9 @@ module.exports = {
},
}));
return exits.success({
return {
attachment,
...path,
});
};
},
};

4
server/api/helpers/update-attachment.js → server/api/helpers/attachments/update-one.js
View file

@ -17,7 +17,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const attachment = await Attachment.updateOne(inputs.record.id).set(inputs.values);
if (attachment) {
@ -31,6 +31,6 @@ module.exports = {
);
}
return exits.success(attachment);
return attachment;
},
};

48
server/api/helpers/board-memberships/create-one.js Normal file
View file

@ -0,0 +1,48 @@
module.exports = {
inputs: {
user: {
type: 'ref',
required: true,
},
board: {
type: 'ref',
required: true,
},
request: {
type: 'ref',
},
},
exits: {
userAlreadyBoardMember: {},
},
async fn(inputs) {
const boardMembership = await BoardMembership.create({
boardId: inputs.board.id,
userId: inputs.user.id,
})
.intercept('E_UNIQUE', 'userAlreadyBoardMember')
.fetch();
sails.sockets.broadcast(
`user:${boardMembership.userId}`,
'boardMembershipCreate',
{
item: boardMembership,
},
inputs.request,
);
sails.sockets.broadcast(
`board:${boardMembership.boardId}`,
'boardMembershipCreate',
{
item: boardMembership,
},
inputs.request,
);
return boardMembership;
},
};

71
server/api/helpers/board-memberships/delete-one.js Normal file
View file

@ -0,0 +1,71 @@
module.exports = {
inputs: {
record: {
type: 'ref',
required: true,
},
project: {
type: 'ref',
required: true,
},
request: {
type: 'ref',
},
},
async fn(inputs) {
const cardIds = await sails.helpers.boards.getCardIds(inputs.record.boardId);
await CardSubscription.destroy({
cardId: cardIds,
userId: inputs.record.userId,
});
await CardMembership.destroy({
cardId: cardIds,
userId: inputs.record.userId,
});
const boardMembership = await BoardMembership.destroyOne(inputs.record.id);
if (boardMembership) {
sails.sockets.broadcast(
`user:${boardMembership.userId}`,
'boardMembershipDelete',
{
item: boardMembership,
},
inputs.request,
);
const notifyBoard = () => {
sails.sockets.broadcast(
`board:${boardMembership.boardId}`,
'boardMembershipDelete',
{
item: boardMembership,
},
inputs.request,
);
};
const isProjectManager = await sails.helpers.users.isProjectManager(
inputs.record.userId,
inputs.project.id,
);
if (isProjectManager) {
notifyBoard();
} else {
// TODO: also remove if unsubscribed to user
sails.sockets.removeRoomMembersFromRooms(
`user:${boardMembership.userId}`,
`board:${boardMembership.boardId}`,
notifyBoard,
);
}
}
return boardMembership;
},
};

6
server/api/helpers/get-labels.js → server/api/helpers/board-memberships/get-many.js
View file

@ -6,9 +6,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
const labels = await Label.find(inputs.criteria).sort('id');
return exits.success(labels);
async fn(inputs) {
return BoardMembership.find(inputs.criteria).sort('id');
},
};

34
server/api/helpers/board-memberships/get-project-path.js Normal file
View file

@ -0,0 +1,34 @@
module.exports = {
inputs: {
criteria: {
type: 'json',
required: true,
},
},
exits: {
pathNotFound: {},
},
async fn(inputs) {
const boardMembership = await BoardMembership.findOne(inputs.criteria);
if (!boardMembership) {
throw 'pathNotFound';
}
const path = await sails.helpers.boards
.getProjectPath(boardMembership.boardId)
.intercept('pathNotFound', (nodes) => ({
pathNotFound: {
boardMembership,
...nodes,
},
}));
return {
boardMembership,
...path,
};
},
};

40
server/api/helpers/create-board.js → server/api/helpers/boards/create-one.js
View file

@ -1,29 +1,32 @@
module.exports = {
inputs: {
project: {
type: 'ref',
required: true,
},
values: {
type: 'json',
custom: (value) => _.isPlainObject(value) && _.isFinite(value.position),
required: true,
},
user: {
type: 'ref',
required: true,
},
project: {
type: 'ref',
required: true,
},
request: {
type: 'ref',
},
},
async fn(inputs, exits) {
const boards = await sails.helpers.getBoardsForProject(inputs.project.id);
async fn(inputs) {
const managerUserIds = await sails.helpers.projects.getManagerUserIds(inputs.project.id);
const boards = await sails.helpers.projects.getBoards(inputs.project.id);
const { position, repositions } = sails.helpers.insertToPositionables(
const { position, repositions } = sails.helpers.utils.insertToPositionables(
inputs.values.position,
boards,
);
const userIds = await sails.helpers.getMembershipUserIdsForProject(inputs.project.id);
repositions.forEach(async ({ id, position: nextPosition }) => {
await Board.update({
id,
@ -32,6 +35,9 @@ module.exports = {
position: nextPosition,
});
const memberUserIds = await sails.helpers.boards.getMemberUserIds(id);
const userIds = _.union(managerUserIds, memberUserIds);
userIds.forEach((userId) => {
sails.sockets.broadcast(`user:${userId}`, 'boardUpdate', {
item: {
@ -48,21 +54,25 @@ module.exports = {
projectId: inputs.project.id,
}).fetch();
userIds.forEach((userId) => {
const boardMembership = await BoardMembership.create({
boardId: board.id,
userId: inputs.user.id,
}).fetch();
managerUserIds.forEach((userId) => {
sails.sockets.broadcast(
`user:${userId}`,
'boardCreate',
{
item: board,
included: {
lists: [],
labels: [],
},
},
inputs.request,
);
});
return exits.success(board);
return {
board,
boardMembership,
};
},
};

30
server/api/helpers/boards/delete-one.js Normal file
View file

@ -0,0 +1,30 @@
module.exports = {
inputs: {
record: {
type: 'ref',
required: true,
},
request: {
type: 'ref',
},
},
async fn(inputs) {
const board = await Board.archiveOne(inputs.record.id);
if (board) {
sails.sockets.leaveAll(`board:${board.id}`);
sails.sockets.broadcast(
`project:${board.projectId}`,
'boardDelete',
{
item: board,
},
inputs.request,
);
}
return board;
},
};

15
server/api/helpers/boards/get-board-memberships.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
return sails.helpers.boardMemberships.getMany({
boardId: inputs.idOrIds,
});
},
};

15
server/api/helpers/boards/get-card-ids.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
const cards = await sails.helpers.boards.getCards(inputs.idOrIds);
return sails.helpers.utils.mapRecords(cards);
},
};

18
server/api/helpers/get-cards-for-board.js → server/api/helpers/boards/get-cards.js
View file

@ -2,7 +2,7 @@ const LIMIT = 10;
module.exports = {
inputs: {
recordOrId: {
recordOrIdOrIds: {
type: 'ref',
custom: (value) => _.isObjectLike(value) || _.isString(value) || _.every(value, _.isString),
required: true,
@ -12,18 +12,18 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const criteria = {};
let sort;
let limit;
if (_.isObjectLike(inputs.recordOrId)) {
criteria.boardId = inputs.recordOrId.id;
if (_.isObjectLike(inputs.recordOrIdOrIds)) {
criteria.boardId = inputs.recordOrIdOrIds.id;
if (inputs.recordOrId.type === 'kanban') {
if (inputs.recordOrIdOrIds.type === Board.Types.KANBAN) {
sort = 'position';
} else if (inputs.recordOrId.type === 'collection') {
} else if (inputs.recordOrIdOrIds.type === Board.Types.COLLECTION) {
if (inputs.beforeId) {
criteria.id = {
'<': inputs.beforeId,
@ -33,11 +33,9 @@ module.exports = {
limit = LIMIT;
}
} else {
criteria.boardId = inputs.recordOrId;
criteria.boardId = inputs.recordOrIdOrIds;
}
const cards = await sails.helpers.getCards(criteria, sort, limit);
return exits.success(cards);
return sails.helpers.cards.getMany(criteria, sort, limit);
},
};

15
server/api/helpers/boards/get-labels.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
return sails.helpers.labels.getMany({
boardId: inputs.idOrIds,
});
},
};

27
server/api/helpers/boards/get-lists.js Normal file
View file

@ -0,0 +1,27 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
exceptListIdOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
},
},
async fn(inputs) {
const criteria = {
boardId: inputs.idOrIds,
};
if (!_.isUndefined(inputs.exceptListIdOrIds)) {
criteria.id = {
'!=': inputs.exceptListIdOrIds,
};
}
return sails.helpers.lists.getMany(criteria);
},
};

6
server/api/helpers/get-boards.js → server/api/helpers/boards/get-many.js
View file

@ -6,9 +6,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
const boards = await Board.find(inputs.criteria).sort('position');
return exits.success(boards);
async fn(inputs) {
return Board.find(inputs.criteria).sort('position');
},
};

15
server/api/helpers/boards/get-member-user-ids.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
const boardMemberships = await sails.helpers.boards.getBoardMemberships(inputs.idOrIds);
return sails.helpers.utils.mapRecords(boardMemberships, 'userId', _.isArray(inputs.idOrIds));
},
};

6
server/api/helpers/get-board-to-project-path.js → server/api/helpers/boards/get-project-path.js Executable file → Normal file
View file

@ -10,7 +10,7 @@ module.exports = {
pathNotFound: {},
},
async fn(inputs, exits) {
async fn(inputs) {
const board = await Board.findOne(inputs.criteria);
if (!board) {
@ -27,9 +27,9 @@ module.exports = {
};
}
return exits.success({
return {
board,
project,
});
};
},
};

12
server/api/helpers/update-board.js → server/api/helpers/boards/update-one.js
View file

@ -24,16 +24,18 @@ module.exports = {
},
},
async fn(inputs, exits) {
const userIds = await sails.helpers.getMembershipUserIdsForProject(inputs.record.projectId);
async fn(inputs) {
const userIds = await sails.helpers.projects.getManagerAndBoardMemberUserIds(
inputs.record.projectId,
);
if (!_.isUndefined(inputs.values.position)) {
const boards = await sails.helpers.getBoardsForProject(
const boards = await sails.helpers.projects.getBoards(
inputs.record.projectId,
inputs.record.id,
);
const { position, repositions } = sails.helpers.insertToPositionables(
const { position, repositions } = sails.helpers.utils.insertToPositionables(
inputs.values.position,
boards,
);
@ -74,6 +76,6 @@ module.exports = {
});
}
return exits.success(board);
return board;
},
};

8
server/api/helpers/create-card-label.js → server/api/helpers/card-labels/create-one.js
View file

@ -1,10 +1,10 @@
module.exports = {
inputs: {
card: {
label: {
type: 'ref',
required: true,
},
label: {
card: {
type: 'ref',
required: true,
},
@ -17,7 +17,7 @@ module.exports = {
labelAlreadyInCard: {},
},
async fn(inputs, exits) {
async fn(inputs) {
const cardLabel = await CardLabel.create({
cardId: inputs.card.id,
labelId: inputs.label.id,
@ -34,6 +34,6 @@ module.exports = {
inputs.request,
);
return exits.success(cardLabel);
return cardLabel;
},
};

4
server/api/helpers/delete-card-label.js → server/api/helpers/card-labels/delete-one.js
View file

@ -13,7 +13,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const cardLabel = await CardLabel.destroyOne(inputs.record.id);
if (cardLabel) {
@ -27,6 +27,6 @@ module.exports = {
);
}
return exits.success(cardLabel);
return cardLabel;
},
};

6
server/api/helpers/get-projects.js → server/api/helpers/card-labels/get-many.js
View file

@ -6,9 +6,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
const projects = await Project.find(inputs.criteria).sort('id');
return exits.success(projects);
async fn(inputs) {
return CardLabel.find(inputs.criteria).sort('id');
},
};

16
server/api/helpers/create-card-membership.js → server/api/helpers/card-memberships/create-one.js
View file

@ -1,14 +1,14 @@
module.exports = {
inputs: {
card: {
type: 'ref',
required: true,
},
userOrUserId: {
userOrId: {
type: 'ref',
custom: (value) => _.isObjectLike(value) || _.isString(value),
required: true,
},
card: {
type: 'ref',
required: true,
},
request: {
type: 'ref',
},
@ -18,8 +18,8 @@ module.exports = {
userAlreadyCardMember: {},
},
async fn(inputs, exits) {
const { userId = inputs.userOrUserId } = inputs.userOrUserId;
async fn(inputs) {
const { userId = inputs.userOrId } = inputs.userOrId;
const cardMembership = await CardMembership.create({
userId,
@ -59,6 +59,6 @@ module.exports = {
);
}
return exits.success(cardMembership);
return cardMembership;
},
};

4
server/api/helpers/delete-card-membership.js → server/api/helpers/card-memberships/delete-one.js
View file

@ -13,7 +13,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const cardMembership = await CardMembership.destroyOne(inputs.record.id);
if (cardMembership) {
@ -42,6 +42,6 @@ module.exports = {
}
}
return exits.success(cardMembership);
return cardMembership;
},
};

12
server/api/helpers/card-memberships/get-many.js Normal file
View file

@ -0,0 +1,12 @@
module.exports = {
inputs: {
criteria: {
type: 'json',
custom: (value) => _.isArray(value) || _.isPlainObject(value),
},
},
async fn(inputs) {
return CardMembership.find(inputs.criteria).sort('id');
},
};

12
server/api/helpers/card-subscriptions/get-many.js Normal file
View file

@ -0,0 +1,12 @@
module.exports = {
inputs: {
criteria: {
type: 'json',
custom: (value) => _.isArray(value) || _.isPlainObject(value),
},
},
async fn(inputs) {
return CardSubscription.find(inputs.criteria).sort('id');
},
};

76
server/api/helpers/create-card.js → server/api/helpers/cards/create-one.js
View file

@ -1,12 +1,5 @@
module.exports = {
inputs: {
board: {
type: 'ref',
required: true,
},
list: {
type: 'ref',
},
values: {
type: 'json',
custom: (value) => {
@ -26,6 +19,13 @@ module.exports = {
type: 'ref',
required: true,
},
board: {
type: 'ref',
required: true,
},
list: {
type: 'ref',
},
request: {
type: 'ref',
},
@ -37,12 +37,10 @@ module.exports = {
positionMustBeInValues: {},
},
async fn(inputs, exits) {
async fn(inputs) {
const { values } = inputs;
values.boardId = inputs.board.id;
if (inputs.board.type === 'kanban') {
if (inputs.board.type === Board.Types.KANBAN) {
if (!inputs.list) {
throw 'listMustBePresent';
}
@ -57,9 +55,9 @@ module.exports = {
throw 'positionMustBeInValues';
}
const cards = await sails.helpers.getCardsForList(inputs.list.id);
const cards = await sails.helpers.lists.getCards(inputs.list.id);
const { position, repositions } = sails.helpers.insertToPositionables(
const { position, repositions } = sails.helpers.utils.insertToPositionables(
inputs.values.position,
cards,
);
@ -81,11 +79,24 @@ module.exports = {
});
values.position = position;
} else if (inputs.board.type === 'collection') {
} else if (inputs.board.type === Board.Types.COLLECTION) {
delete values.position;
}
const card = await Card.create(values).fetch();
const card = await Card.create({
...values,
boardId: inputs.board.id,
creatorUserId: inputs.user.id,
}).fetch();
sails.sockets.broadcast(
`board:${card.boardId}`,
'cardCreate',
{
item: card,
},
inputs.request,
);
if (inputs.user.subscribeToOwnCards) {
await CardSubscription.create({
@ -93,34 +104,25 @@ module.exports = {
userId: inputs.user.id,
}).tolerate('E_UNIQUE');
card.isSubscribed = true;
} else {
card.isSubscribed = false;
sails.sockets.broadcast(`user:${inputs.user.id}`, 'cardUpdate', {
item: {
id: card.id,
isSubscribed: true,
},
});
}
// FIXME: broadcast subscription separately
sails.sockets.broadcast(
`board:${card.boardId}`,
'cardCreate',
await sails.helpers.actions.createOne(
{
item: card,
included: {
cardMemberships: [],
cardLabels: [],
tasks: [],
attachments: [],
type: Action.Types.CREATE_CARD,
data: {
list: _.pick(inputs.list, ['id', 'name']),
},
},
inputs.request,
inputs.user,
card,
);
await sails.helpers.createAction(card, inputs.user, {
type: 'createCard',
data: {
list: _.pick(inputs.list, ['id', 'name']),
},
});
return exits.success(card);
return card;
},
};

4
server/api/helpers/delete-card.js → server/api/helpers/cards/delete-one.js
View file

@ -9,7 +9,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const card = await Card.archiveOne(inputs.record.id);
if (card) {
@ -23,6 +23,6 @@ module.exports = {
);
}
return exits.success(card);
return card;
},
};

12
server/api/helpers/get-actions-for-card.js → server/api/helpers/cards/get-actions.js
View file

@ -2,9 +2,9 @@ const LIMIT = 10;
module.exports = {
inputs: {
id: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.isArray(value),
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
beforeId: {
@ -12,9 +12,9 @@ module.exports = {
},
},
async fn(inputs, exits) {
async fn(inputs) {
const criteria = {
cardId: inputs.id,
cardId: inputs.idOrIds,
};
if (!_.isUndefined(inputs.beforeId)) {
@ -23,8 +23,6 @@ module.exports = {
};
}
const actions = await sails.helpers.getActions(criteria, LIMIT);
return exits.success(actions);
return sails.helpers.actions.getMany(criteria, LIMIT);
},
};

15
server/api/helpers/cards/get-attachments.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
return sails.helpers.attachments.getMany({
cardId: inputs.idOrIds,
});
},
};

15
server/api/helpers/cards/get-card-labels.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
return sails.helpers.cardLabels.getMany({
cardId: inputs.idOrIds,
});
},
};

15
server/api/helpers/cards/get-card-memberships.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
return sails.helpers.cardMemberships.getMany({
cardId: inputs.idOrIds,
});
},
};

27
server/api/helpers/cards/get-card-subscriptions.js Normal file
View file

@ -0,0 +1,27 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
exceptUserIdOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
},
},
async fn(inputs) {
const criteria = {
cardId: inputs.idOrIds,
};
if (!_.isUndefined(inputs.exceptUserIdOrIds)) {
criteria.userId = {
'!=': inputs.exceptUserIdOrIds,
};
}
return sails.helpers.cardSubscriptions.getMany(criteria);
},
};

15
server/api/helpers/cards/get-label-ids.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
const cardLabels = await sails.helpers.cards.getCardLabels(inputs.idOrIds);
return sails.helpers.utils.mapRecords(cardLabels, 'labelId', _.isArray(inputs.idOrIds));
},
};

15
server/api/helpers/cards/get-labels.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
const labelIds = await sails.helpers.cards.getLabelIds(inputs.idOrIds);
return sails.helpers.labels.getMany(labelIds);
},
};

6
server/api/helpers/get-cards.js → server/api/helpers/cards/get-many.js
View file

@ -13,9 +13,7 @@ module.exports = {
},
},
async fn(inputs, exits) {
const cards = await Card.find(inputs.criteria).sort(inputs.sort).limit(inputs.limit);
return exits.success(cards);
async fn(inputs) {
return Card.find(inputs.criteria).sort(inputs.sort).limit(inputs.limit);
},
};

14
server/api/helpers/get-card-to-project-path.js → server/api/helpers/cards/get-project-path.js Executable file → Normal file
View file

@ -10,7 +10,7 @@ module.exports = {
pathNotFound: {},
},
async fn(inputs, exits) {
async fn(inputs) {
const card = await Card.findOne(inputs.criteria);
if (!card) {
@ -19,8 +19,8 @@ module.exports = {
let path;
if (card.listId) {
path = await sails.helpers
.getListToProjectPath(card.listId)
path = await sails.helpers.lists
.getProjectPath(card.listId)
.intercept('pathNotFound', (nodes) => ({
pathNotFound: {
card,
@ -28,8 +28,8 @@ module.exports = {
},
}));
} else {
path = await sails.helpers
.getBoardToProjectPath(card.boardId)
path = await sails.helpers.boards
.getProjectPath(card.boardId)
.intercept('pathNotFound', (nodes) => ({
pathNotFound: {
card,
@ -38,9 +38,9 @@ module.exports = {
}));
}
return exits.success({
return {
card,
...path,
});
};
},
};

22
server/api/helpers/cards/get-subscription-user-ids.js Normal file
View file

@ -0,0 +1,22 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
exceptUserIdOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
},
},
async fn(inputs) {
const cardSubscriptions = await sails.helpers.cards.getCardSubscriptions(
inputs.idOrIds,
inputs.exceptUserIdOrIds,
);
return sails.helpers.utils.mapRecords(cardSubscriptions, 'userId', _.isArray(inputs.idOrIds));
},
};

15
server/api/helpers/cards/get-tasks.js Normal file
View file

@ -0,0 +1,15 @@
module.exports = {
inputs: {
idOrIds: {
type: 'json',
custom: (value) => _.isString(value) || _.every(value, _.isString),
required: true,
},
},
async fn(inputs) {
return sails.helpers.tasks.getMany({
cardId: inputs.idOrIds,
});
},
};

152
server/api/helpers/update-card.js → server/api/helpers/cards/update-one.js
View file

@ -4,12 +4,6 @@ module.exports = {
type: 'ref',
required: true,
},
toBoard: {
type: 'ref',
},
toList: {
type: 'ref',
},
values: {
type: 'json',
custom: (value) => {
@ -23,7 +17,16 @@ module.exports = {
return true;
},
required: true,
defaultsTo: {},
},
nextBoard: {
type: 'ref',
},
nextList: {
type: 'ref',
},
user: {
type: 'ref',
},
board: {
type: 'ref',
@ -31,9 +34,6 @@ module.exports = {
list: {
type: 'ref',
},
user: {
type: 'ref',
},
request: {
type: 'ref',
},
@ -42,66 +42,66 @@ module.exports = {
exits: {
boardMustBePresent: {},
listMustBePresent: {},
toListMustBelongToBoard: {},
toListMustBePresent: {},
nextListMustBelongToBoard: {},
nextListMustBePresent: {},
positionMustBeInValues: {},
userMustBePresent: {},
},
async fn(inputs, exits) {
async fn(inputs) {
const { isSubscribed, ...values } = inputs.values;
if (inputs.toBoard || inputs.toList || !_.isUndefined(values.position)) {
if (inputs.nextBoard || inputs.nextList || !_.isUndefined(values.position)) {
if (!inputs.board) {
throw 'boardMustBePresent';
}
if (inputs.toBoard) {
if (inputs.toBoard.id === inputs.board.id) {
delete inputs.toBoard; // eslint-disable-line no-param-reassign
if (inputs.nextBoard) {
if (inputs.nextBoard.id === inputs.board.id) {
delete inputs.nextBoard; // eslint-disable-line no-param-reassign
} else {
values.boardId = inputs.toBoard.id;
values.boardId = inputs.nextBoard.id;
}
}
const board = inputs.toBoard || inputs.board;
const board = inputs.nextBoard || inputs.board;
if (inputs.toList) {
if (inputs.board.type === 'kanban' && !inputs.list) {
if (inputs.nextList) {
if (inputs.board.type === Board.Types.KANBAN && !inputs.list) {
throw 'listMustBePresent';
}
if (inputs.toList.boardId !== board.id) {
throw 'toListMustBelongToBoard';
if (inputs.nextList.boardId !== board.id) {
throw 'nextListMustBelongToBoard';
}
if (
board.type === 'collection' ||
(inputs.board.type === 'kanban' && inputs.toList.id === inputs.list.id)
board.type === Board.Types.COLLECTION ||
(inputs.board.type === Board.Types.KANBAN && inputs.nextList.id === inputs.list.id)
) {
delete inputs.toList; // eslint-disable-line no-param-reassign
delete inputs.nextList; // eslint-disable-line no-param-reassign
} else {
values.listId = inputs.toList.id;
values.listId = inputs.nextList.id;
}
}
if (inputs.toList) {
if (inputs.nextList) {
if (_.isUndefined(values.position)) {
throw 'positionMustBeInValues';
}
} else if (inputs.toBoard) {
if (inputs.toBoard.type === 'kanban') {
throw 'toListMustBePresent';
} else if (inputs.nextBoard) {
if (inputs.nextBoard.type === Board.Types.KANBAN) {
throw 'nextListMustBePresent';
}
if (inputs.board.type === 'kanban') {
if (inputs.board.type === Board.Types.KANBAN) {
values.listId = null;
values.position = null;
}
}
}
if ((!_.isUndefined(isSubscribed) || inputs.toBoard || inputs.toList) && !inputs.user) {
if ((!_.isUndefined(isSubscribed) || inputs.nextBoard || inputs.nextList) && !inputs.user) {
throw 'userMustBePresent';
}
@ -109,8 +109,12 @@ module.exports = {
const boardId = values.boardId || inputs.record.boardId;
const listId = values.listId || inputs.record.listId;
const cards = await sails.helpers.getCardsForList(listId, inputs.record.id);
const { position, repositions } = sails.helpers.insertToPositionables(values.position, cards);
const cards = await sails.helpers.lists.getCards(listId, inputs.record.id);
const { position, repositions } = sails.helpers.utils.insertToPositionables(
values.position,
cards,
);
repositions.forEach(async ({ id, position: nextPosition }) => {
await Card.update({
@ -134,28 +138,26 @@ module.exports = {
let card;
if (!_.isEmpty(values)) {
let prevLabels;
if (inputs.toBoard) {
if (inputs.toBoard.projectId !== inputs.board.projectId) {
const userIds = await sails.helpers.getMembershipUserIdsForProject(
inputs.toBoard.projectId,
);
if (inputs.nextBoard) {
if (inputs.nextBoard.projectId !== inputs.board.projectId) {
const memberUserIds = await sails.helpers.boards.getMemberUserIds(inputs.nextBoard.id);
await CardSubscription.destroy({
cardId: inputs.record.id,
userId: {
'!=': userIds,
'!=': memberUserIds,
},
});
await CardMembership.destroy({
cardId: inputs.record.id,
userId: {
'!=': userIds,
'!=': memberUserIds,
},
});
}
prevLabels = await sails.helpers.getLabelsForCard(inputs.record.id);
prevLabels = await sails.helpers.cards.getLabels(inputs.record.id);
await CardLabel.destroy({
cardId: inputs.record.id,
@ -165,20 +167,11 @@ module.exports = {
card = await Card.updateOne(inputs.record.id).set(values);
if (!card) {
return exits.success(card);
return card;
}
if (inputs.toBoard) {
sails.sockets.broadcast(
`board:${inputs.board.id}`,
'cardDelete',
{
item: inputs.record,
},
inputs.request,
);
const labels = await sails.helpers.getLabelsForBoard(card.boardId);
if (inputs.nextBoard) {
const labels = await sails.helpers.boards.getLabels(card.boardId);
const labelByNameMap = _.keyBy(labels, 'name');
const labelIds = await Promise.all(
@ -187,9 +180,9 @@ module.exports = {
return labelByNameMap[prevLabel.name].id;
}
const { id } = await sails.helpers.createLabel(
inputs.toBoard,
const { id } = await sails.helpers.labels.createOne(
_.omit(prevLabel, ['id', 'boardId']),
inputs.nextBoard,
);
return id;
@ -197,34 +190,23 @@ module.exports = {
);
await Promise.all(
labelIds.map(async (labelId) => {
await CardLabel.create({
labelIds.map(async (labelId) =>
CardLabel.create({
labelId,
cardId: card.id,
})
.tolerate('E_UNIQUE')
.fetch();
}),
.fetch(),
),
);
const cardMemberships = await sails.helpers.getMembershipsForCard(card.id);
const cardLabels = await sails.helpers.getCardLabelsForCard(card.id);
const tasks = await sails.helpers.getTasksForCard(card.id);
const attachments = await sails.helpers.getAttachmentsForCard(card.id);
sails.sockets.broadcast(`board:${card.boardId}`, 'cardCreate', {
sails.sockets.broadcast(`board:${card.boardId}`, 'cardUpdate', {
item: card,
included: {
cardMemberships,
cardLabels,
tasks,
attachments,
},
});
const userIds = await sails.helpers.getSubscriptionUserIdsForCard(card.id);
const subscriptionUserIds = await sails.helpers.cards.getSubscriptionUserIds(card.id);
userIds.forEach((userId) => {
subscriptionUserIds.forEach((userId) => {
sails.sockets.broadcast(`user:${userId}`, 'cardUpdate', {
item: {
id: card.id,
@ -243,15 +225,19 @@ module.exports = {
);
}
if (!inputs.toBoard && inputs.toList) {
if (!inputs.nextBoard && inputs.nextList) {
// TODO: add transfer action
await sails.helpers.createAction(card, inputs.user, {
type: 'moveCard',
data: {
fromList: _.pick(inputs.list, ['id', 'name']),
toList: _.pick(inputs.toList, ['id', 'name']),
await sails.helpers.actions.createOne(
{
type: Action.Types.MOVE_CARD,
data: {
fromList: _.pick(inputs.list, ['id', 'name']),
toList: _.pick(inputs.nextList, ['id', 'name']),
},
},
});
inputs.user,
card,
);
}
} else {
card = inputs.record;
@ -290,6 +276,6 @@ module.exports = {
}
}
return exits.success(card);
return card;
},
};

Some files were not shown because too many files have changed in this diff Show more