import Planka upstream

This commit is contained in:
xiaojibeier
2026-07-18 11:48:22 +08:00
commit c26fd3b190
1564 changed files with 214813 additions and 0 deletions
@@ -0,0 +1,63 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
values: {
type: 'json',
required: true,
},
actorUser: {
type: 'ref',
required: true,
},
request: {
type: 'ref',
},
},
async fn(inputs) {
const { values } = inputs;
const { project, projectManager } = await Project.qm.createOne(values, {
user: inputs.actorUser,
});
const scoper = sails.helpers.projects.makeScoper.with({
record: project,
});
scoper.projectManagerUserIds = [projectManager.userId];
const userIdsWithFullProjectVisibility = await scoper.getUserIdsWithFullProjectVisibility();
userIdsWithFullProjectVisibility.forEach((userId) => {
// TODO: send projectManager in included
sails.sockets.broadcast(
`user:${userId}`,
'projectCreate',
{
item: project,
},
inputs.request,
);
});
const webhooks = await Webhook.qm.getAll();
sails.helpers.utils.sendWebhooks.with({
webhooks,
event: Webhook.Events.PROJECT_CREATE,
buildData: () => ({
item: project,
}),
user: inputs.actorUser,
});
return {
project,
projectManager,
};
},
};
@@ -0,0 +1,68 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
record: {
type: 'ref',
required: true,
},
actorUser: {
type: 'ref',
required: true,
},
request: {
type: 'ref',
},
},
exits: {
mustNotHaveBoards: {},
},
async fn(inputs) {
const boardsTotal = await sails.helpers.projects.getBoardsTotalById(inputs.record.id);
if (boardsTotal > 0) {
throw 'mustNotHaveBoards';
}
const { projectManagers } = await sails.helpers.projects.deleteRelated(inputs.record);
const project = await Project.qm.deleteOne(inputs.record.id);
if (project) {
const scoper = sails.helpers.projects.makeScoper.with({
record: project,
});
scoper.projectManagerUserIds = sails.helpers.utils.mapRecords(projectManagers, 'userId');
const projectRelatedUserIds = await scoper.getProjectRelatedUserIds();
projectRelatedUserIds.forEach((userId) => {
sails.sockets.broadcast(
`user:${userId}`,
'projectDelete',
{
item: project,
},
inputs.request,
);
});
const webhooks = await Webhook.qm.getAll();
sails.helpers.utils.sendWebhooks.with({
webhooks,
event: Webhook.Events.PROJECT_DELETE,
buildData: () => ({
item: project,
}),
user: inputs.actorUser,
});
}
return project;
},
};
@@ -0,0 +1,52 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
recordOrRecords: {
type: 'ref',
required: true,
},
},
async fn(inputs) {
let projectIdOrIds;
if (_.isPlainObject(inputs.recordOrRecords)) {
({
recordOrRecords: { id: projectIdOrIds },
} = inputs);
} else if (_.every(inputs.recordOrRecords, _.isPlainObject)) {
projectIdOrIds = sails.helpers.utils.mapRecords(inputs.recordOrRecords);
}
await ProjectFavorite.qm.delete({
projectId: projectIdOrIds,
});
const projectManagers = await ProjectManager.qm.delete({
projectId: projectIdOrIds,
});
const { uploadedFiles } = await BackgroundImage.qm.delete({
projectId: projectIdOrIds,
});
sails.helpers.utils.removeUnreferencedUploadedFiles(uploadedFiles);
const baseCustomFieldGroups = await BaseCustomFieldGroup.qm.delete({
projectId: projectIdOrIds,
});
await sails.helpers.baseCustomFieldGroups.deleteRelated(baseCustomFieldGroups);
const boards = await Board.qm.delete({
projectId: projectIdOrIds,
});
await sails.helpers.boards.deleteRelated(boards);
return { projectManagers };
},
};
@@ -0,0 +1,19 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
id: {
type: 'string',
required: true,
},
},
async fn(inputs) {
const boards = await Board.qm.getByProjectId(inputs.id);
return sails.helpers.utils.mapRecords(boards);
},
};
@@ -0,0 +1,26 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
id: {
type: 'string',
required: true,
},
userId: {
type: 'string',
required: true,
},
},
async fn(inputs) {
const boardMemberships = await BoardMembership.qm.getByProjectIdAndUserId(
inputs.id,
inputs.userId,
);
return boardMemberships.length;
},
};
@@ -0,0 +1,19 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
id: {
type: 'string',
required: true,
},
},
async fn(inputs) {
const boards = await Board.qm.getByProjectId(inputs.id);
return boards.length;
},
};
@@ -0,0 +1,25 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
ids: {
type: 'json',
required: true,
},
},
async fn(inputs) {
const projectManagers = await ProjectManager.qm.getByProjectIds(inputs.ids);
const managerProjectIdsSet = new Set(
sails.helpers.utils.mapRecords(projectManagers, 'projectId', true),
);
const lonelyProjectIds = inputs.ids.filter((id) => !managerProjectIdsSet.has(id));
return Project.qm.getByIds(lonelyProjectIds);
},
};
@@ -0,0 +1,19 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
id: {
type: 'string',
required: true,
},
},
async fn(inputs) {
const projectManagers = await ProjectManager.qm.getByProjectId(inputs.id);
return sails.helpers.utils.mapRecords(projectManagers, 'userId');
},
};
@@ -0,0 +1,24 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
id: {
type: 'string',
required: true,
},
exceptProjectManagerIdOrIds: {
type: 'json',
},
},
async fn(inputs) {
const projectManagers = await ProjectManager.qm.getByProjectId(inputs.id, {
exceptIdOrIds: inputs.exceptProjectManagerIdOrIds,
});
return projectManagers.length;
},
};
@@ -0,0 +1,209 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
class Scoper {
constructor(project, board, { notificationService }) {
this.project = project;
this.board = board;
this.notificationService = notificationService;
this.adminUserIds = null;
this.projectManagerUserIds = null;
this.boardMemberships = null;
this.userIdsWithFullProjectVisibility = null;
this.boardMembershipsForWholeProject = null;
this.boardMemberUserIdsForWholeProject = null;
this.boardMemberUserIds = null;
this.projectRelatedUserIds = null;
this.boardRelatedUserIds = null;
this.notificationServiceRelatedUserIds = null;
}
replaceProject(project) {
if (this.project && project.id !== this.project.id) {
this.projectManagerUserIds = null;
this.boardMembershipsForWholeProject = null;
this.boardMemberUserIdsForWholeProject = null;
}
this.project = project;
this.userIdsWithFullProjectVisibility = null;
this.projectRelatedUserIds = null;
this.boardRelatedUserIds = null;
}
replaceBoard(board) {
if (this.board && board.id !== this.board.id) {
this.boardMemberships = null;
this.boardMemberUserIds = null;
this.boardRelatedUserIds = null;
}
this.board = board;
}
clone() {
return _.cloneDeep(this);
}
cloneForProject(project) {
const scoper = this.clone();
scoper.replaceProject(project);
return scoper;
}
cloneForBoard(board) {
const scoper = this.clone();
scoper.replaceBoard(board);
return scoper;
}
async getAdminUserIds() {
if (!this.adminUserIds) {
this.adminUserIds = await sails.helpers.users.getAllActiveIds(User.Roles.ADMIN);
}
return this.adminUserIds;
}
async getProjectManagerUserIds() {
if (!this.projectManagerUserIds) {
this.projectManagerUserIds = await sails.helpers.projects.getManagerUserIds(this.project.id);
}
return this.projectManagerUserIds;
}
async getBoardMemberships() {
if (!this.boardMemberships) {
this.boardMemberships = await BoardMembership.qm.getByBoardId(this.board.id);
}
return this.boardMemberships;
}
async getUserIdsWithFullProjectVisibility() {
if (!this.userIdsWithFullProjectVisibility) {
const projectManagerUserIds = await this.getProjectManagerUserIds();
if (this.project.ownerProjectManagerId) {
this.userIdsWithFullProjectVisibility = projectManagerUserIds;
} else {
const adminUserIds = await this.getAdminUserIds();
this.userIdsWithFullProjectVisibility = _.union(adminUserIds, projectManagerUserIds);
}
}
return this.userIdsWithFullProjectVisibility;
}
async getBoardMembershipsForWholeProject() {
if (!this.boardMembershipsForWholeProject) {
this.boardMembershipsForWholeProject = await BoardMembership.qm.getByProjectId(
this.project.id,
);
}
return this.boardMembershipsForWholeProject;
}
async getBoardMemberUserIdsForWholeProject() {
if (!this.boardMemberUserIdsForWholeProject) {
const boardMembershipsForWholeProject = await this.getBoardMembershipsForWholeProject();
this.boardMemberUserIdsForWholeProject = sails.helpers.utils.mapRecords(
boardMembershipsForWholeProject,
'userId',
true,
);
}
return this.boardMemberUserIdsForWholeProject;
}
async getBoardMemberUserIds() {
if (!this.boardMemberUserIds) {
const boardMemberships = await this.getBoardMemberships();
this.boardMemberUserIds = sails.helpers.utils.mapRecords(boardMemberships, 'userId');
}
return this.boardMemberUserIds;
}
async getProjectRelatedUserIds() {
if (!this.projectRelatedUserIds) {
const userIdsWithFullProjectVisibility = await this.getUserIdsWithFullProjectVisibility();
const boardMemberUserIdsForWholeProject = await this.getBoardMemberUserIdsForWholeProject();
this.projectRelatedUserIds = _.union(
userIdsWithFullProjectVisibility,
boardMemberUserIdsForWholeProject,
);
}
return this.projectRelatedUserIds;
}
async getBoardRelatedUserIds() {
if (!this.boardRelatedUserIds) {
const userIdsWithFullProjectVisibility = await this.getUserIdsWithFullProjectVisibility();
const boardMemberUserIds = await this.getBoardMemberUserIds();
this.boardRelatedUserIds = _.union(userIdsWithFullProjectVisibility, boardMemberUserIds);
}
return this.boardRelatedUserIds;
}
async getNotificationServiceRelatedUserIds() {
if (!this.notificationServiceRelatedUserIds) {
this.notificationServiceRelatedUserIds = await this.getProjectManagerUserIds();
}
return this.notificationServiceRelatedUserIds;
}
}
module.exports = {
sync: true,
inputs: {
record: {
type: 'ref',
required: true,
},
board: {
type: 'ref',
},
notificationService: {
type: 'ref',
},
},
exits: {
boardMustBePresent: {},
},
fn(inputs) {
if (inputs.notificationService && !inputs.board) {
throw 'boardMustBePresent';
}
return new Scoper(inputs.record, inputs.board, {
notificationService: inputs.notificationService,
});
},
};
@@ -0,0 +1,236 @@
/*!
* Copyright (c) 2024 PLANKA Software GmbH
* Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
*/
module.exports = {
inputs: {
record: {
type: 'ref',
required: true,
},
values: {
type: 'json',
required: true,
},
actorUser: {
type: 'ref',
required: true,
},
scoper: {
type: 'ref',
},
webhooks: {
type: 'ref',
},
request: {
type: 'ref',
},
},
exits: {
ownerProjectManagerInValuesMustBeLastManager: {},
backgroundImageInValuesMustBePresent: {},
backgroundGradientInValuesMustBePresent: {},
alreadyHasOwnerProjectManager: {},
},
// TODO: use normalizeValues
async fn(inputs) {
const { isFavorite, ...values } = inputs.values;
if (values.backgroundImage) {
values.backgroundImageId = values.backgroundImage.id;
}
if (values.ownerProjectManager) {
if (inputs.record.ownerProjectManagerId) {
if (values.ownerProjectManager.id === inputs.record.ownerProjectManagerId) {
delete values.ownerProjectManager;
} else {
throw 'alreadyHasOwnerProjectManager';
}
} else {
const projectManagersLeft = await sails.helpers.projects.getProjectManagersTotalById(
inputs.record.id,
values.ownerProjectManager.id,
);
if (projectManagersLeft > 0) {
throw 'ownerProjectManagerInValuesMustBeLastManager';
}
values.ownerProjectManagerId = values.ownerProjectManager.id;
}
}
const backgroundType = _.isUndefined(values.backgroundType)
? inputs.record.backgroundType
: values.backgroundType;
if (_.isNull(backgroundType)) {
Object.assign(values, {
backgroundImageId: null,
backgroundGradient: null,
});
} else if (backgroundType === Project.BackgroundTypes.GRADIENT) {
const backgroundGradient = _.isUndefined(values.backgroundGradient)
? inputs.record.backgroundGradient
: values.backgroundGradient;
if (!backgroundGradient) {
throw 'backgroundGradientInValuesMustBePresent';
}
values.backgroundImageId = null;
} else if (backgroundType === Project.BackgroundTypes.IMAGE) {
const backgroundImageId = _.isUndefined(values.backgroundImageId)
? inputs.record.backgroundImageId
: values.backgroundImageId;
if (!backgroundImageId) {
throw 'backgroundImageInValuesMustBePresent';
}
values.backgroundGradient = null;
}
let project;
if (_.isEmpty(values)) {
project = inputs.record;
} else {
project = await Project.qm.updateOne(inputs.record.id, values);
if (!project) {
return project;
}
const {
scoper = sails.helpers.projects.makeScoper.with({
record: project,
}),
} = inputs;
const projectRelatedUserIds = await scoper.getProjectRelatedUserIds();
if (values.ownerProjectManager) {
const boardIds = await sails.helpers.projects.getBoardIdsById(project.id);
const prevScoper = scoper.cloneForProject(inputs.record);
const adminUserIds = await prevScoper.getAdminUserIds();
const projectManagerUserIds = await prevScoper.getProjectManagerUserIds();
const boardMemberships = await prevScoper.getBoardMembershipsForWholeProject();
const nonProjectManagerAdminUserIds = _.difference(adminUserIds, projectManagerUserIds);
const boardMemberUserIdsByBoardId = boardMemberships.reduce(
(result, boardMembership) => ({
...result,
[boardMembership.boardId]: [
...(result[boardMembership.boardId] || []),
boardMembership.userId,
],
}),
{},
);
boardIds.forEach((boardId) => {
const missingUserIds = _.difference(
nonProjectManagerAdminUserIds,
boardMemberUserIdsByBoardId[boardId] || [],
);
missingUserIds.forEach((userId) => {
sails.sockets.removeRoomMembersFromRooms(`@user:${userId}`, `board:${boardId}`);
});
});
const projectRelatedUserIdsSet = new Set(projectRelatedUserIds);
const prevProjectRelatedUserIds = await prevScoper.getProjectRelatedUserIds();
const missingProjectRelatedUserIds = prevProjectRelatedUserIds.filter(
(userId) => !projectRelatedUserIdsSet.has(userId),
);
missingProjectRelatedUserIds.forEach((userId) => {
sails.sockets.broadcast(
`user:${userId}`,
'projectUpdate',
{
item: _.pick(project, ['id', 'ownerProjectManagerId']),
},
inputs.request,
);
});
}
projectRelatedUserIds.forEach((userId) => {
sails.sockets.broadcast(
`user:${userId}`,
'projectUpdate',
{
item: project,
},
inputs.request,
);
});
const { webhooks = await Webhook.qm.getAll() } = inputs;
sails.helpers.utils.sendWebhooks.with({
webhooks,
event: Webhook.Events.PROJECT_UPDATE,
buildData: () => ({
item: project,
}),
buildPrevData: () => ({
item: inputs.record,
}),
user: inputs.actorUser,
});
}
if (!_.isUndefined(isFavorite)) {
const wasFavorite = await sails.helpers.users.isProjectFavorite(
inputs.actorUser.id,
project.id,
);
if (isFavorite !== wasFavorite) {
if (isFavorite) {
try {
await ProjectFavorite.qm.createOne({
projectId: project.id,
userId: inputs.actorUser.id,
});
} catch (error) {
if (error.code !== 'E_UNIQUE') {
throw error;
}
}
} else {
await ProjectFavorite.qm.deleteOne({
projectId: project.id,
userId: inputs.actorUser.id,
});
}
sails.sockets.broadcast(
`user:${inputs.actorUser.id}`,
'projectUpdate',
{
item: {
isFavorite,
id: project.id,
},
},
inputs.request,
);
// TODO: send webhooks
}
}
return project;
},
};