")
.append($("
").text('This will delete the following notes and their sub-notes: '))
.append($nodeTitles)
.append($deleteClonesCheckbox);
const confirmDialog = await import('../dialogs/confirm.js');
if (!await confirmDialog.confirm($confirmText)) {
return false;
}
const deleteClones = $deleteClonesCheckbox.find("input").is(":checked");
const taskId = utils.randomString(10);
for (const node of nodes) {
if (deleteClones) {
await server.remove('notes/' + node.data.noteId + '?taskId=' + taskId);
noteDetailService.noteDeleted(node.data.noteId);
}
else {
const {noteDeleted} = await server.remove('branches/' + node.data.branchId + '?taskId=' + taskId);
if (noteDeleted) {
noteDetailService.noteDeleted(node.data.noteId);
}
}
}
if (deleteClones) {
// if clones are also deleted we give up with targeted cleanup of the tree
treeService.reload();
return true;
}
// following code assumes that nodes contain only top-most selected nodes - getSelectedNodes has been
// called with stopOnParent=true
let next = nodes[nodes.length - 1].getNextSibling();
if (!next) {
next = nodes[0].getPrevSibling();
}
if (!next && !await hoistedNoteService.isRootNode(nodes[0])) {
next = nodes[0].getParent();
}
let activeNotePath = null;
if (next) {
activeNotePath = await treeUtils.getNotePath(next);
}
await treeService.loadTreeCache();
const parentNoteIds = Array.from(new Set(nodes.map(node => node.getParent().data.noteId)));
for (const node of nodes) {
node.remove();
}
for (const parentNoteId of parentNoteIds) {
await treeService.reloadNote(parentNoteId);
}
// activate after all the reloading
if (activeNotePath) {
treeService.focusTree();
const node = await treeService.activateNote(activeNotePath);
node.setFocus(true);
}
infoService.showMessage("Note(s) has been deleted.");
return true;
}
async function moveNodeUpInHierarchy(node) {
if (await hoistedNoteService.isRootNode(node) || await hoistedNoteService.isTopLevelNode(node)) {
return;
}
const resp = await server.put('branches/' + node.data.branchId + '/move-after/' + node.getParent().data.branchId);
if (!resp.success) {
alert(resp.message);
return;
}
if (!hoistedNoteService.isTopLevelNode(node) && node.getParent().getChildren().length <= 1) {
node.getParent().folder = false;
node.getParent().renderTitle();
}
await changeNode(
node => node.moveTo(node.getParent(), 'after'),
node);
}
async function changeNode(func, node, beforeNoteId = null, afterNoteId = null) {
utils.assertArguments(func, node);
const childNoteId = node.data.noteId;
const thisOldParentNode = node.getParent();
// this will move the node the user is directly operating on to the desired location
// note that there might be other instances of this note in the tree and those are updated through
// force reloading. We could simplify our lives by just reloading this one as well, but that leads
// to flickering and not good user experience. Current solution leads to no-flicker experience in most
// cases (since cloning is not used that often) and correct for multi-clone use cases
await func(node);
const thisNewParentNode = node.getParent();
node.data.parentNoteId = thisNewParentNode.data.noteId;
await treeCache.moveNote(childNoteId, thisOldParentNode.data.noteId, thisNewParentNode.data.noteId, beforeNoteId, afterNoteId);
await treeService.checkFolderStatus(thisOldParentNode);
await treeService.checkFolderStatus(thisNewParentNode);
if (!thisNewParentNode.isExpanded()) {
// this expands the note in case it become the folder only after the move
await thisNewParentNode.setExpanded(true);
}
for (const newParentNode of treeService.getNodesByNoteId(thisNewParentNode.data.noteId)) {
if (newParentNode.key === thisNewParentNode.key) {
// this one has been handled above specifically
continue;
}
newParentNode.load(true); // force reload to show up new note
await treeService.checkFolderStatus(newParentNode);
}
for (const oldParentNode of treeService.getNodesByNoteId(thisOldParentNode.data.noteId)) {
if (oldParentNode.key === thisOldParentNode.key) {
// this one has been handled above specifically
continue;
}
await oldParentNode.load(true); // force reload to show up new note
await treeService.checkFolderStatus(oldParentNode);
}
}
async function filterRootNote(nodes) {
const hoistedNoteId = await hoistedNoteService.getHoistedNoteId();
return nodes.filter(node =>
node.data.noteId !== 'root'
&& node.data.noteId !== hoistedNoteId);
}
function makeToast(id, message) {
return {
id: id,
title: "Delete status",
message: message,
icon: "trash"
};
}
ws.subscribeToMessages(async message => {
if (message.taskType !== 'delete-notes') {
return;
}
if (message.type === 'task-error') {
infoService.closePersistent(message.taskId);
infoService.showError(message.message);
} else if (message.type === 'task-progress-count') {
infoService.showPersistent(makeToast(message.taskId, "Delete notes in progress: " + message.progressCount));
} else if (message.type === 'task-succeeded') {
const toast = makeToast(message.taskId, "Delete finished successfully.");
toast.closeAfter = 5000;
infoService.showPersistent(toast);
}
});
export default {
moveBeforeNode,
moveAfterNode,
moveToNode,
deleteNodes,
moveNodeUpInHierarchy
};