Files
wekan/server/versionControlView.js
T
Lauri Ojansivu 5f3b211b37 New issue and REST linked card: one "created" activity, not two.
A card inserted through the Cards collection gets its "created" activity
from Cards.after.insert. Two paths inserted through the collection AND
called cardCreation() themselves:

- Board View / Version Control, New issue (vcsCreateIssue), and
- POST /api/boards/:boardId/lists/:listId/cards with linkedId
  (createLinkedCardFor).

Each such card got two "created" activities, and every watcher two
notifications and two emails. The other explicit callers - REST create,
bulk create, email view, email to card - insert with Cards.direct, where
no hook runs, and are right to record it themselves.

Both extra calls are removed. Outside a method (a REST route, a server
job) the hook has no user, so the REST linked card's activity would have
lost its author: the hook now falls back to the card's own userId, which
createLinkedCardFor sets to the session user. Activities never exclude
their actor from notifications, so the fallback only names an author
where there was none, such as a recurring card's next copy.

tests/noDoubleCreateActivity.test.cjs walks server/ and models/ and fails
on any explicit cardCreation that follows a hooked insert. The
GHSA-6jr3-42jf-vhm5 guard in restApiIdorBatch now pins the linked card's
attribution through createLinkedCardFor and the hook. From the reporter's
patch.

Thanks to Raymond-Voogt and xet7 !

Fixes #6823.
2026-10-27 21:14:23 +02:00

99 lines
4.5 KiB
JavaScript

// Board View / Version Control: the board as a GitHub / Gitea issue tracker
// (client/components/boards/versionControlView.*,
// docs/Features/Board-Header/Board-Views/Version-Control-View.md). Reading needs nothing new -
// the cards, labels, comments and attachments are the board's own, already
// published to whoever can see the board. Only two writes need the server:
//
// vcsCreateIssue New issue: a card in the board's open list
// vcsSetIssueState Close / Reopen: the card moves to the closed / open list
//
// Both write through the ordinary collections, not `.direct`, so the change
// history hooks (server/models/changeHistoryHooks.js) record them and the
// History tab - the board's history table - can undo them like any other move.
import { Meteor } from 'meteor/meteor';
import { check, Match } from 'meteor/check';
import { ReactiveCache } from '/imports/reactiveCache';
import Cards from '/models/cards';
import Lists from '/models/lists';
import { allowIsBoardMemberWithWriteAccess } from '/server/lib/utils';
import { canEditCardOrLinkedCard } from '/server/lib/linkedCardPermission';
const { cleanNewIssue, stateTarget, isSyncedIssue } = require('/models/lib/versionControlView');
async function writableBoard(userId, boardId) {
const board = await ReactiveCache.getBoard(boardId);
if (!userId || !board || !allowIsBoardMemberWithWriteAccess(userId, board)) throw new Meteor.Error('not-authorized');
return board;
}
// The list a state lives in, made when the board has none (a board that was
// not imported from a tracker has no "Closed" list until an issue is closed).
async function listFor(board, state) {
const lists = await ReactiveCache.getLists({ boardId: board._id, archived: false }, { sort: { sort: 1 } });
const target = stateTarget(lists || [], state);
if (target.listId) return target.listId;
const last = (lists || []).reduce((max, l) => Math.max(max, Number(l.sort) || 0), -1);
return Lists.insertAsync({
title: target.create, boardId: board._id, sort: last + 1, archived: false, createdAt: new Date(),
});
}
Meteor.methods({
async vcsCreateIssue(boardId, input) {
check(boardId, String);
check(input, { title: String, body: Match.Optional(String), labelIds: Match.Optional([String]) });
const userId = this.userId;
const board = await writableBoard(userId, boardId);
let issue;
try {
issue = cleanNewIssue(input);
} catch (e) {
throw new Meteor.Error(e.message);
}
const known = new Set((board.labels || []).map(l => l._id));
const listId = await listFor(board, 'open');
const swimlane = await board.getDefaultSwimlineAsync();
if (!listId || !swimlane) throw new Meteor.Error('vcs-no-list');
const siblings = await ReactiveCache.getCards({ boardId: board._id, listId, archived: false });
const cardId = await Cards.insertAsync({
title: issue.title,
description: issue.body,
boardId: board._id,
listId,
swimlaneId: swimlane._id,
userId,
labelIds: issue.labelIds.filter(id => known.has(id)),
sort: (siblings || []).length,
cardNumber: await board.getNextCardNumber(),
});
// The "created" activity comes from Cards.after.insert (server/models/
// cards.js), as for any card inserted through the collection. Recording
// it here as well gave every new issue two, and its watchers two
// notifications (#6823).
return { cardId };
},
async vcsSetIssueState(cardId, state) {
check(cardId, String);
check(state, Match.OneOf('open', 'closed'));
const userId = this.userId;
const card = await ReactiveCache.getCard(cardId);
if (!card) throw new Meteor.Error('not-found');
const board = await writableBoard(userId, card.boardId);
// Closing an issue moves its card: only a card the caller may edit, which
// for an assigned-only member is their own (GHSA-r4gm-mjj9-g3x8).
if (!(await canEditCardOrLinkedCard(userId, card, board))) throw new Meteor.Error('not-authorized');
// A synced issue is closed and reopened in its tracker, and the next sync
// brings the state: moving the card out of its synced list would make
// the sync see the issue as gone.
if (isSyncedIssue(card)) throw new Meteor.Error('vcs-synced-issue');
// An archived card is a closed issue; reopening it restores it.
if (state === 'open' && card.archived) await card.restore();
const listId = await listFor(board, state);
if (listId && listId !== card.listId) {
await Cards.updateAsync(card._id, { $set: { listId, dateLastActivity: new Date() } });
}
return { listId };
},
});