copy from ttt bot

server/MuteHandler.ts

@@ -0,0 +1,25 @@
+import RegistrationHandler from "./RegistrationHandler"
+
+export default class MuteHandler {
+	public mute(player: string): boolean {
+		const register = RegistrationHandler.Instance
+		const binding = register.getNameRegisteredForSteamUser(player)
+		console.log(`Performing mute wizardry on ${player}, ${JSON.stringify(binding)}`)
+
+
+		return true
+	}
+	public unmute(player: string): boolean {
+		const register = RegistrationHandler.Instance
+		const binding = register.getNameRegisteredForSteamUser(player)
+		console.log(`Performing unmute wizardry on ${player}`)
+		return true
+	}
+	public unmuteAll(): boolean {
+		const register = RegistrationHandler.Instance
+		const binding = register.getAllMappings()
+
+		console.log(`Performing unmute wizardry on all players`)
+		return true
+	}
+}

server/RegistrationHandler.ts

@@ -0,0 +1,55 @@
+import { GuildMember } from "discord.js"
+import { Maybe, userNameBinding } from "./interfaces"
+
+export default class RegistrationHandler {
+	private userRegister: userNameBinding[] = []
+	private static _instance: RegistrationHandler
+	public constructor() {
+		console.log('Setup RegistrationHandler')
+	}
+	public static get Instance() {
+		return this._instance || (this._instance = new this())
+	}
+
+	public register(discordUser: GuildMember, steamname: string): boolean {
+		try {
+
+			const binding: userNameBinding = {
+				Steam: steamname,
+				DiscordUser: discordUser
+			}
+			console.log(`Trying to register ${JSON.stringify(binding)}`)
+			let alreadyPresentBinding = this.userRegister.find(x => x.DiscordUser.user.username == binding.DiscordUser.user.username)
+			if (alreadyPresentBinding) {
+				console.log(`Binding already present: ${JSON.stringify(alreadyPresentBinding)}, overwriting.`)
+				alreadyPresentBinding = binding
+			}
+			else {
+				this.userRegister.push(binding)
+				console.log(`Binding successfully added.`)
+			}
+		} catch (error) {
+			console.error(error)
+			return false
+		}
+		return true
+	}
+	public getAllMappings(): userNameBinding[] {
+		return this.userRegister
+	}
+	public removeUser(discordUser: GuildMember): void {
+		this.userRegister = this.userRegister.filter(x => x.DiscordUser.user.id !== discordUser.user.id)
+	}
+	public getNameRegisteredForDiscordUser(discordUser: GuildMember): Maybe<userNameBinding> {
+		return this.userRegister.find(x => x.DiscordUser.user.id == discordUser.user.id)
+	}
+	public getNameRegisteredForSteamUser(steamUser: string): Maybe<userNameBinding> {
+		return this.userRegister.find(x => x.Steam == steamUser)
+	}
+	public listRegisteredMembers(): string {
+		const output = this.userRegister.map(x => `${x.DiscordUser.user.username} : ${x.Steam}\n`)
+		return output.join()
+	}
+	private printHelpText(): string { return "" }
+	private buildHelpText(): string { return "" }
+}

server/configuration.ts

@@ -0,0 +1,27 @@
+import dotenv from "dotenv"
+dotenv.config()
+
+export const config = {
+	server: {
+		bodyParser: {
+			urlEncodedOptions: {
+				inflate: true,
+				limit: '5mb',
+				type: 'application/x-www-form-urlencoded',
+				extended: true,
+				parameterLimit: 1000
+			},
+			jsonOptions: {
+				inflate: true,
+				limit: '5mb',
+				type: 'application/json',
+				strict: true
+			}
+		}
+	},
+	debug: true,
+	port: 1234,
+	token: process.env.BOT_TOKEN ?? "",
+	guild_id: process.env.GUILD_ID ?? "",
+	client_id: process.env.CLIENT_ID ?? ""
+}

server/constants.ts

