forked from OpenWF/SpaceNinjaServer
98 lines
3.3 KiB
TypeScript
98 lines
3.3 KiB
TypeScript
import { RequestHandler } from "express";
|
|
import { getDojoClient, getGuildForRequestEx, hasAccessToDojo, hasGuildPermission } from "@/src/services/guildService";
|
|
import { logger } from "@/src/utils/logger";
|
|
import { GuildPermission, IDojoComponentDatabase } from "@/src/types/guildTypes";
|
|
import { Types } from "mongoose";
|
|
import { getAccountIdForRequest } from "@/src/services/loginService";
|
|
import { getInventory } from "@/src/services/inventoryService";
|
|
|
|
export const changeDojoRootController: RequestHandler = async (req, res) => {
|
|
const accountId = await getAccountIdForRequest(req);
|
|
const inventory = await getInventory(accountId, "GuildId LevelKeys");
|
|
const guild = await getGuildForRequestEx(req, inventory);
|
|
if (!hasAccessToDojo(inventory) || !(await hasGuildPermission(guild, accountId, GuildPermission.Architect))) {
|
|
res.json({ DojoRequestStatus: -1 });
|
|
return;
|
|
}
|
|
|
|
const idToNode: Record<string, INode> = {};
|
|
guild.DojoComponents.forEach(x => {
|
|
idToNode[x._id.toString()] = {
|
|
component: x,
|
|
parent: undefined,
|
|
children: []
|
|
};
|
|
});
|
|
|
|
let oldRoot: INode | undefined;
|
|
guild.DojoComponents.forEach(x => {
|
|
const node = idToNode[x._id.toString()];
|
|
if (x.pi) {
|
|
idToNode[x.pi.toString()].children.push(node);
|
|
node.parent = idToNode[x.pi.toString()];
|
|
} else {
|
|
oldRoot = node;
|
|
}
|
|
});
|
|
logger.debug("Old tree:\n" + treeToString(oldRoot!));
|
|
|
|
const newRoot = idToNode[req.query.newRoot as string];
|
|
recursivelyTurnParentsIntoChildren(newRoot);
|
|
newRoot.component.pi = undefined;
|
|
newRoot.component.op = undefined;
|
|
newRoot.component.pp = undefined;
|
|
newRoot.parent = undefined;
|
|
|
|
// Don't even ask me why this is needed because I don't know either
|
|
const stack: INode[] = [newRoot];
|
|
let i = 0;
|
|
const idMap: Record<string, Types.ObjectId> = {};
|
|
while (stack.length != 0) {
|
|
const top = stack.shift()!;
|
|
idMap[top.component._id.toString()] = new Types.ObjectId(
|
|
(++i).toString(16).padStart(8, "0") + top.component._id.toString().substr(8)
|
|
);
|
|
top.children.forEach(x => stack.push(x));
|
|
}
|
|
guild.DojoComponents.forEach(x => {
|
|
x._id = idMap[x._id.toString()];
|
|
if (x.pi) {
|
|
x.pi = idMap[x.pi.toString()];
|
|
}
|
|
});
|
|
|
|
logger.debug("New tree:\n" + treeToString(newRoot));
|
|
|
|
await guild.save();
|
|
|
|
res.json(await getDojoClient(guild, 0));
|
|
};
|
|
|
|
interface INode {
|
|
component: IDojoComponentDatabase;
|
|
parent: INode | undefined;
|
|
children: INode[];
|
|
}
|
|
|
|
const treeToString = (root: INode, depth: number = 0): string => {
|
|
let str = " ".repeat(depth * 4) + root.component.pf + " (" + root.component._id.toString() + ")\n";
|
|
root.children.forEach(x => {
|
|
str += treeToString(x, depth + 1);
|
|
});
|
|
return str;
|
|
};
|
|
|
|
const recursivelyTurnParentsIntoChildren = (node: INode): void => {
|
|
if (node.parent!.parent) {
|
|
recursivelyTurnParentsIntoChildren(node.parent!);
|
|
}
|
|
|
|
node.parent!.component.pi = node.component._id;
|
|
node.parent!.component.op = node.component.pp;
|
|
node.parent!.component.pp = node.component.op;
|
|
|
|
node.parent!.parent = node;
|
|
node.parent!.children.splice(node.parent!.children.indexOf(node), 1);
|
|
node.children.push(node.parent!);
|
|
};
|