362 lines
16 KiB
TypeScript
362 lines
16 KiB
TypeScript
import { Guild, GuildScheduledEvent, GuildScheduledEventEditOptions, GuildScheduledEventSetStatusArg, GuildScheduledEventStatus, Message, MessageCreateOptions, MessageReaction, TextChannel } from "discord.js"
|
|
import { Emotes, NONE_OF_THAT } from "../constants"
|
|
import { logger, newRequestId } from "../logger"
|
|
import { getMembersWithRoleFromGuild } from "./roleFilter"
|
|
import { config } from "../configuration"
|
|
import { VoteMessage, isVoteEndedMessage, isVoteMessage } from "./messageIdentifiers"
|
|
import { createDateStringFromEvent } from "./dateHelper"
|
|
import { Maybe, voteMessageInputInformation as prepareVoteMessageInput } from "../interfaces"
|
|
import format from "date-fns/format"
|
|
import toDate from "date-fns/toDate"
|
|
import differenceInDays from "date-fns/differenceInDays"
|
|
import addDays from "date-fns/addDays"
|
|
import isAfter from "date-fns/isAfter"
|
|
import { ExtendedClient } from "../structures/client"
|
|
import { JellyfinHandler } from "../jellyfin/handler"
|
|
|
|
export type Vote = {
|
|
emote: string, //todo habs nicht hinbekommen hier Emotes zu nutzen
|
|
count: number,
|
|
movie: string
|
|
}
|
|
export type VoteMessageInfo = {
|
|
votes: Vote[],
|
|
event: GuildScheduledEvent,
|
|
}
|
|
export default class VoteController {
|
|
private client: ExtendedClient
|
|
private yavinJellyfinHandler: JellyfinHandler
|
|
|
|
public constructor(_client: ExtendedClient, _yavin: JellyfinHandler) {
|
|
this.client = _client
|
|
this.yavinJellyfinHandler = _yavin
|
|
}
|
|
|
|
public async handleNoneOfThatVote(messageReaction: MessageReaction, reactedUponMessage: VoteMessage, requestId: string, guildId: string) {
|
|
if (!messageReaction.message.guild) return 'No guild'
|
|
const guild = messageReaction.message.guild
|
|
logger.debug(`${reactedUponMessage.id} is vote message`, { requestId, guildId })
|
|
|
|
const watcherRoleMember = await getMembersWithRoleFromGuild(config.bot.announcement_role, messageReaction.message.guild)
|
|
logger.info("ROLE MEMBERS " + JSON.stringify(watcherRoleMember), { requestId, guildId })
|
|
|
|
const watcherRoleMemberCount = watcherRoleMember.size
|
|
logger.info(`MEMBER COUNT: ${watcherRoleMemberCount}`, { requestId, guildId })
|
|
|
|
const noneOfThatReactions = reactedUponMessage.reactions.cache.get(NONE_OF_THAT)?.users.cache.filter(x => x.id !== this.client.user?.id).size ?? 0
|
|
|
|
const memberThreshold = (watcherRoleMemberCount / 2)
|
|
logger.info(`Reroll ${noneOfThatReactions} > ${memberThreshold} ?`, { requestId, guildId })
|
|
if (noneOfThatReactions > memberThreshold)
|
|
logger.info(`No reroll`, { requestId, guildId })
|
|
else {
|
|
logger.info('Starting poll reroll', { requestId, guildId })
|
|
await this.handleReroll(reactedUponMessage, guild.id, requestId)
|
|
logger.info(`Finished handling NONE_OF_THAT vote`, { requestId, guildId })
|
|
}
|
|
}
|
|
|
|
private async removeMessage(message: Message): Promise<Message<boolean>> {
|
|
if (message.pinned) {
|
|
await message.unpin()
|
|
}
|
|
return await message.delete()
|
|
}
|
|
|
|
/**
|
|
* returns true if a Vote object contains at least one vote
|
|
* @param {Vote} vote
|
|
*/
|
|
private hasAtLeastOneVote(vote: Vote): boolean {
|
|
// subtracting the bots initial vote
|
|
const overOneVote = (vote.count - 1) >= 1
|
|
logger.debug(`${vote.movie} : ${vote.count} -> above: ${overOneVote}`)
|
|
return overOneVote
|
|
}
|
|
|
|
public async generateRerollMovieList(voteInfo: VoteMessageInfo, guildId: string, requestId: string) {
|
|
if (config.bot.reroll_retains_top_picks) {
|
|
const votedOnMovies = voteInfo.votes.filter(this.hasAtLeastOneVote).filter(x => x.emote !== NONE_OF_THAT)
|
|
logger.info(`Found ${votedOnMovies.length} with votes`, { requestId, guildId })
|
|
const newMovieCount: number = config.bot.random_movie_count - votedOnMovies.length
|
|
logger.info(`Fetching ${newMovieCount} from jellyfin`)
|
|
const newMovies: string[] = await this.yavinJellyfinHandler.getRandomMovieNames(newMovieCount, guildId, requestId)
|
|
// merge
|
|
return newMovies.concat(votedOnMovies.map(x => x.movie))
|
|
} else {
|
|
// get movies from jellyfin to fill the remaining slots
|
|
const newMovieCount: number = config.bot.random_movie_count
|
|
logger.info(`Fetching ${newMovieCount} from jellyfin`)
|
|
return await this.yavinJellyfinHandler.getRandomMovieNames(newMovieCount, guildId, requestId)
|
|
}
|
|
}
|
|
|
|
public async handleReroll(voteMessage: VoteMessage, guildId: string, requestId: string) {
|
|
// get the movies currently being voted on, their votes, the eventId and its date
|
|
const voteInfo: VoteMessageInfo = await this.parseVoteInfoFromVoteMessage(voteMessage, requestId)
|
|
if (!voteInfo.event.scheduledStartAt) {
|
|
logger.info("Event does not have a start date, cancelling", { guildId: voteInfo.event.guildId, requestId })
|
|
return
|
|
}
|
|
|
|
let movies: string[] = await this.generateRerollMovieList(voteInfo, guildId, requestId)
|
|
|
|
const announcementChannel = this.client.getAnnouncementChannelForGuild(guildId)
|
|
if (!announcementChannel) {
|
|
logger.error(`No announcementChannel found for ${guildId}, can't post poll`)
|
|
return
|
|
}
|
|
try {
|
|
logger.info(`Trying to remove old vote Message`, { requestId, guildId })
|
|
this.removeMessage(voteMessage)
|
|
} catch (err) {
|
|
// TODO: integrate failure DM to media Admin to inform about inability to delete old message
|
|
logger.error(`Error during removeMessage: ${err}`)
|
|
}
|
|
const sentMessage = this.prepareAndSendVoteMessage({
|
|
event: voteInfo.event,
|
|
movies,
|
|
announcementChannel,
|
|
startDate: voteInfo.event.scheduledStartAt,
|
|
pinAfterSending: true
|
|
},
|
|
guildId,
|
|
requestId)
|
|
logger.debug(`Sent reroll message: ${JSON.stringify(sentMessage)}`, { requestId, guildId })
|
|
}
|
|
|
|
private async fetchEventByEventId(guild: Guild, eventId: string, requestId: string): Promise<Maybe<GuildScheduledEvent>> {
|
|
const guildEvent: GuildScheduledEvent = await guild.scheduledEvents.fetch(eventId)
|
|
if (!guildEvent) logger.error(`GuildScheduledEvent with id${eventId} could not be found`, { requestId, guildId: guild.id })
|
|
return guildEvent
|
|
}
|
|
|
|
public async parseVoteInfoFromVoteMessage(message: VoteMessage, requestId: string): Promise<VoteMessageInfo> {
|
|
const lines = message.cleanContent.split('\n')
|
|
let parsedIds = this.parseGuildIdAndEventIdFromWholeMessage(message.cleanContent)
|
|
|
|
if (!message.guild)
|
|
throw new Error(`Message ${message.id} not a guild message`)
|
|
|
|
const event: Maybe<GuildScheduledEvent> = await this.fetchEventByEventId(message.guild, parsedIds.eventId, requestId)
|
|
|
|
let votes: Vote[] = []
|
|
for (const line of lines) {
|
|
if (line.slice(0, 5).includes(':')) {
|
|
const splitLine = line.split(":")
|
|
const [emoji, movie] = splitLine
|
|
const fetchedVoteFromMessage = message.reactions.cache.get(emoji)
|
|
if (fetchedVoteFromMessage) {
|
|
if (emoji === NONE_OF_THAT) {
|
|
votes.push({ movie: NONE_OF_THAT, emote: NONE_OF_THAT, count: fetchedVoteFromMessage.count })
|
|
} else
|
|
votes.push({ movie: movie.trim(), emote: emoji, count: fetchedVoteFromMessage.count })
|
|
} else {
|
|
logger.error(`No vote reaction found for movie, assuming 0`, requestId)
|
|
votes.push({ movie, emote: emoji, count: 0 })
|
|
}
|
|
}
|
|
}
|
|
return <VoteMessageInfo>{ event, votes }
|
|
}
|
|
public parseEventDateFromMessage(message: string, guildId: string, requestId: string): Date {
|
|
logger.warn(`Falling back to RegEx parsing to get Event Date`, { guildId, requestId })
|
|
const datematcher = RegExp(/((?:0[1-9]|[12][0-9]|3[01])\.(?:0[1-9]|1[012])\.)(?:\ um\ )((?:(?:[01][0-9]|[2][0-3])\:[0-5][0-9])|(?:[2][4]\:00))!/i)
|
|
const result: RegExpMatchArray | null = message.match(datematcher)
|
|
const timeFromResult = result?.at(-1)
|
|
const dateFromResult = result?.at(1)?.concat(format(new Date(), 'yyyy')).concat(" " + timeFromResult) ?? ""
|
|
return new Date(dateFromResult)
|
|
}
|
|
public parseGuildIdAndEventIdFromWholeMessage(message: string) {
|
|
const idmatch = RegExp(/(?:http|https):\/\/discord\.com\/events\/(\d*)\/(\d*)/)
|
|
const matches = message.match(idmatch)
|
|
if (matches && matches.length == 3)
|
|
return { guildId: matches[1], eventId: matches[2] }
|
|
throw Error(`Could not find eventId in Vote Message`)
|
|
}
|
|
|
|
public async prepareAndSendVoteMessage(inputInfo: prepareVoteMessageInput, guildId: string, requestId: string) {
|
|
const messageText = this.createVoteMessageText(inputInfo.event, inputInfo.movies, guildId, requestId)
|
|
const sentMessage = await this.sendVoteMessage(messageText, inputInfo.movies.length, inputInfo.announcementChannel)
|
|
if (inputInfo.pinAfterSending)
|
|
sentMessage.pin()
|
|
return sentMessage
|
|
}
|
|
|
|
public createVoteMessageText(event: GuildScheduledEvent, movies: string[], guildId: string, requestId: string): string {
|
|
let message = `[Abstimmung] für https://discord.com/events/${guildId}/${event.id} \n<@&${config.bot.announcement_role}> Es gibt eine neue Abstimmung für die nächste Watchparty ${createDateStringFromEvent(event.scheduledStartAt, guildId, requestId)}! Stimme hierunter für den nächsten Film ab!\n`
|
|
|
|
for (let i = 0; i < movies.length; i++) {
|
|
message = message.concat(Emotes[i]).concat(": ").concat(movies[i]).concat("\n")
|
|
}
|
|
message = message.concat(NONE_OF_THAT).concat(": Wenn dir nichts davon gefällt.")
|
|
|
|
return message
|
|
}
|
|
|
|
// TODO: Refactor into separate message controller
|
|
public async sendVoteMessage(messageText: string, movieCount: number, announcementChannel: TextChannel) {
|
|
|
|
const options: MessageCreateOptions = {
|
|
allowedMentions: { parse: ["roles"] },
|
|
content: messageText,
|
|
}
|
|
|
|
const sentMessage: Message<true> = await (await announcementChannel.fetch()).send(options)
|
|
|
|
for (let i = 0; i < movieCount; i++) {
|
|
sentMessage.react(Emotes[i])
|
|
}
|
|
sentMessage.react(NONE_OF_THAT)
|
|
|
|
return sentMessage
|
|
}
|
|
|
|
public async closePoll(guild: Guild, requestId: string) {
|
|
const guildId = guild.id
|
|
logger.info("stopping poll", { guildId, requestId })
|
|
|
|
const announcementChannel: Maybe<TextChannel> = this.client.getAnnouncementChannelForGuild(guildId)
|
|
if (!announcementChannel) {
|
|
logger.error("Could not find the textchannel. Unable to close poll.", { guildId, requestId })
|
|
return
|
|
}
|
|
|
|
const messages: Message<true>[] = (await announcementChannel.messages.fetch()) //todo: fetch only pinned messages
|
|
.map((value) => value)
|
|
.filter(message => !isVoteEndedMessage(message) && isVoteMessage(message))
|
|
.sort((a, b) => b.createdTimestamp - a.createdTimestamp)
|
|
|
|
if (!messages || messages.length <= 0) {
|
|
logger.info("Could not find any vote messages. Cancelling pollClose", { guildId, requestId })
|
|
return
|
|
}
|
|
|
|
const lastMessage: Message<true> = messages[0]
|
|
|
|
if (!isVoteMessage(lastMessage)) {
|
|
logger.error(`Found message that is not a vote message, can't proceed`, { guildId, requestId })
|
|
logger.debug(`Found messages: ${JSON.stringify(messages, null, 2)}`, { guildId, requestId })
|
|
logger.debug(`Last message: ${JSON.stringify(lastMessage, null, 2)}`, { guildId, requestId })
|
|
}
|
|
else {
|
|
const votes = (await this.getVotesByEmote(lastMessage, guildId, requestId))
|
|
.sort((a, b) => b.count - a.count)
|
|
|
|
logger.debug(`votes: ${JSON.stringify(votes, null, 2)}`, { guildId, requestId })
|
|
|
|
logger.info("Deleting vote message")
|
|
lastMessage.unpin()
|
|
await lastMessage.delete()
|
|
const event = await this.getOpenPollEvent(guild, guild.id, requestId)
|
|
if (event && votes?.length > 0) {
|
|
this.updateOpenPollEventWithVoteResults(event, votes, guild, guildId, requestId)
|
|
this.sendVoteClosedMessage(event, votes[0].movie, guildId, requestId)
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* gets votes for the movies without the NONE_OF_THAT votes
|
|
*/
|
|
public async getVotesByEmote(message: VoteMessage, guildId: string, requestId: string): Promise<Vote[]> {
|
|
const votes: Vote[] = []
|
|
logger.debug(`Number of items in emotes: ${Object.values(Emotes).length}`, { guildId, requestId })
|
|
for (let i = 0; i < Object.keys(Emotes).length / 2; i++) {
|
|
const emote = Emotes[i]
|
|
logger.debug(`Getting reaction for emote ${emote}`, { guildId, requestId })
|
|
const reaction = message.reactions.resolve(emote)
|
|
logger.debug(`Reaction for emote ${emote}: ${JSON.stringify(reaction, null, 2)}`, { guildId, requestId })
|
|
if (reaction) {
|
|
const vote: Vote = { emote: emote, count: reaction.count, movie: this.extractMovieFromMessageByEmote(message, emote) }
|
|
votes.push(vote)
|
|
}
|
|
}
|
|
return votes
|
|
}
|
|
public async getOpenPollEvent(guild: Guild, guildId: string, requestId: string): Promise<Maybe<GuildScheduledEvent>> {
|
|
const voteEvents = (await guild.scheduledEvents.fetch())
|
|
.map((value) => value)
|
|
.filter(event => event.name.toLowerCase().includes("voting offen"))
|
|
logger.debug(`Found events: ${JSON.stringify(voteEvents, null, 2)}`, { guildId, requestId })
|
|
|
|
if (!voteEvents || voteEvents.length <= 0) {
|
|
logger.error("Could not find an open vote event.", { guildId, requestId })
|
|
return
|
|
}
|
|
return voteEvents[0]
|
|
}
|
|
public async updateOpenPollEventWithVoteResults(voteEvent: GuildScheduledEvent, votes: Vote[], guild: Guild, guildId: string, requestId: string) {
|
|
logger.info(`Updating event with movie ${votes[0].movie}.`, { guildId, requestId })
|
|
const options: GuildScheduledEventEditOptions<GuildScheduledEventStatus.Scheduled, GuildScheduledEventSetStatusArg<GuildScheduledEventStatus.Scheduled>> = {
|
|
name: votes[0].movie,
|
|
description: `!wp\nNummer 2: ${votes[1].movie} mit ${votes[1].count - 1} Stimmen\nNummer 3: ${votes[2].movie} mit ${votes[2].count - 1} Stimmen`
|
|
}
|
|
logger.debug(`Updating event: ${JSON.stringify(voteEvent, null, 2)}`, { guildId, requestId })
|
|
logger.info("Updating event.", { guildId, requestId })
|
|
voteEvent.edit(options)
|
|
}
|
|
public async sendVoteClosedMessage(event: GuildScheduledEvent, movie: string, guildId: string, requestId: string): Promise<Message<boolean>> {
|
|
const date = event.scheduledStartAt ? format(event.scheduledStartAt, "dd.MM.") : "Fehler, Event hatte kein Datum"
|
|
const time = event.scheduledStartAt ? format(event.scheduledStartAt, "HH:mm") : "Fehler, Event hatte keine Uhrzeit"
|
|
const body = `[Abstimmung beendet] für https://discord.com/events/${event.guildId}/${event.id}\n<@&${config.bot.announcement_role}> Wir gucken ${movie} am ${date} um ${time}`
|
|
const options: MessageCreateOptions = {
|
|
content: body,
|
|
allowedMentions: { parse: ["roles"] }
|
|
}
|
|
const announcementChannel = this.client.getAnnouncementChannelForGuild(guildId)
|
|
logger.info("Sending vote closed message.", { guildId, requestId })
|
|
if (!announcementChannel) {
|
|
const errorMessageText = "Could not find announcement channel. Please fix!"
|
|
logger.error(errorMessageText, { guildId, requestId })
|
|
throw errorMessageText
|
|
}
|
|
return announcementChannel.send(options)
|
|
}
|
|
private extractMovieFromMessageByEmote(voteMessage: VoteMessage, emote: string): string {
|
|
const lines = voteMessage.cleanContent.split("\n")
|
|
const emoteLines = lines.filter(line => line.includes(emote))
|
|
|
|
if (!emoteLines) {
|
|
return ""
|
|
}
|
|
const movie = emoteLines[0].substring(emoteLines[0].indexOf(emote) + emote.length + 2) // plus colon and space
|
|
|
|
return movie
|
|
}
|
|
public async checkForPollsToClose(guild: Guild): Promise<void> {
|
|
const requestId = newRequestId()
|
|
logger.info(`Automatic check for poll closing.`, { guildId: guild.id, requestId })
|
|
const events = (await guild.scheduledEvents.fetch()).filter(event => event.name.toLocaleLowerCase().includes("voting offen")).map(event => event)
|
|
if (events.length > 1) {
|
|
logger.error("Handling more than one Event is not implemented yet. Found more than one poll to close")
|
|
return
|
|
} else if (events.length == 0) {
|
|
logger.info("Could not find any events. Cancelling", { guildId: guild.id, requestId })
|
|
}
|
|
|
|
const updatedEvent = events[0] //add two hours because of different timezones in discord api and Date.now()
|
|
if (!updatedEvent.scheduledStartTimestamp) {
|
|
logger.error("Event does not have a scheduled start time. Cancelling", { guildId: guild.id, requestId })
|
|
return
|
|
}
|
|
|
|
const createDate: Date = toDate(updatedEvent.createdTimestamp)
|
|
const eventDate: Date = toDate(updatedEvent.scheduledStartTimestamp)
|
|
const difference: number = differenceInDays(createDate, eventDate)
|
|
|
|
if (difference <= 2) {
|
|
logger.info("Less than two days between event create and event start. Not closing poll.", { guildId: guild.id, requestId })
|
|
return
|
|
}
|
|
|
|
const closePollDate: Date = addDays(eventDate, -2)
|
|
|
|
if (isAfter(Date.now(), closePollDate)) {
|
|
logger.info("Less than two days until event. Closing poll", { guildId: guild.id, requestId })
|
|
this.closePoll(guild, requestId)
|
|
} else {
|
|
logger.info(`ScheduledStart: ${closePollDate}. Now: ${toDate(Date.now())}`, { guildId: guild.id, requestId })
|
|
}
|
|
}
|
|
}
|