@takaro/modules 0.0.0-next.0da151e

package/src/modules/timedShutdown/cronJobs/Shutdown.js

@@ -0,0 +1,8 @@
+import { data, takaro } from '@takaro/helpers';
+
+async function main() {
+  const { gameServerId } = data;
+  await takaro.gameserver.gameServerControllerShutdown(gameServerId);
+}
+
+await main();

package/src/modules/timedShutdown/cronJobs/warning.js

@@ -0,0 +1,13 @@
+import { data, takaro } from '@takaro/helpers';
+
+async function main() {
+  const { gameServerId } = data;
+
+  const msg = data.module.userConfig.warningMessage;
+
+  await takaro.gameserver.gameServerControllerSendMessage(gameServerId, {
+    message: msg,
+  });
+}
+
+await main();

package/src/modules/timedShutdown/index.ts

@@ -0,0 +1,45 @@
+import { ModuleTransferDTO, ICronJob, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
+
+export class TimedShutdown extends ModuleTransferDTO<TimedShutdown> {
+  constructor() {
+    super();
+
+    this.name = 'timedShutdown';
+    this.author = 'Takaro';
+    this.supportedGames = ['all'];
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.1',
+        description: 'Automatically shut down the server at a specific time.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
+            warningMessage: {
+              type: 'string',
+              title: 'Warning message',
+              description: 'Message to send to players before the server shuts down.',
+              default: 'Server is shutting down in 5 minutes!',
+              minLength: 1,
+              maxLength: 1024,
+            },
+          },
+          required: ['warningMessage'],
+        }),
+
+        cronJobs: [
+          new ICronJob({
+            name: 'Shutdown',
+            temporalValue: '30 3 * * *',
+            function: this.loadFn('cronJobs', 'Shutdown'),
+          }),
+          new ICronJob({
+            name: 'warning',
+            temporalValue: '25 3 * * *',
+            function: this.loadFn('cronJobs', 'warning'),
+          }),
+        ],
+      }),
+    ];
+  }
+}

package/src/modules/utils/commands/help.js

@@ -0,0 +1,100 @@
+import { data, takaro, TakaroUserError, checkPermission } from '@takaro/helpers';
+async function main() {
+  const enabledModules = await takaro.module.moduleInstallationsControllerGetInstalledModules({
+    filters: { gameserverId: [data.gameServerId] },
+  });
+
+  const moduleCommands = await Promise.all(
+    enabledModules.data.data.map(async (mod) => {
+      // Check if the module itself is enabled
+      if (!mod.systemConfig.enabled) {
+        return [];
+      }
+
+      const installedVersion = await takaro.module.moduleVersionControllerGetModuleVersion(mod.versionId);
+      const commands = installedVersion.data.data.commands;
+
+      // Filter out disabled commands
+      return commands.filter((command) => {
+        const commandConfig = mod.systemConfig.commands && mod.systemConfig.commands[command.name];
+        return commandConfig && commandConfig.enabled;
+      });
+    }),
+  );
+  const allCommandsFlat = moduleCommands.flat();
+
+  // Filter commands based on player permissions
+  const accessibleCommands = allCommandsFlat.filter((command) => {
+    // If command has no required permissions, it's accessible to all
+    if (!command.requiredPermissions || command.requiredPermissions.length === 0) {
+      return true;
+    }
+
+    // Check if player has all required permissions
+    return command.requiredPermissions.every((permission) => checkPermission(data.pog, permission));
+  });
+
+  if (data.arguments.command === 'search') {
+    // Check if a search term was actually provided (not the default 'none')
+    if (data.arguments.searchTerm === 'none') {
+      throw new TakaroUserError('Please provide a search term. Usage: /help search <term>');
+    }
+
+    // Search functionality
+    const searchTerm = data.arguments.searchTerm.toLowerCase();
+    const matchingCommands = accessibleCommands.filter((command) => {
+      // Check if command name contains search term
+      const nameMatch = command.name.toLowerCase().includes(searchTerm);
+      // Check if help text contains search term
+      const helpTextMatch = command.helpText.toLowerCase().includes(searchTerm);
+      return nameMatch || helpTextMatch;
+    });
+
+    if (matchingCommands.length === 0) {
+      await data.player.pm(`No commands found matching "${data.arguments.searchTerm}".`);
+    } else {
+      await data.player.pm(`Commands matching "${data.arguments.searchTerm}":`);
+      await Promise.all(
+        matchingCommands.map(async (command) => {
+          await data.player.pm(`${command.name}: ${command.helpText}`);
+        }),
+      );
+    }
+  } else if (data.arguments.command === 'all') {
+    await data.player.pm('Available commands:');
+
+    if (accessibleCommands.length === 0) {
+      await data.player.pm('No commands available to you.');
+    } else {
+      await Promise.all(
+        accessibleCommands.map(async (command) => {
+          await data.player.pm(`${command.name}: ${command.helpText}`);
+        }),
+      );
+    }
+  } else {
+    const requestedCommand = allCommandsFlat.find((c) => {
+      return c.name === data.arguments.command;
+    });
+
+    if (!requestedCommand) {
+      throw new TakaroUserError(
+        `Unknown command "${data.arguments.command}", use this command without arguments to see all available commands.`,
+      );
+    } else {
+      // Check if player has permission to use this command
+      const hasAccess =
+        !requestedCommand.requiredPermissions ||
+        requestedCommand.requiredPermissions.length === 0 ||
+        requestedCommand.requiredPermissions.every((permission) => checkPermission(data.pog, permission));
+
+      if (!hasAccess) {
+        throw new TakaroUserError(`You don't have permission to use the "${data.arguments.command}" command.`);
+      }
+
+      await data.player.pm(`${requestedCommand.name}: ${requestedCommand.helpText}`);
+    }
+  }
+}
+
+await main();

package/src/modules/utils/commands/ping.js

@@ -0,0 +1,7 @@
+import { data } from '@takaro/helpers';
+
+async function main() {
+  await data.player.pm('Pong!');
+}
+
+await main();

package/src/modules/utils/index.ts

@@ -0,0 +1,53 @@
+import { ModuleTransferDTO, ICommand, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
+
+export class Utils extends ModuleTransferDTO<Utils> {
+  constructor() {
+    super();
+
+    this.name = 'utils';
+    this.author = 'Takaro';
+    this.supportedGames = ['all'];
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.2',
+        description: 'A collection of useful commands',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          additionalProperties: false,
+        }),
+        commands: [
+          new ICommand({
+            function: this.loadFn('commands', 'ping'),
+            name: 'ping',
+            trigger: 'ping',
+            helpText: 'Replies with pong, useful for testing if the connection works.',
+            arguments: [],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'help'),
+            name: 'help',
+            trigger: 'help',
+            helpText: 'The text you are reading right now, displays information about commands.',
+            arguments: [
+              {
+                name: 'command',
+                type: 'string',
+                defaultValue: 'all',
+                helpText: 'The command to get help for, or "search" to search for commands',
+                position: 0,
+              },
+              {
+                name: 'searchTerm',
+                type: 'string',
+                defaultValue: 'none',
+                helpText: 'Search term to find commands (when first argument is "search")',
+                position: 1,
+              },
+            ],
+          }),
+        ],
+      }),
+    ];
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "dist",
+    "allowJs": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "allowJs": true
+  },
+  "include": ["src/**/*"]
+}

package/typedoc.json

@@ -0,0 +1,3 @@
+{
+  "entryPoints": ["src/main.ts"]
+}