@@ -0,0 +1,52 @@
+import { localized_string } from "./interfaces"
+
+export const reactions = {
+	troll_grin: "U+1F92A",
+	angry_face: "U+1F621",
+	ok: "U+1F44C"
+}
+export const commands = {
+	LIST_COMMAND: "list",
+	REGISTER_COMMAND: "register",
+	REMOVE_COMMAND: "remove",
+	SHOW_FOR_STEAM_COMMAND: "forsteam",
+	SHOW_COMMAND: "show"
+}
+export const msg_strings: localized_string = {
+	greeting: {
+		german: "Ich wurde neugestartet. Bitte registriert euch erneut, falls ihr automatisch gemutet werden wollt :)",
+		english: "I have been restarted. Please register again if you want to be muted automatically :)"
+	},
+	fmt_registered_user: {
+		german: "Habe den Steamname {steam_name} mit dem Discordnamen {discord_name} verknüpft.",
+		english: "Registered the steam name {steam_name} for the discord name {discord_name}."
+	},
+	fmt_registered_for_steam: {
+		german: "Aktuell registriert für User {steam_name}: {discord_name}",
+		english: "Currently registered for user {steam_name}: {discord_name}"
+	},
+	fmt_registered_for_discord: {
+		german: "Aktuell registriert für User {discord_name}: {steam_name}",
+		english: "Currently registered for user {discord_name}: {steam_name}"
+	},
+	user_was_not_registered: {
+		german: "Du warst gar nicht registriert.",
+		english: "You weren't even registered.",
+	},
+	user_has_been_removed: {
+		german: "Du wurdest aus der Liste entfernt.",
+		english: "You were removed from the list.",
+	},
+	currently_registered: {
+		german: "Aktuell registriert: \n {playerlist}",
+		english: "Currently registered: \n {playerlist}"
+	},
+	troll_rejection: {
+		german: "Nöööö, du nicht...",
+		english: "Naaaah, not you..."
+	},
+	troll_rejection_second_part: {
+		german: "Spaß, hab dich registriert: :P",
+		english: "Just kidding, you are registered: :P"
+	}
+}

server/discordAdapter.ts

@@ -0,0 +1,149 @@
+import { REST } from '@discordjs/rest'
+import { SlashCommandBuilder } from '@discordjs/builders'
+import { commands } from './constants'
+import { Routes } from 'discord-api-types/v9'
+import { config } from './configuration'
+import { Client, CommandInteraction, GuildMember, Intents, Interaction } from 'discord.js'
+import RegistrationHandler from './RegistrationHandler'
+import { discordCommand } from './interfaces'
+
+export default class DiscordAdapter {
+	private rest: REST
+	private client: Client
+	private registration: RegistrationHandler
+	public constructor() {
+		this.rest = new REST({ version: '9' }).setToken(config.token)
+		this.client = new Client({ intents: [Intents.FLAGS.GUILDS] })
+		this.registration = RegistrationHandler.Instance
+		this.setupCallbacks(this.client)
+		this.client.login(config.token)
+		this.registerCommands(this.commandList)
+	}
+	public async registerCommands(pCommands: discordCommand[]) {
+		try {
+			console.log('Refreshing slash commands')
+			await this.rest.put(Routes.applicationGuildCommands(config.client_id, config.guild_id), { body: pCommands })
+			console.log('Successfully refreshed slash commands')
+		} catch (error) {
+			console.log(`Error refreshing slash commands: ${error}`)
+		}
+	}
+	private setupCallbacks(c: Client) {
+		c.on('ready', () => {
+			console.log(`Logged in as ${c.user?.tag}`)
+		})
+		c.on('interactionCreate', async interaction => {
+			if (!interaction.isCommand()) return
+			const interactionCommand = this.commandList.find(x => x.name == interaction.commandName)
+			if (interactionCommand)
+				interactionCommand.performCommand(interaction, this.registration)
+		})
+	}
+	public async echoes(interaction: CommandInteraction, registration: RegistrationHandler): Promise<void> {
+		const value = interaction.options.getString('input')
+		const member: GuildMember = <GuildMember>interaction.member
+		try {
+			console.log(`Member ${member.user.username} mute state: ${member.voice.mute}`)
+			member.voice.setMute(!member.voice.mute, "test")
+		} catch (error) {
+			console.error(error)
+		}
+		await interaction.reply(`This should be an echo: ${value}`)
+	}
+	public async listUsers(interaction: CommandInteraction, registration: RegistrationHandler): Promise<void> {
+		const result = registration.listRegisteredMembers()
+		await interaction.reply(result)
+	}
+	public async removeUser(interaction: CommandInteraction, registration: RegistrationHandler): Promise<void> {
+		const discordUser: GuildMember = <GuildMember>interaction.member
+		registration.removeUser(discordUser)
+		await interaction.reply(`User has been removed`)
+		return
+	}
+	public async registerUser(interaction: CommandInteraction, registration: RegistrationHandler): Promise<void> {
+		const discordUser: GuildMember = <GuildMember>interaction.member
+		const steamNameToRegister = interaction.options.getString('steamname')
+		console.dir(discordUser)
+		if (!steamNameToRegister) {
+			await interaction.reply(`No steam name supplied, can't register`)
+		}
+		else {
+			registration.register(discordUser, steamNameToRegister)
+			await interaction.reply(`This should register user ${discordUser.user.username} with id ${discordUser.user.id} to use steamname: ${steamNameToRegister}`)
+		}
+		return
+	}
+	public async showForSteam(interaction: CommandInteraction, registration: RegistrationHandler): Promise<void> {
+		const steamName = interaction.options.getString('steamname')
+		if (!steamName) {
+			await interaction.reply(`No steam name supplied, can't search`)
+		} else {
+			const result = registration.getNameRegisteredForSteamUser(steamName)
+			await interaction.reply(JSON.stringify(result, null, 2))
+		}
+		return
+	}
+	public async show(interaction: CommandInteraction, registration: RegistrationHandler): Promise<void> {
+		const discordUser: GuildMember = <GuildMember>interaction.member
+		const result = registration.getNameRegisteredForDiscordUser(discordUser)
+		await interaction.reply(JSON.stringify(result, null, 2))
+		return
+	}
+
+	public commandList: discordCommand[] = [
+		{
+			name: "echo",
+			description: "Echoes a string",
+			performCommand: this.echoes,
+			options: [
+				{
+					name: 'input',
+					description: 'The input that should be echoed',
+					required: true,
+					type: 3
+				}
+			]
+		},
+		{
+			name: commands.LIST_COMMAND,
+			description: "Lists all registerd users",
+			performCommand: this.listUsers
+		},
+		{
+			name: commands.REMOVE_COMMAND,
+			description: "Remove the mapping for this discord user",
+			performCommand: this.removeUser
+		},
+		{
+			name: commands.REGISTER_COMMAND,
+			description: "Register the senders discord name for a supplied steam name",
+			options: [
+				{
+					name: 'steamname',
+					description: 'The steamname that should be registered',
+					required: true,
+					type: 3
+				}
+			],
+			performCommand: this.registerUser
+		},
+		{
+			name: commands.SHOW_FOR_STEAM_COMMAND,
+			description: "Show the discord that's registered for a steam name",
+			performCommand: this.showForSteam,
+			options: [
+				{
+					name: 'steamname',
+					description: 'The steamname that should be searched',
+					required: true,
+					type: 3
+				}
+			],
+		},
+		{
+			name: commands.SHOW_COMMAND,
+			description: "Show the Steamname that's registered for this discord name",
+			performCommand: this.show
+		}
+	]
+}

