@takaro/modules 0.0.15 → 0.0.19

package/src/modules/serverMessages/index.ts

@@ -1,39 +1,43 @@
-import { BuiltinModule, ICronJob } from '../../BuiltinModule.js';
+import { ModuleTransferDTO, ICronJob, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
 
-export class ServerMessages extends BuiltinModule<ServerMessages> {
+export class ServerMessages extends ModuleTransferDTO<ServerMessages> {
   constructor() {
-    super(
-      'serverMessages',
-      'Send automated, rotated, configurable messages to players on the server.',
-      JSON.stringify({
-        $schema: 'http://json-schema.org/draft-07/schema#',
-        type: 'object',
-        properties: {
-          messages: {
-            type: 'array',
-            title: 'Messages',
-            description: 'List of messages that will be sent to players on the server.',
-            default: [
-              // prettier-ignore
-              'This is an automated message, don\'t forget to read the server rules!',
-            ],
-            items: {
-              type: 'string',
-              minLength: 5,
-              maxLength: 1024,
+    super();
+
+    this.name = 'serverMessages';
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.1',
+        description: 'Send automated, rotated, configurable messages to players on the server.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
+            messages: {
+              type: 'array',
+              title: 'Messages',
+              description: 'List of messages that will be sent to players on the server.',
+              default: [
+                // prettier-ignore
+                'This is an automated message, don\'t forget to read the server rules!',
+              ],
+              items: {
+                type: 'string',
+                minLength: 5,
+                maxLength: 1024,
+              },
+              minItems: 1,
             },
-            minItems: 1,
           },
-        },
-        required: ['messages'],
-      }),
-    );
-
-    this.cronJobs = [
-      new ICronJob({
-        name: 'Automated message',
-        temporalValue: '*/30 * * * *',
-        function: this.loadFn('cronJobs', 'Automated message'),
+          required: ['messages'],
+        }),
+        cronJobs: [
+          new ICronJob({
+            name: 'Automated message',
+            temporalValue: '*/30 * * * *',
+            function: this.loadFn('cronJobs', 'Automated message'),
+          }),
+        ],
       }),
     ];
   }

package/src/modules/teleports/commands/deletewaypoint.js

@@ -1,56 +1,18 @@
 import { takaro, data, checkPermission, TakaroUserError } from '@takaro/helpers';
-
-function getWaypointName(name) {
-  return `waypoint ${name}`;
-}
+import { getWaypointName, waypointReconciler } from './utils.js';
 
 async function main() {
-  const { pog, gameServerId, arguments: args } = data;
+  const { pog, gameServerId, arguments: args, module: mod } = data;
 
   if (!checkPermission(pog, 'TELEPORTS_MANAGE_WAYPOINTS')) {
     throw new TakaroUserError('You do not have permission to manage waypoints.');
   }
 
-  async function ensureWaypointsModule() {
-    let waypointsDefinition = (
-      await takaro.module.moduleControllerSearch({
-        filters: {
-          name: ['Waypoints'],
-        },
-      })
-    ).data.data[0];
-
-    if (!waypointsDefinition) {
-      console.log('Waypoints module definition not found, creating it.');
-      waypointsDefinition = (
-        await takaro.module.moduleControllerCreate({
-          name: 'Waypoints',
-          description: 'Waypoints module for the teleport system.',
-        })
-      ).data.data;
-    }
-
-    let waypointsInstallation = (
-      await takaro.gameserver.gameServerControllerGetInstalledModules(gameServerId)
-    ).data.data.find((module) => module.name === 'Waypoints');
-
-    if (!waypointsInstallation) {
-      console.log('Waypoints module not found, installing it.');
-      waypointsInstallation = (
-        await takaro.gameserver.gameServerControllerInstallModule(gameServerId, waypointsDefinition.id)
-      ).data.data;
-    }
-
-    return { waypointsInstallation, waypointsDefinition };
-  }
-
-  const { waypointsInstallation } = await ensureWaypointsModule();
-
   const variable = await takaro.variable.variableControllerSearch({
     filters: {
       key: [getWaypointName(args.waypoint)],
       gameServerId: [gameServerId],
-      moduleId: [waypointsInstallation.moduleId],
+      moduleId: [mod.moduleId],
     },
   });
 
@@ -59,18 +21,7 @@ async function main() {
   }
 
   await takaro.variable.variableControllerDelete(variable.data.data[0].id);
-
-  const teleportCommand = await takaro.command.commandControllerSearch({
-    filters: {
-      moduleId: [waypointsInstallation.moduleId],
-      name: [`waypoint ${args.waypoint} server ${gameServerId}`],
-    },
-  });
-
-  if (teleportCommand.data.data.length) {
-    await takaro.command.commandControllerRemove(teleportCommand.data.data[0].id);
-  }
-
+  await waypointReconciler();
   await pog.pm(`Waypoint ${args.waypoint} deleted.`);
 }
 

package/src/modules/teleports/commands/listwaypoints.js

@@ -1,44 +1,12 @@
-import { takaro, data, checkPermission } from '@takaro/helpers';
+import { data, checkPermission } from '@takaro/helpers';
+import { ensureWaypointsModule } from './utils.js';
 
 async function main() {
   const { pog, gameServerId } = data;
 
-  async function ensureWaypointsModule() {
-    let waypointsDefinition = (
-      await takaro.module.moduleControllerSearch({
-        filters: {
-          name: ['Waypoints'],
-        },
-      })
-    ).data.data[0];
-
-    if (!waypointsDefinition) {
-      console.log('Waypoints module definition not found, creating it.');
-      waypointsDefinition = (
-        await takaro.module.moduleControllerCreate({
-          name: 'Waypoints',
-          description: 'Waypoints module for the teleport system.',
-        })
-      ).data.data;
-    }
-
-    let waypointsInstallation = (
-      await takaro.gameserver.gameServerControllerGetInstalledModules(gameServerId)
-    ).data.data.find((module) => module.name === 'Waypoints');
-
-    if (!waypointsInstallation) {
-      console.log('Waypoints module not found, installing it.');
-      waypointsInstallation = (
-        await takaro.gameserver.gameServerControllerInstallModule(gameServerId, waypointsDefinition.id)
-      ).data.data;
-    }
-
-    return { waypointsInstallation, waypointsDefinition };
-  }
-
   const { waypointsDefinition } = await ensureWaypointsModule();
 
-  const allWaypoints = waypointsDefinition.commands;
+  const allWaypoints = waypointsDefinition.latestVersion.commands;
 
   const waypointsWithPermission = allWaypoints
     .filter((waypoint) => checkPermission(pog, `WAYPOINTS_USE_${waypoint.trigger.toUpperCase()}_${gameServerId}`))

package/src/modules/teleports/commands/setwaypoint.js

@@ -1,54 +1,16 @@
 import { takaro, data, checkPermission, TakaroUserError } from '@takaro/helpers';
-
-function getWaypointName(name) {
-  return `waypoint ${name}`;
-}
+import { getWaypointName, waypointReconciler } from './utils.js';
 
 async function main() {
-  const { pog, gameServerId, module: mod, arguments: args } = data;
+  const { pog, gameServerId, arguments: args, module: mod } = data;
 
   if (!checkPermission(pog, 'TELEPORTS_MANAGE_WAYPOINTS')) {
     throw new TakaroUserError('You do not have permission to manage waypoints.');
   }
 
-  async function ensureWaypointsModule() {
-    let waypointsDefinition = (
-      await takaro.module.moduleControllerSearch({
-        filters: {
-          name: ['Waypoints'],
-        },
-      })
-    ).data.data[0];
-
-    if (!waypointsDefinition) {
-      console.log('Waypoints module definition not found, creating it.');
-      waypointsDefinition = (
-        await takaro.module.moduleControllerCreate({
-          name: 'Waypoints',
-          description: 'Waypoints module for the teleport system.',
-        })
-      ).data.data;
-    }
-
-    let waypointsInstallation = (
-      await takaro.gameserver.gameServerControllerGetInstalledModules(gameServerId)
-    ).data.data.find((module) => module.name === 'Waypoints');
-
-    if (!waypointsInstallation) {
-      console.log('Waypoints module not found, installing it.');
-      waypointsInstallation = (
-        await takaro.gameserver.gameServerControllerInstallModule(gameServerId, waypointsDefinition.id)
-      ).data.data;
-    }
-
-    return { waypointsInstallation, waypointsDefinition };
-  }
-
-  const { waypointsInstallation, waypointsDefinition } = await ensureWaypointsModule();
-
   try {
     await takaro.variable.variableControllerCreate({
-      moduleId: waypointsInstallation.moduleId,
+      moduleId: mod.moduleId,
       gameServerId,
       key: getWaypointName(args.waypoint),
       value: JSON.stringify({
@@ -61,50 +23,10 @@ async function main() {
     if (error.message === 'Request failed with status code 409') {
       throw new TakaroUserError(`Waypoint ${args.waypoint} already exists.`);
     }
+    throw error;
   }
 
-  const teleportCommand = await takaro.command.commandControllerSearch({
-    filters: {
-      moduleId: [mod.moduleId],
-      name: ['teleportwaypoint'],
-    },
-  });
-
-  await takaro.command.commandControllerCreate({
-    moduleId: waypointsInstallation.moduleId,
-    name: `waypoint ${args.waypoint} server ${gameServerId}`,
-    trigger: args.waypoint,
-    helpText: `Teleport to waypoint ${args.waypoint}.`,
-    function: teleportCommand.data.data[0].function.code,
-  });
-
-  const existingPermissions = waypointsDefinition.permissions || [];
-  const permissionInputDTOs = existingPermissions.map((permission) => ({
-    permission: permission.permission,
-    description: permission.description,
-    friendlyName: permission.friendlyName,
-    canHaveCount: permission.canHaveCount,
-  }));
-
-  const gameServer = (await takaro.gameserver.gameServerControllerGetOne(gameServerId)).data.data;
-
-  await takaro.module.moduleControllerUpdate(waypointsInstallation.moduleId, {
-    permissions: [
-      {
-        permission: `WAYPOINTS_USE_${args.waypoint.toUpperCase()}_${gameServerId}`,
-        description: `Use the waypoint ${args.waypoint} on ${gameServer.name}.`,
-        friendlyName: `Use waypoint ${args.waypoint} on ${gameServer.name}`,
-        canHaveCount: false,
-      },
-      ...permissionInputDTOs,
-    ],
-  });
-
-  // Need to reinstall the module to ensure the new commands systemconfig and permissions are properly in place
-  await takaro.gameserver.gameServerControllerInstallModule(gameServerId, waypointsInstallation.moduleId, {
-    systemConfig: JSON.stringify(waypointsInstallation.systemConfig),
-    userConfig: JSON.stringify(waypointsInstallation.userConfig),
-  });
+  await waypointReconciler();
 
   await pog.pm(`Waypoint ${args.waypoint} set.`);
 }

package/src/modules/teleports/commands/teleportwaypoint.js

@@ -7,7 +7,7 @@ function getWaypointName(name) {
 async function main() {
   const { pog, gameServerId, trigger, module, itemId } = data;
 
-  const triggeredCommand = module.module.commands.find((command) => command.id === itemId);
+  const triggeredCommand = module.version.commands.find((command) => command.id === itemId);
 
   if (!triggeredCommand) {
     throw new Error('Waypoint not found.');
@@ -22,46 +22,19 @@ async function main() {
     throw new TakaroUserError(`You are not allowed to use the waypoint ${trigger}.`);
   }
 
-  async function ensureWaypointsModule() {
-    let waypointsDefinition = (
-      await takaro.module.moduleControllerSearch({
-        filters: {
-          name: ['Waypoints'],
-        },
-      })
-    ).data.data[0];
-
-    if (!waypointsDefinition) {
-      console.log('Waypoints module definition not found, creating it.');
-      waypointsDefinition = (
-        await takaro.module.moduleControllerCreate({
-          name: 'Waypoints',
-          description: 'Waypoints module for the teleport system.',
-        })
-      ).data.data;
-    }
-
-    let waypointsInstallation = (
-      await takaro.gameserver.gameServerControllerGetInstalledModules(gameServerId)
-    ).data.data.find((module) => module.name === 'Waypoints');
-
-    if (!waypointsInstallation) {
-      console.log('Waypoints module not found, installing it.');
-      waypointsInstallation = (
-        await takaro.gameserver.gameServerControllerInstallModule(gameServerId, waypointsDefinition.id)
-      ).data.data;
-    }
-
-    return { waypointsInstallation, waypointsDefinition };
-  }
-
-  const { waypointsInstallation } = await ensureWaypointsModule();
+  const teleportsModule = (
+    await takaro.module.moduleControllerSearch({
+      filters: {
+        builtin: ['teleports'],
+      },
+    })
+  ).data.data[0];
 
   const variable = await takaro.variable.variableControllerSearch({
     filters: {
       key: [getWaypointName(trigger)],
       gameServerId: [gameServerId],
-      moduleId: [waypointsInstallation.moduleId],
+      moduleId: [teleportsModule.id],
     },
   });
 

package/src/modules/teleports/cronJobs/Waypoint reconciler.js

@@ -0,0 +1,7 @@
+import { waypointReconciler } from './utils.js';
+
+async function main() {
+  await waypointReconciler();
+}
+
+await main();

package/src/modules/teleports/functions/utils.js

@@ -34,3 +34,153 @@ export async function findTp(tpName, playerId, pub = false) {
     sortDirection: 'asc',
   });
 }
+
+export async function ensureWaypointsModule() {
+  const { gameServerId } = data;
+  let waypointsDefinition = (
+    await takaro.module.moduleControllerSearch({
+      filters: {
+        name: ['Waypoints'],
+      },
+    })
+  ).data.data[0];
+
+  if (!waypointsDefinition) {
+    console.log('Waypoints module definition not found, creating it.');
+    waypointsDefinition = (
+      await takaro.module.moduleControllerCreate({
+        name: 'Waypoints',
+      })
+    ).data.data;
+  }
+
+  let waypointsInstallation = (
+    await takaro.module.moduleInstallationsControllerGetInstalledModules({
+      filters: { gameserverId: [gameServerId] },
+    })
+  ).data.data.find((module) => module.module.name === 'Waypoints');
+
+  if (!waypointsInstallation) {
+    console.log('Waypoints installation not found, installing it.');
+    waypointsInstallation = (
+      await takaro.module.moduleInstallationsControllerInstallModule({
+        gameServerId,
+        versionId: waypointsDefinition.latestVersion.id,
+      })
+    ).data.data;
+  }
+
+  return { waypointsInstallation, waypointsDefinition };
+}
+
+export function getWaypointName(name) {
+  return `waypoint ${name}`;
+}
+
+export function getWaypointId(varName) {
+  const split = varName.split(' ')[1];
+  if (split) return split;
+  return varName;
+}
+
+/**
+ * This function is responsible to read all the configured waypoints (vars)
+ * and then ensuring that the waypoints module has the correct config
+ */
+export async function waypointReconciler() {
+  console.log('Reconciling waypoints');
+  const { waypointsInstallation, waypointsDefinition } = await ensureWaypointsModule();
+  const { gameServerId, module: mod } = data;
+
+  // Get all the installed waypoints
+  const waypointVars = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        moduleId: [mod.moduleId],
+        gameServerId: [gameServerId],
+      },
+    })
+  ).data.data;
+
+  const waypointsInModule = waypointsDefinition.latestVersion.commands;
+
+  // Check if any waypoints are missing in module
+  const missingWaypoints = waypointVars.filter((waypointVar) => {
+    const existingWaypointsForServer = waypointsInModule.filter((waypoint) => waypoint.name.includes(gameServerId));
+    return !existingWaypointsForServer.some((waypoint) => waypoint.trigger === getWaypointId(waypointVar.key));
+  });
+
+  // Check if there are waypoints too many in module compared to our vars
+  const toDeleteWaypoints = waypointsInModule.filter((waypoint) => {
+    // We ignore any commands that are not for this game server
+    if (!waypoint.name.includes(gameServerId)) return false;
+    return !waypointVars.some((waypointVar) => getWaypointId(waypointVar.key) === waypoint.trigger);
+  });
+
+  if (!missingWaypoints.length && !toDeleteWaypoints.length) {
+    // No changes in waypoints, exit
+    return;
+  }
+
+  console.log(
+    'Missing waypoints:',
+    missingWaypoints.map((waypoint) => waypoint.key),
+  );
+  console.log(
+    'To delete waypoints:',
+    toDeleteWaypoints.map((waypoint) => waypoint.trigger),
+  );
+
+  // Fetch the teleporting code template
+  const teleportCommand = await takaro.command.commandControllerSearch({
+    filters: {
+      moduleId: [mod.moduleId],
+      name: ['teleportwaypoint'],
+    },
+  });
+
+  // Edit the module accordingly
+  await Promise.all([
+    ...missingWaypoints.map((waypoint) => {
+      return takaro.command.commandControllerCreate({
+        name: `waypoint ${getWaypointId(waypoint.key)} server ${gameServerId}`,
+        trigger: getWaypointId(waypoint.key),
+        helpText: `Teleport to waypoint ${getWaypointId(waypoint.key)}.`,
+        function: teleportCommand.data.data[0].function.code,
+        versionId: waypointsInstallation.versionId,
+      });
+    }),
+    ...toDeleteWaypoints.map((waypointVar) => {
+      return takaro.command.commandControllerRemove(waypointVar.id);
+    }),
+  ]);
+
+  // Update permissions
+  const existingPermissions = waypointsDefinition.latestVersion.permissions || [];
+  const permissionInputDTOs = existingPermissions.map((permission) => ({
+    permission: permission.permission,
+    description: permission.description,
+    friendlyName: permission.friendlyName,
+    canHaveCount: permission.canHaveCount,
+  }));
+  // We need to filter out the permissions we deleted in the above lines
+  const filteredPermissionsInputs = permissionInputDTOs.filter((permission) => {
+    return !toDeleteWaypoints.some(
+      (waypoint) => permission.permission === `WAYPOINTS_USE_${waypoint.trigger.toUpperCase()}_${gameServerId}`,
+    );
+  });
+  const gameServer = (await takaro.gameserver.gameServerControllerGetOne(gameServerId)).data.data;
+  await takaro.module.moduleControllerUpdate(waypointsInstallation.moduleId, {
+    latestVersion: {
+      permissions: [
+        ...filteredPermissionsInputs,
+        ...missingWaypoints.map((waypoint) => ({
+          permission: `WAYPOINTS_USE_${getWaypointId(waypoint.key).toUpperCase()}_${gameServerId}`,
+          description: `Use the waypoint ${getWaypointId(waypoint.key)} on ${gameServer.name}.`,
+          friendlyName: `Use waypoint ${getWaypointId(waypoint.key)} on ${gameServer.name}`,
+          canHaveCount: false,
+        })),
+      ],
+    },
+  });
+}