Wir schreiben einen Telegram-Bot für lecker Bierchen

mkdir telegram_bot
cd telegram_bot
bun init

bun install node-telegram-bot-api dayjs @prisma/client
bun install --save-dev @types/node-telegram-bot-api prisma

docker run --name mariadb --env MARIADB_ROOT_PASSWORD=sup3rs3cr3t -p 3306:3306 -d mariadb

DATABASE_URL = "mysql://root:sup3rs3cr3t@localhost:3306/beerBot"

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema
 
// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
 
generator client {
  provider = "prisma-client-js"
}
 
datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}
 
model Event {
  id Int @id @default(autoincrement())
  date String @unique
  creator User @relation(fields: [creatorId], references: [id], onDelete: Cascade)
  creatorId Int
  votes Vote[]
}
 
model User {
  id Int @id
  firstName String
  lastName String
  isEnrolled Boolean
  votes Vote[]
  events Event[]
}
 
model Vote {
  id Int @id @default(autoincrement())
  vote String
  event Event @relation(fields: [eventId], references: [id], onDelete: Cascade)
  eventId Int
  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId Int
}

bunx prisma migrate dev

DATABASE_URL = "mysql://root:sup3rs3cr3t@localhost:3306/beerBot"
API_KEY = "XXXXXYYYYYZZZZZ"

const obj = {
  a: 'some text',
  b: 'some other text',
  c: 'some more text'
};
 
const {a, b} = obj;

const some_function = ({ a, b }) => a + b;
 
some_function(obj);

const function_name = (arguments) => {
  // do something
}

const function_name = (arguments: ArgumentsType): ReturnType => {
  // do something
}

bunx tsc

import Bot from "node-telegram-bot-api";
import dayjs from "dayjs";
import { PrismaClient } from "@prisma/client";
 
import type BotType from "node-telegram-bot-api";
import type { Message } from "node-telegram-bot-api";

const token = process.env.API_KEY || "";
const bot = new Bot(token, { polling: true });
const prisma = new PrismaClient();

interface VoteOptionsType {
  [index: string]: string;
}
 
interface CommandArgsType {
  command: string;
  args: string[];
  prisma: PrismaClient;
  msg: Message;
  bot: BotType;
}
 
const voteOptions = {
  ok: "Bin dabei!",
  nok: "Heute nicht, sorry",
  pending: "Noch nicht sicher",
} as VoteOptionsType;

console.log("Running Telegram Bot. Listening...");
 
bot.onText(/^\/.+/, async (msg, match) => {
  console.log(
    `[debug] ${formatName({ firstName: msg.from?.first_name, lastName: msg.from?.last_name })} ran ${msg.text}`,
  );
});

bot.onText(/^\/.+/, async (msg, match) => {
  console.log(
    `[debug] ${formatName({ firstName: msg.from?.first_name, lastName: msg.from?.last_name })} ran ${msg.text}`,
  );
 
  const command = msg.text?.split(" ")[0] || "";
  const args = msg.text?.split(" ").slice(1) || [];
 
  const args_to_commands = {
    command,
    args,
    prisma,
    msg,
    bot,
  };
});

bot.onText(/^\/.+/, async (msg, match) => {
  console.log(
    `[debug] ${formatName({ firstName: msg.from?.first_name, lastName: msg.from?.last_name })} ran ${msg.text}`,
  );
 
  const command = msg.text?.split(" ")[0] || "";
  const args = msg.text?.split(" ").slice(1) || [];
 
  const args_to_commands = {
    command,
    args,
    prisma,
    msg,
    bot,
  };
 
  await createUser(args_to_commands);
 
  let response = "";
  switch (true) {
    case /^\/start/.test(command):
      response = await start(args_to_commands);
      break;
    case /^\/help/.test(command):
      response = await help(args_to_commands);
      break;
    case /^\/enroll/.test(command):
      response = await enroll(args_to_commands);
      break;
    case /^\/leave/.test(command):
      response = await leave(args_to_commands);
      break;
    case /^\/active/.test(command):
      response = await active(args_to_commands);
      break;
    case /^\/beer/.test(command):
      response = await beer(args_to_commands);
      break;
    case /^\/status/.test(command):
      response = await status(args_to_commands);
      break;
    case Object.keys(voteOptions)
      .map((v) => "/" + v)
      .includes(command):
      response = await vote(args_to_commands);
      break;
    default:
      response = await nomatch(args_to_commands);
      break;
  }
 
  if (response)
    bot.sendMessage(msg.chat.id, response, { parse_mode: "Markdown" });
});

