async def refreshCommand(cmd: Union[commands.Context, discord.Interaction], bot: commands.Bot): """ Refreshes the channel's webhook on request. Arguments --- cmd: Context or interaction from the invoked command. bot: The Discord bot. """ db = await botdb.getDB(bot.pool) if isinstance(cmd, commands.Context): message = YagooMessage(bot, cmd.author) else: message = YagooMessage(bot, cmd.user) result = await refreshPrompts.confirm(cmd, message) if result.responseType: if result.buttonID == "yes": await refreshWebhook(bot, cmd.guild, cmd.channel, db) message.resetEmbed() message.embed.title = "Successfully Refreshed!" message.embed.description = "The channel's webhook should now be refreshed. "\ "Channel notifications will be posted after a short while." message.msg = await message.msg.edit(content=None, embed=message.embed, view=None) return await removeMessage(message, cmd)
async def displayResult(message: YagooMessage, unsubData: UnsubscriptionResponse): """ Displays the unsubscription result. message: The message used to display the result. unsubData: The unsubscription data. """ subTypeText = "" channels = "" for subType in unsubData.subTypes: subTypeText += f"{subType.capitalize()}, " if len(unsubData.channels) <= 5: for channel in unsubData.channels: channels += f"{channel.channelName}, " else: channels = f"{len(unsubData.channels)} channels" message.resetEmbed() message.embed.title = "Successfully Unsubscribed!" message.embed.description = f"This channel is now unsubscribed from {channels.strip(', ')}." message.embed.color = discord.Color.green() message.embed.add_field(name="Subscription Types", value=subTypeText.strip(", "), inline=False) message.msg = await message.msg.edit(content=None, embed=message.embed, view=None) return
async def displaySubbed(message: YagooMessage, subResult: SubscriptionResponse): """ Gives a status to the user about subbed accounts. Arguments --- message: The message that will be used as the display. subResult: The `SubscriptionResponse` from the subscription prompts. """ channels = "" message.resetEmbed() for name in subResult.channelNames: channels += f"{name}, " if subResult.subTypes: message.embed.title = "Successfully Subscribed!" message.embed.description = f"This channel is now subscribed to {channels.strip(', ')}." message.embed.color = discord.Colour.green() subTypes = "" for subType in subResult.subTypes: subTypes += f"{subType.capitalize()}, " message.embed.add_field(name="Subscription Types", value=subTypes.strip(", ")) else: message.embed.title = "Already Subscribed!" message.embed.description = f"This channel is already subscribed to {channels.strip(', ')}!" message.embed.color = discord.Colour.red() message.msg = await message.msg.edit(content=None, embed=message.embed, view=None)
async def defaultSubtype(cmd: Union[commands.Context, discord.Interaction], bot: commands.Bot): """ Prompts the user to either set or change the default subscription types for the channel. Arguments --- cmd: Context or interaction from the invoked command bot: The Discord bot. """ db = await botdb.getDB(bot.pool) server = await dbTools.serverGrab(bot, str(cmd.guild.id), str(cmd.channel.id), ("subDefault", ), db) if isinstance(cmd, commands.Context): message = YagooMessage(bot, cmd.author) message.msg = await cmd.send("Loading channel subscription defaults..." ) else: message = YagooMessage(bot, cmd.user) subTypes = {} for subType in allSubTypes(False): subTypes[subType] = False if not (server["subDefault"] is None or server["subDefault"] == ""): for subType in await botdb.listConvert(server["subDefault"]): subTypes[subType] = True message.embed.title = "Default Channel Subscription Types" message.embed.description = "Pick the subscription types for this channel to subscribe to by default." result = await subPrompts.subTypes.prompt(cmd, message, "Confirm", "confirm", subTypes, True) if isinstance(result, SubscriptionData): subDefault: List[str] = [] for subType in result.subList: if result.subList[subType]: subDefault.append(subType) await botdb.addData( (str(cmd.channel.id), await botdb.listConvert(subDefault)), ("channel", "subDefault"), "servers", db) message.resetEmbed() message.embed.title = "Successfully Set Channel Defaults!" if subDefault == []: message.embed.description = "Subscription commands will now ask for subscription types first." message.embed.color = discord.Color.from_rgb(0, 0, 0) else: defaultSubs = "" for sub in subDefault: defaultSubs += f"{sub.capitalize()}, " message.embed.description = "Subscription commands will now follow the channel's defaults." message.embed.color = discord.Color.green() message.embed.add_field(name="Default Subscriptions", value=defaultSubs.strip(", "), inline=False) await message.msg.edit(content=" ", embed=message.embed, view=None) return await removeMessage(cmd=cmd) await removeMessage(message, cmd)
async def displayProgress(message: YagooMessage): message.resetEmbed() message.embed.title = "Currently Subscribing..." message.embed.description = "Currently subscribing to the channels specified.\n" \ "This might take longer if the amount of channels is larger." message.embed.color = discord.Color.from_rgb(0, 0, 0) message.msg = await message.msg.edit(content=None, embed=message.embed, view=None)
def displayResult(message: YagooMessage, accName: str, status: bool): """ Display the result of the follow action. Arguments --- message: The message used to display the result. accName: The Twitter account name. status: The status from the follow command. """ message.resetEmbed() if status: message.embed.title = "Successfully Followed Account!" message.embed.description = f"This channel is now following @{accName}." message.embed.color = discord.Color.green() else: message.embed.title = "Already Followed Account!" message.embed.description = f"This channel is already following @{accName}." message.embed.color = discord.Color.red()
def displayResult(message: YagooMessage, unfollowData: TwitterUnfollowResponse): """ Display the result of the follow action. Arguments --- message: The message used to display the result. unfollowData: The channel's unfollow data. """ message.resetEmbed() message.embed.title = "Successfully Unfollowed Accounts!" message.embed.color = discord.Color.green() accounts = "" if len(unfollowData.accounts) <= 3: for account in unfollowData.accounts: accounts += f"@{account.handle}, " else: accounts = f"{len(unfollowData.accounts)} accounts'" if unfollowData.allAccounts: accounts = "all Twitter accounts'" message.embed.description = f"The channel has been unfollowed from {accounts.strip(', ')} tweets."
async def prompt(cmd: Union[commands.Context, discord.Interaction], message: YagooMessage, channelIDs: Optional[List[str]] = None, subData: Optional[ChannelSubscriptionData] = None, allChannels: bool = False): """ Prompts the user for which subscription type to unsubscribe from. Arguments --- ctx: Context from the executed command. msg: The message that will be used as the prompt. channelIDs: IDs of the VTuber channels to be unsubscribed from. subData: The subscription data of the current channel. allChannels: If all channels are to be unsubscribed. Returns --- A `dict` with: - status: `True` if an option was chosen by the user. - unsubbed: A `list` with subscription types to unsubscribe from. """ if not allChannels: channels = await unsubPrompts.removePrompt.parseToChannels( channelIDs, subData) else: channels = subData.allChannels subTypes = {} if allChannels: name = "All Channels" elif len(channelIDs) > 1: name = "Multiple Channels" else: name = channels[0].channelName message.resetEmbed() message.embed.title = f"Unsubscribing from {name}" message.embed.description = "Choose the subscription types to unsubscribe from." if not allChannels: for channel in channels: for subType in subData.findTypes(channel.channelID): if subType not in subTypes: subTypes[subType] = True else: for subType in allSubTypes(False): subTypes[subType] = True while True: await unsubPrompts.removePrompt.editMsg(message, subTypes) if isinstance(cmd, commands.Context): result = await message.legacyPost(cmd) else: result = await message.post(cmd, True, True) if result.responseType: if result.buttonID == "cancel": return UnsubscriptionResponse(False) if result.buttonID == "submit": unsubbed = [] for subType in subTypes: if not subTypes[subType]: unsubbed.append(subType) return UnsubscriptionResponse(True, unsubbed, channels) if result.buttonID == "select": allSubs = True for subType in subTypes: if subTypes[subType]: allSubs = False for subType in subTypes: subTypes[subType] = allSubs else: subTypes[ result.buttonID] = not subTypes[result.buttonID] else: return UnsubscriptionResponse(False)
async def subAll(cmd: Union[commands.Context, discord.Interaction], message: YagooMessage, server: dict, channelId: str, db: mysql.connector.MySQLConnection, category: str = None): """ Subscribes to all channels (in a category if specified, every channel if otherwise). Arguments --- cmd: Context or interaction from the invoked command. bot: The Discord bot. message: The message that will be used for prompts. server: The server as a `dict` containing `subDefault` and other subscription types. channelId: The channel ID of the current Discord channel. db: An existing MySQL connection to reduce unnecessary connections. category: The category filter for subscribing to channels within the category. Returns --- A `dict` with: - status: `True` if the subscription command was executed successfully. - subbed: A list containing the subscribed subscription types. """ channel = await botdb.getAllData("channels", ("id", "twitter"), category, "category", db=db) subDefault = await subUtils.checkDefault(server) twitter = [] channels = [] for ch in channel: if ch["id"]: channels.append(ch["id"]) if ch["twitter"]: twitter.append(ch["twitter"]) if category is None: category = "" else: category += " " if subDefault == [''] or subDefault is None: subDefault = [] message.resetEmbed() message.embed.title = f"Subscribing to all {category}VTubers" message.embed.description = "Pick the notifications to be posted to this channel.\n" \ "(This prompt can be bypassed by setting a default subscription type " \ "using the `subDefault` command)" result = await subPrompts.subTypes.prompt(cmd, message) if isinstance(result, SubscriptionData): for subType in result.subList: if result.subList[subType]: subDefault.append(subType) else: return SubscriptionResponse(False) for subType in subDefault: serverType = await botdb.listConvert(server[subType]) if serverType is None: serverType = [] if subType != "twitter": newData = list(set(serverType) | set(channels)) else: newData = list(set(serverType) | set(twitter)) await botdb.addData((channelId, await botdb.listConvert(newData)), ("channel", subType), "servers", db) return SubscriptionResponse(True, subDefault)
async def subOne(cmd: commands.Context, message: YagooMessage, server: dict, channelId: str, channels: List[YouTubeChannel], db: mysql.connector.MySQLConnection): """ Subscribes to one/multiple channel(s) with the specified channel ID(s). Arguments --- cmd: Context or interaction from the executed command. msg: The message that will be used as a prompt. server: The server as a `dict` containing `subDefault` and other subscription types. channelId: The channel ID of the current Discord channel. channels: A `list` of `YouTubeChannel` of the currently being subscribed channels. db: An existing MySQL connection to reduce unnecessary connections. Returns --- An instance of `SubscriptionResponse` """ subDefault = await subUtils.checkDefault(server) subbed = [] if len(channels) > 1: ytChName = "Multiple Channels" else: ytChName = channels[0].channelName if subDefault == [''] or subDefault is None: message.resetEmbed() message.embed.title = f"Subscribing to {ytChName}" message.embed.description = "Pick the notifications to be posted to this channel.\n" \ "(This prompt can be bypassed by setting a default subscription type " \ "using the `subDefault` command)" result = await subPrompts.subTypes.prompt(cmd, message) if isinstance(result, YagooViewResponse): return SubscriptionResponse(False) subDefault = [] for subType in result.subList: if result.subList[subType]: subDefault.append(subType) for channel in channels: for subType in subDefault: stData = await botdb.listConvert(server[subType]) if not stData: stData = [] if subType == "twitter": twitter = (await botdb.getData(channel.channelID, "id", ("twitter", ), "channels", db))["twitter"] if twitter is not None: if twitter not in stData: stData.append(twitter) server[subType] = await botdb.listConvert(stData) await botdb.addData( (channelId, await botdb.listConvert(stData)), ("channel", subType), "servers", db) if subType not in subbed: subbed.append(subType) else: if channel.channelID not in stData: stData.append(channel.channelID) server[subType] = await botdb.listConvert(stData) await botdb.addData( (channelId, await botdb.listConvert(stData)), ("channel", subType), "servers", db) if subType not in subbed: subbed.append(subType) if len(channels) <= 5: channelNames = [] for channel in channels: channelNames.append(channel.channelName) else: channelNames = [f"{len(channels)} channels"] return SubscriptionResponse(True, subbed, channelNames=channelNames)
async def channelSearch(cmd: Union[commands.Context, discord.Interaction], bot: commands.Bot, message: YagooMessage, channel: str, action: str = "subscribe"): """ Searches for a channel with input from the user. Arguments --- ctx: Context or interaction from the invoked command. bot: The Discord bot. message: The message that will be used for the prompt. channel: The name of the channel if already provided by the user. action: The action that is currently is being done with this search. Result --- A `dict` with: - status: `True` if the user successfully searches for a VTuber. - channelID: The channel ID of the VTuber channel. - channelName: The name of the channel. """ wikiName = await FandomScrape.searchChannel(channel) while True: if wikiName.status.cannotMatch: wikiName = await subPrompts.searchPick(cmd, message, channel, wikiName) if not wikiName.status.matched: return FandomChannel() uConfirm = await subPrompts.vtuberConfirm.prompt( cmd, message, wikiName.channelName, action) if uConfirm.responseType: if uConfirm.buttonID == "confirm": break elif uConfirm.buttonID == "results": wikiName.cannotMatch() else: return FandomChannel() else: return FandomChannel() channelData = await FandomScrape.getChannelURL(wikiName.channelName) if channelData.success: db = await botdb.getDB(bot.pool) if not await botdb.checkIfExists(channelData.channelID, "id", "channels", db): message.resetEmbed() message.embed.title = "Getting Channel Data..." message.embed.description = "This channel is new in the database.\nPlease wait while we're getting the channel's info." message.embed.color = discord.Color.from_rgb(0, 0, 0) message.msg = await message.msg.edit(content=None, embed=message.embed, view=None) chData = await subUtils.addChannel(channelData.channelID, channelData.channelName, ("id", "name"), db) else: chData = await botdb.getData(channelData.channelID, "id", ("id", "name"), "channels", db) return FandomChannel(True, chData["id"], chData["name"]) return FandomChannel()