server/interfaces.ts

@@ -0,0 +1,24 @@
+import { CommandInteraction, GuildMember } from "discord.js"
+import RegistrationHandler from "./RegistrationHandler"
+
+export type Maybe<T> = T | undefined
+export interface Player {
+	name: string
+}
+export type supported_languages = "german" | "english"
+export interface localized_string {
+	[k: string]: {
+		german: string,
+		english: string
+	}
+}
+export interface userNameBinding {
+	Steam: string,
+	DiscordUser: GuildMember
+}
+export interface discordCommand {
+	name: string,
+	description: string
+	options?: any[]
+	performCommand(interaction: CommandInteraction, registration: RegistrationHandler): Promise<void>
+}

server/routes.ts

@@ -0,0 +1,36 @@
+import express from "express";
+import MuteHandler from "./MuteHandler";
+
+export default class Routes {
+	public constructor(
+		private muteHandler = new MuteHandler()
+	) { }
+
+	public setRoutes(app: express.Application): void {
+		app.route('').get(this.landingPage.bind(this))
+		app.route('/').get(this.landingPage.bind(this))
+		app.route('/mute').post(this.mutePlayer.bind(this))
+		app.route('/unmute/all').post(this.unmuteAll.bind(this))
+		app.route('/unmute/:id').post(this.unmutePlayer.bind(this))
+	}
+	private async mutePlayer(req: express.Request, res: express.Response): Promise<void> {
+		const playerName = req.body.name
+		console.log(`Muting player ${playerName}`)
+		this.muteHandler.mute(playerName)
+		res.status(200).json()
+	}
+	private async unmuteAll(_: express.Request, res: express.Response): Promise<void> {
+		console.log(`Unmuting all players`)
+		this.muteHandler.unmuteAll()
+		res.status(200).json()
+	}
+	private async unmutePlayer(req: express.Request, res: express.Response): Promise<void> {
+		const playerName = req.body.name
+		console.log(`Unmuting player ${playerName}`)
+		this.muteHandler.unmute(playerName)
+		res.status(200).json()
+	}
+	private async landingPage(_: express.Request, res: express.Response): Promise<void> {
+		res.send('Hello World')
+	}
+}

server/server.ts

@@ -0,0 +1,36 @@
+import bodyParser from "body-parser"
+import cors from "cors"
+import express from "express"
+import { config } from "./configuration"
+
+export default class Server {
+	private app: express.Application
+	private port: number
+
+	public constructor(port: number) {
+		this.port = port
+		this.app = express()
+	}
+	public static init(port: number): Server {
+		return new Server(port)
+	}
+	public start(callback: (...args: any[]) => void): void {
+		this.setBodyParser()
+		this.setCors()
+		this.getApp().listen(this.port, callback)
+
+	}
+	public getApp(): express.Application {
+		return this.app
+	}
+	public getPort(): number {
+		return this.port
+	}
+	private setBodyParser(): void {
+		this.getApp().use(bodyParser.urlencoded(config.server.bodyParser.urlEncodedOptions))
+		this.getApp().use(bodyParser.json(config.server.bodyParser.jsonOptions))
+	}
+	private setCors(): void {
+		this.getApp().use(cors())
+	}
+}