const formatName = ({
  firstName,
  lastName,
}: {
  firstName: string | undefined;
  lastName: string | undefined;
}): string => {
  return [firstName, lastName].filter((x) => x).join(" ");
};
 
const createUser = async ({
  msg,
  prisma,
}: CommandArgsType): Promise<undefined> => {
  const user = await prisma.user.findUnique({
    where: {
      id: msg.from?.id || 0,
    },
  });
 
  if (user === null)
    await prisma.user.create({
      data: {
        id: msg.from?.id || 0,
        firstName: msg.from?.first_name || "",
        lastName: msg.from?.last_name || "",
        isEnrolled: true,
      },
    });
};
 
const getToday = (): string => dayjs().format("YYYY-MM-DD");
 

const start = async (args: CommandArgsType): Promise<string> => {
  return `Willkommen beim Bier Bot! Ich habe dich automatisch eingetragen, und du kannst dich jederzeit mit /leave austragen. Hier ist eine Liste von Befehlen:
 
${await help(args)}
`
};

const help = async (args: CommandArgsType): Promise<string> => {
  return `- /help: Zeige diese Nachricht
- /active: Zeige alle aktiven User
- /enroll: Schliesse dich den aktiven Usern an
- /leave: Verlasse die aktiven User
- /beer: Starte ein Bier-Event
- /ok; /nok; /pending: Stimme über ein aktuelles Bier-Event ab
- /status: Zeige, wer heute dabei ist
`;
};

const nomatch = async ({ command }: CommandArgsType): Promise<string> => {
  return `Sorry, ich habe den Befehl ${command} nicht gefunden.`;
};

bun run index.ts

const enroll = async ({ msg, prisma }: CommandArgsType): Promise<string> => {
  await prisma.user.update({
    where: {
      id: msg.from?.id || 0,
    },
    data: {
      isEnrolled: true,
    },
  });
 
  return "gemacht";
};
 
const leave = async ({ msg, prisma }: CommandArgsType): Promise<string> => {
  await prisma.user.update({
    where: {
      id: msg.from?.id || 0,
    },
    data: {
      isEnrolled: false,
    },
  });
 
  return "gemacht";
};

const active = async ({ msg, prisma }: CommandArgsType): Promise<string> => {
  const activeUsers = await prisma.user.findMany({
    where: {
      isEnrolled: true,
    },
    orderBy: [
      { firstName: 'asc' }
    ]
  });
 
  return activeUsers.map((user) => `- ${formatName(user)}`).join("\n");
};

const beer = async ({ msg, bot, prisma }: CommandArgsType): Promise<string> => {
  const today = getToday();
 
  // if an event exists already, stop here
  const existingEvent = await prisma.event.findUnique({
    where: {
      date: today,
    },
    include: {
      creator: true,
    },
  });
 
  if (existingEvent !== null)
    return `${formatName(existingEvent.creator)} hat schon ein Event erstellt.`;
 
  // create a new event
  const event = await prisma.event.create({
    data: {
      date: today,
      creatorId: msg.from?.id || 0,
    },
    include: {
      creator: true,
    },
  });
 
  // the creator of the event obviously votes /ok
  await prisma.vote.create({
    data: {
      vote: "ok",
      eventId: event.id,
      userId: event.creator.id,
    },
  });
 
  // find all active users to notify
  const activeUsers = await prisma.user.findMany({
    where: {
      isEnrolled: true,
      orderBy: [
        { firstName: 'asc' }
      ]
    },
  });
 
  // list all the voteOptions as a string
  const voteOptionsText = Object.keys(voteOptions)
    .map((v) => `/${v} - ${voteOptions[v]}`)
    .join("\n")
 
  // full text to send to active users
  const text = `${formatName(event.creator)} will heute lecker Bierchen trinken. Dabei?\n\n${voteOptionsText}`;
 
  // send active users a message
  activeUsers
    .filter((user) => user.id !== msg.from?.id || 0)
    .forEach((user) => {
      bot.sendMessage(user.id, text, {
        reply_markup: {
          keyboard: [Object.keys(voteOptions).map((v) => ({ text: "/" + v }))],
        },
      });
    });
 
  return "Ich habe es allen aktiven Usern mitgeteilt. Benutze /status, um herauszufinden, wer heute dabei ist."
};

const status = async ({ prisma }: CommandArgsType): Promise<string> => {
  const today = getToday();
 
  const event = await prisma.event.findUnique({
    where: {
      date: today,
    },
    include: {
      votes: {
        include: {
          user: true,
        },
      },
    },
  });
 
  if (event === null) return "Heute gibt es noch kein Event. Benutze /beer, um ein Neues zu starten!";
 
  const text = Object.keys(voteOptions)
    .filter(
      (voteOption) =>
        event.votes.filter((vote) => vote.vote === voteOption).length > 0,
    )
    .map(
      (voteOption) =>
        voteOptions[voteOption] +
        ":\n" +
        event.votes
          .filter((vote) => vote.vote === voteOption)
          .map((vote) => `- ${formatName(vote.user)}`)
          .join("\n"),
    )
    .join("\n");
 
  return text;
}

const vote = async ({
  msg,
  prisma,
  command,
  args,
  bot,
}: CommandArgsType): Promise<string> => {
  const removeSlash = command.replace("/", "");
  const today = getToday();
 
  const event = await prisma.event.findUnique({
    where: {
      date: today,
    },
  });
 
  if (event === null) 
    return "Heute gibt es noch kein Event. Benutze /beer, um ein Neues zu starten!";
 
  const votes = await prisma.vote.findMany({
    where: {
      userId: msg.from?.id || 0,
      eventId: event.id,
    },
  });
 
  if (votes.length === 0) {
    // create a new vote
    await prisma.vote.create({
      data: {
        eventId: event.id,
        userId: msg.from?.id || 0,
        vote: removeSlash,
      },
    });
  } else {
    // update an existing vote
    await prisma.vote.update({
      where: {
        id: votes[0].id,
      },
      data: {
        vote: removeSlash,
      },
    });
  }
 
  const voteOptionsText = Object.keys(voteOptions)
    .map((voteOption) => "/" + voteOption)
    .join("; ");
 
  return `gemacht. Du kannst deine Stimme stets mit einem dieser Befehle aktualisieren: ${voteOptionsText}\n\n${await status({ msg, prisma, command, args, bot })}`;
};

import Bot from "node-telegram-bot-api";
import dayjs from "dayjs";
import { PrismaClient } from "@prisma/client";
 
import type BotType from "node-telegram-bot-api";
import type { Message } from "node-telegram-bot-api";
 
const token = process.env.API_KEY || "";
const bot = new Bot(token, { polling: true });
const prisma = new PrismaClient();
 
interface VoteOptionsType {
  [index: string]: string;
}
 
interface CommandArgsType {
  command: string;
  args: string[];
  prisma: PrismaClient;
  msg: Message;
  bot: BotType;
}
 
const voteOptions = {
  ok: "I'm in!",
  nok: "Not today, sorry",
  pending: "Not sure yet",
} as VoteOptionsType;
 
 
console.log("Running Telegram Bot. Listening...");
 
bot.onText(/^\/.+/, async (msg, match) => {
  console.log(
    `[debug] ${formatName({ firstName: msg.from?.first_name, lastName: msg.from?.last_name })} ran ${msg.text}`,
  );
 
  const command = msg.text?.split(" ")[0] || "";
  const args = msg.text?.split(" ").slice(1) || [];
 
  const args_to_commands = {
    command,
    args,
    prisma,
    msg,
    bot,
  };
 
  await createUser(args_to_commands);
 
  let response = "";
  switch (true) {
    case /^\/start/.test(command):
      response = await start(args_to_commands);
      break;
    case /^\/help/.test(command):
      response = await help(args_to_commands);
      break;
    case /^\/enroll/.test(command):
      response = await enroll(args_to_commands);
      break;
    case /^\/leave/.test(command):
      response = await leave(args_to_commands);
      break;
    case /^\/active/.test(command):
      response = await active(args_to_commands);
      break;
    case /^\/beer/.test(command):
      response = await beer(args_to_commands);
      break;
    case /^\/status/.test(command):
      response = await status(args_to_commands);
      break;
    case Object.keys(voteOptions)
      .map((v) => "/" + v)
      .includes(command):
      response = await vote(args_to_commands);
      break;
    default:
      response = await nomatch(args_to_commands);
      break;
  }
 
  if (response)
    bot.sendMessage(msg.chat.id, response, { parse_mode: "Markdown" });
});
 
/*
 * UTILITY FUNCTIONS
 */
const formatName = ({
  firstName,
  lastName,
}: {
  firstName: string | undefined;
  lastName: string | undefined;
}): string => {
  return [firstName, lastName].filter((x) => x).join(" ");
};
 
const createUser = async ({
  msg,
  prisma,
}: CommandArgsType): Promise<undefined> => {
  const user = await prisma.user.findUnique({
    where: {
      id: msg.from?.id || 0,
    },
  });
 
  if (user === null)
    await prisma.user.create({
      data: {
        id: msg.from?.id || 0,
        firstName: msg.from?.first_name || "",
        lastName: msg.from?.last_name || "",
        isEnrolled: true,
      },
    });
};
 
const getToday = (): string => dayjs().format("YYYY-MM-DD");
 
/*
 * COMMANDS
 */
const start = async (args: CommandArgsType): Promise<string> => {
  return `Willkommen beim Bier Bot! Ich habe dich automatisch eingetragen, und du kannst dich jederzeit mit /leave austragen. Hier ist eine Liste von Befehlen:
 
${await help(args)}
`;
};
 
const help = async (args: CommandArgsType): Promise<string> => {
  return `- /help: Zeige diese Nachricht
- /active: Zeige alle aktiven User
- /enroll: Schliesse dich den aktiven Usern an
- /leave: Verlasse die aktiven User
- /beer: Starte ein Bier-Event
- /ok; /nok; /pending: Stimme über ein aktuelles Bier-Event ab
- /status: Zeige, wer heute dabei ist
`;
};
 
const enroll = async ({ msg, prisma }: CommandArgsType): Promise<string> => {
  await prisma.user.update({
    where: {
      id: msg.from?.id || 0,
    },
    data: {
      isEnrolled: true,
    },
  });
 
  return "gemacht";
};
 
const leave = async ({ msg, prisma }: CommandArgsType): Promise<string> => {
  await prisma.user.update({
    where: {
      id: msg.from?.id || 0,
    },
    data: {
      isEnrolled: false,
    },
  });
 
  return "gemacht";
};
 
const active = async ({ msg, prisma }: CommandArgsType): Promise<string> => {
  const activeUsers = await prisma.user.findMany({
    where: {
      isEnrolled: true,
    },
    orderBy: [
      { firstName: 'asc' }
    ]
  });
 
  return activeUsers.map((user) => `- ${formatName(user)}`).join("\n");
};
 
const beer = async ({ msg, bot, prisma }: CommandArgsType): Promise<string> => {
  const today = getToday();
 
  // if an event exists already, stop here
  const existingEvent = await prisma.event.findUnique({
    where: {
      date: today,
    },
    include: {
      creator: true,
    },
  });
 
  if (existingEvent !== null)
    return `${formatName(existingEvent.creator)} hat schon ein Event erstellt.`;
 
  // create a new event
  const event = await prisma.event.create({
    data: {
      date: today,
      creatorId: msg.from?.id || 0,
    },
    include: {
      creator: true,
    },
  });
 
  // the creator of the event obviously votes /ok
  await prisma.vote.create({
    data: {
      vote: "ok",
      eventId: event.id,
      userId: event.creator.id,
    },
  });
 
  // find all active users to notify
  const activeUsers = await prisma.user.findMany({
    where: {
      isEnrolled: true,
    },
    orderBy: [
      { firstName: 'asc' }
    ]
  });
 
  // list all the voteOptions as a string
  const voteOptionsText = Object.keys(voteOptions)
    .map((v) => `/${v} - ${voteOptions[v]}`)
    .join("\n")
 
  // full text to send to active users
  const text = `${formatName(event.creator)} will heute lecker Bierchen trinken. Dabei?\n\n${voteOptionsText}`;
 
  // send active users a message
  activeUsers
    // .filter((user) => user.id !== msg.from?.id || 0)
    .forEach((user) => {
      bot.sendMessage(user.id, text, {
        reply_markup: {
          keyboard: [Object.keys(voteOptions).map((v) => ({ text: "/" + v }))],
        },
      });
    });
 
  return "Ich habe es allen aktiven Usern mitgeteilt. Benutze /status, um herauszufinden, wer heute dabei ist."
};
 
const status = async ({ prisma }: CommandArgsType): Promise<string> => {
  const today = getToday();
 
  const event = await prisma.event.findUnique({
    where: {
      date: today,
    },
    include: {
      votes: {
        include: {
          user: true,
        },
      },
    },
  });
 
  if (event === null) return "Heute gibt es noch kein Event. Benutze /beer, um ein Neues zu starten!";
 
  const text = Object.keys(voteOptions)
    .filter(
      (voteOption) =>
        event.votes.filter((vote) => vote.vote === voteOption).length > 0,
    )
    .map(
      (voteOption) =>
        voteOptions[voteOption] +
        ":\n" +
        event.votes
          .filter((vote) => vote.vote === voteOption)
          .map((vote) => `- ${formatName(vote.user)}`)
          .join("\n"),
    )
    .join("\n");
 
  return text;
};
 
const vote = async ({
  msg,
  prisma,
  command,
  args,
  bot,
}: CommandArgsType): Promise<string> => {
  const removeSlash = command.replace("/", "");
  const today = getToday();
 
  const event = await prisma.event.findUnique({
    where: {
      date: today,
    },
  });
 
  if (event === null) 
    return "Heute gibt es noch kein Event. Benutze /beer, um ein Neues zu starten!";
 
  const votes = await prisma.vote.findMany({
    where: {
      userId: msg.from?.id || 0,
      eventId: event.id,
    },
  });
 
  if (votes.length === 0) {
    // create a new vote
    await prisma.vote.create({
      data: {
        eventId: event.id,
        userId: msg.from?.id || 0,
        vote: removeSlash,
      },
    });
  } else {
    // update an existing vote
    await prisma.vote.update({
      where: {
        id: votes[0].id,
      },
      data: {
        vote: removeSlash,
      },
    });
  }
 
  const voteOptionsText = Object.keys(voteOptions)
    .map((voteOption) => "/" + voteOption)
    .join("; ");
 
  return `gemacht. Du kannst deine Stimme stets mit einem dieser Befehle aktualisieren: ${voteOptionsText}\n\n${await status({ msg, prisma, command, args, bot })}`;
};
 
const nomatch = async ({ command }: CommandArgsType): Promise<string> => {
  return `Sorry, ich habe den Befehl ${command} nicht gefunden.`;
};