def dice_em(result: list, sep: str = ', ') -> Embed: sep = f'**{sep}**' if len(result) == 1: return Embed(title=':game_die: Rzut kością', description=f'Wynik: **{result[0]}**.', color=Color.dark_red()) else: return Embed(title=':game_die: Rzut kośćmi', description=f'Wyniki: **{sep.join(result)}**.', color=Color.dark_red())
def black_jack_embed(user: User, player, outcome: str = None, hidden: bool = True) -> Embed: """ Creates embed based on set of constraints for blackjack :param user: discord.User :param player: player object for blackjack :param outcome: blackjack game outcome :param hidden: dealer card value :return: discord.Embed """ embed = black_jack_template(user, player, "", Color.gold()) embed.add_field(name="Dealer hand", value=player.game.get_emote_string(hidden=hidden)) if outcome == "win": embed.colour = Color.dark_green() embed.description = "**Outcome:** You won!" elif outcome == "lose": embed.colour = Color.dark_red() embed.description = "**Outcome:** You lost!" elif outcome == "tie": embed.colour = Color.dark_grey() embed.description = "**Outcome:** It's a tie!" return embed
def goodbye(message: str) -> Embed: """ Constructs goodbye embed with fixed title 'Goodbye' and red color. :param message: embed description :return: Embed object """ return simple_embed(message, "Goodbye", color=Color.dark_red())
async def play(self) -> None: """Start the main game loop.""" await self.send_status() HangmanGame.players[self.guild][self.channel].append(self.player) while self.player in HangmanGame.players[self.guild][self.channel]: guess = await self.get_guess() guess_status = await self.apply_guess(guess) if guess_status is False: embed = Embed( title="Game aborted", description="You aborted the game.", color=Color.dark_red() ) await self.channel.send(embed=embed) return await self.send_status(guess, guess_status) if state := self.is_finished(): if state == 1: embed = Embed( title="You won", description=":tada: You won the game!", color=Color.green() ) await self.channel.send(embed=embed) elif state == 2: embed = Embed( title="You lost", description="You ran out of guesses.", color=Color.green() ) await self.channel.send(embed=embed) return
def random(): c = [ Color.teal(), Color.dark_teal(), Color.green(), Color.dark_green(), Color.blue(), Color.dark_blue(), Color.purple(), Color.dark_purple(), Color.magenta(), Color.dark_magenta(), Color.gold(), Color.dark_gold(), Color.orange(), Color.dark_orange(), Color.red(), Color.dark_red(), Color.lighter_grey(), Color.darker_grey(), Color.blurple(), tan, icedcoffee, chilipepper ] return c[randint(0, len(c) - 1)]
def __init__(self, client): self.client = client self.client_color = Color.red() self.color_dict = { 1: [Color.teal(), 'teal'], 2: [Color.dark_teal(), 'dark_teal'], 3: [Color.green(), 'green'], 4: [Color.dark_green(), 'dark_green'], 5: [Color.blue(), 'blue'], 6: [Color.dark_blue(), 'dark_blue'], 7: [Color.purple(), 'purple'], 8: [Color.dark_purple(), 'dark_purple'], 9: [Color.magenta(), 'magenta'], 10: [Color.dark_magenta(), 'dark_magenta'], 11: [Color.gold(), 'gold'], 12: [Color.dark_gold(), 'dark_gold'], 13: [Color.orange(), 'orange'], 14: [Color.dark_orange(), 'dark_orange'], 15: [Color.red(), 'red'], 16: [Color.dark_red(), 'dark_red'], 17: [Color.lighter_grey(), 'lighter_grey'], 18: [Color.dark_grey(), 'grey'], 19: [Color.light_grey(), 'light_grey'], 20: [Color.darker_grey(), 'darker_grey'] }
def random(): # type: () -> Color tan = Color(0xBEAA3E) return choice([ Color.teal(), Color.dark_teal(), Color.green(), Color.dark_green(), Color.blue(), Color.dark_blue(), Color.purple(), Color.dark_purple(), Color.magenta(), Color.dark_magenta(), Color.gold(), Color.dark_gold(), Color.orange(), Color.dark_orange(), Color.red(), Color.dark_red(), Color.lighter_grey(), Color.darker_grey(), Color.blurple(), tan, ])
async def on_member_ban(self, guild: Guild, user: t.Union[User, Member]) -> None: if self.bot.log_is_ignored(Event.member_ban, (guild.id, user.id)): return unban_log_entry = await last_audit_log_with_fail_embed( guild, actions=[AuditLogAction.ban], send_callback=partial(self.send_log, guild), target=user) if unban_log_entry is None: return embed = Embed(title="User banned", description=textwrap.dedent(f""" **User:** {user.mention} **Author:** {unban_log_entry.user.mention} **Reason:** {unban_log_entry.reason if unban_log_entry.reason else "N/A"} """), color=Color.dark_red()) embed.set_thumbnail(url=user.avatar_url) embed.set_footer(text=f"User ID: {user.id}") embed.timestamp = unban_log_entry.created_at await self.send_log(guild, embed=embed)
async def send_wordle_embed(self, ctx, wordle, guesses, header_str): """ Generates the wordle image, host it on imgur and send the it as an interaction response -- input: ctx: interactions.CommandContext wordle: wordle.Wordle guesses: List[str] header_str: str """ img_path = "wordle_tmp.png" wordle.generate_image(guesses, img_path) link = utils.upload_image_to_imgur(img_path) os.remove(img_path) color = Color.gold() if len(guesses) > 0 and guesses[-1] == wordle.solution: color = Color.dark_green() elif len(guesses ) == wordle.nb_trials and guesses[-1] != wordle.solution: color = Color.dark_red() embed = Embed(title="Wordle", description=header_str, color=color.value, image=EmbedImageStruct(url=link)._json) await ctx.send(embeds=embed, ephemeral=True)
def random(): # type: () -> Color chilipepper = Color(0x9B1B30) tan = Color(0xBEAA3E) icedcoffee = Color(0xB18F6A) return choice([ Color.teal(), Color.dark_teal(), Color.green(), Color.dark_green(), Color.blue(), Color.dark_blue(), Color.purple(), Color.dark_purple(), Color.magenta(), Color.dark_magenta(), Color.gold(), Color.dark_gold(), Color.orange(), Color.dark_orange(), Color.red(), Color.dark_red(), Color.lighter_grey(), Color.darker_grey(), Color.blurple(), tan, icedcoffee, chilipepper, ])
async def send_status(self, guess: t.Optional[str] = None, guess_status: t.Optional[t.Literal[0, 1, 2, 3]] = None) -> None: """Get current game status as embed.""" embed = Embed( title="Hangman", color=Color.dark_green(), ) embed.add_field( name="**❯❯ Status**", value=f"```\n{HangmanGame.stages[self.tries]}```", inline=False ) embed.add_field( name="**❯❯ Word**", value=f"**{self.display_word}**", inline=False ) if guess: description = f"Letter {guess}" if guess_status == 0: description += " isn't in the word" color = Color.red() elif guess_status == 1: description += " is in the word" color = Color.green() elif guess_status == 2: description += " isn't valid" color = Color.dark_red() elif guess_status == 3: description += " was already guessed." color = Color.dark_red() guess_embed = Embed( description=description, color=color ) await self.channel.send(embed=guess_embed, delete_after=5) embed.set_footer( text=f"{config.COMMAND_PREFIX}hangexit to exit the game! | Powered By HotWired." ) if hasattr(self, "message"): await self.message.edit(embed=embed) else: self.message = await self.channel.send(embed=embed)
def __init__(self, webhook): self.webhook = webhook self.level_color = { "INFO": Color.light_grey(), "WARNING": Color.gold(), "ERROR": Color.dark_red(), "CRITICAL": Color.red(), "DEBUG": Color.dark_green(), "NOTSET": Color.dark_grey(), } super(DiscordHandler, self).__init__()
async def treset(self, ctx): if self.tournament.status in (2, 3, 4): raise commands.BadArgument( f"The tournament is ongoing and cannot be reset. Please try to use `;cancel` instead." ) self.tournament = Tournament() await ctx.send( f"{Emote.check} The tournament has succesfully been reset.") Log("Tournament Reset", description= f"{ctx.author.mention} has reset the tournament to default values.", color=Color.dark_red())
async def ninerr(self, ctx, errcode: str): """Parses Nintendo 3DS error codes.""" err = errcode[0:8] if re.match('[0-1][0-9][0-9]\-[0-9][0-9][0-9][0-9]', err) == None: await self.bot.say( "Wrong format. Error codes use the format `###-####`.") return embed = discord.Embed( title=err + (": Nintendo 3DS" if err[0] == "0" else ": Wii U")) embed.url = "http://www.nintendo.com/consumer/wfc/en_na/ds/results.jsp?error_code={}&system={}&locale=en_US".format( err, "3DS" if err[0] == "0" else "Wiiu") if err not in self.errcodes: embed.description = "I don't know this one! Click the error code for details on Nintendo Support.\n\nIf you keep getting this issue and Nintendo Support does not help, or know how to fix it, you should report relevant details to <@78465448093417472> so it can be added to the bot." else: embed.description = self.errcodes[err] embed.color = (Color.dark_red() if err[0] == "0" else Color.blue()) await self.bot.say("", embed=embed)
async def on_message_delete(self, msg): if msg.author.bot: return if isinstance(msg.channel, DMChannel): return # ignore, this is handled in modmail for dm's user = msg.author if msg.content is None or msg.content == "": return emb = Embed(title="Message Deleted", color=Color.dark_red()) emb.add_field(name="Message:", value=msg.content, inline=True) emb.add_field(name="User:"******"{user.name}#{user.discriminator}\n<{user.id}>") emb.set_thumbnail(url=user.avatar_url) await self.bot.msglogs_channel.send("", embed=emb)
def bot_info_em(bot: Bot) -> Embed: return Embed( title=bot.user.name, description='\u200b', color=Color.dark_red() ).add_field( name='Właściciel', value=bot.get_user(bot.owner_id) ).add_field( name='Wersja', value=bot.version or 'Nieznana' ).add_field( name='Kod źródłowy', value='GitHub: <https://github.com/AnonymousX86/poland-bot>', inline=False ).set_thumbnail( url=bot.user.avatar_url )
async def on_member_remove(self, member): if member.guild.id == 497097726400528394: em = Embed( title=f"{member.name} left the guild.", description= f":wave: - Sorry to see you go {member.name}#{member.discriminator}, return again soon!", timestamp=datetime.utcnow(), color=Color.dark_red(), ) em.set_author( name="Aurora", icon_url= "https://cdn.discordapp.com/icons/497097726400528394/00453191715921c03ca41dbe8b1a0569.png?size=128", ) em.set_image( url= "https://cdn.discordapp.com/attachments/663351785293086720/718843903561695282/Aurora_Farewell_Banner.jpg" ) await member.guild.get_channel(718798993852727317).send(embed=em)
async def on_raw_message_delete(self, payload: RawMessageDeleteEvent) -> None: """ Send an embed whenever uncached message got deleted, we do not have the previous contents of this message, so we can only send the the fact that it was actually deleted, and channel it happened in. This listener trigers whenever a message is deleted, this includes the messages that are cached and trigger `on_message_delete` directly, which means we have to ignore these. In case this wasn't the case, we may log the embed (with some further checks which are also present in `on_message_edit`, such as DM check). """ guild = self.bot.get_guild(payload.guild_id) if not guild: return # Sleep for a while to leave enough time for normal event to execute, which will add this # channel into the handled cached set, to avoid double logging await asyncio.sleep(1) if (payload.guild_id, payload.message_id) in self._handled_cached: return if self.bot.log_is_ignored(Event.message_delete, (guild.id, payload.message_id)): return channel = self.bot.get_channel(payload.channel_id) embed = Embed(title="Uncached message deleted", description=textwrap.dedent(f""" **Channel:** {channel.mention if channel else 'Unable to get channel'} **Content:** This message is an uncached message, content can't be displayed """), color=Color.dark_red()) embed.timestamp = datetime.datetime.utcnow() embed.set_footer(text=f"Message ID: {payload.message_id}") await self.send_log(guild, embed=embed)
async def on_command_error(ctx, error): """Triggered when a command send an error Decorators: BOT.event Arguments: ctx {Context} -- Context of the message error {Exception} -- Discord error """ content = dict(colour=Color.dark_red()) critical(ctx.command, error) field = dict(name="Error", inline=False) if isinstance(error, errors.NoPrivateMessage): field["value"] = ":warning: This command cannot be used in private messages." elif isinstance(error, errors.CommandOnCooldown): field["value"] = ":stopwatch: This command is on cooldown, \ retry after {:.2f} seconds".format(error.retry_after) elif isinstance(error, errors.DisabledCommand): field["value"] = "This command is disabled and cannot be used." elif isinstance(error, errors.CommandNotFound): field["value"] = ":grey_question: Unknown command. \ Use `{}help` to get commands".format(ctx.prefix) elif isinstance(error, errors.MissingPermissions): field["value"] = ":no_entry_sign: {}".format(error.message) elif isinstance(error, errors.MissingRequiredArgument): field["value"] = "An argument is missing" elif isinstance(error, errors.CheckFailure): field["value"] = ":no_entry_sign: At least 1 check has failed" elif isinstance(error, errors.NotOwner): field["value"] = ":no_entry_sign: You are not the owner of the bot" elif isinstance(error, errors.CommandInvokeError): field["value"] = ":stop_sign: The command {} has thrown an error.".format(ctx.command) critical('In {0.command.qualified_name}:'.format(ctx)) print_tb(error.original.__traceback__) critical('{0.__class__.__name__}: {0}'.format(error.original)) content["fields"] = field message = create_embed(content) await ctx.author.send(embed=message)
def create_embed(lang="de"): embed = Embed(title=f'Willkommen!', color=Color.dark_red(), url="https://github.com/bundestagsBot/bundestagsBot") embed.timestamp = datetime.utcnow() try: if lang == "de": embed.description = welcome_de.format( cfg.options["channel_ids"]["roles"][0], cfg.options["channel_ids"]["welcome"][0], cfg.options["channel_ids"]["bot"][0], cfg.options["channel_ids"]["suggestions"][0]) except KeyError: SHL.output( f"{red}Could not send full Embed. Please check if you applied all needed configuration.{white}" ) embed.description = "__**Welcome**__" except IndexError: SHL.output( f"{red}Could not send full Embed. Please check if you applied all needed configuration.{white}" ) embed.description = "__**Welcome**__" return embed
import pytz import discord from discord import Color from cogs.misc import LikeUser, FakeMember colours = { 'unban': Color.green(), 'unmute': Color.dark_green(), 'note': Color.light_grey(), 'warn': Color.orange(), 'mute': Color.dark_purple(), 'kick': Color.dark_orange(), 'softban': Color.red(), 'ban': Color.dark_red() } async def ban(victim: discord.Member, reason: str = None): await victim.guild.ban(victim, reason=reason) async def softban(victim: discord.Member, reason: str = None): await victim.guild.ban(victim, reason=reason) await victim.guild.unban(victim, reason=reason) async def kick(victim: discord.Member, reason: str = None): await victim.guild.kick(victim, reason=reason)
async def on_message_delete(self, message: Message) -> None: """ Send a log message whenever any sent message is removed. This is useful for moderation purposes, because users often try to hide what they send, to avoid getting caught breaking some rules, logging the content of these messages will prevent that. Messages can sometimes get quite long, and we don't want to clutter the log with them, if this is the case, we upload this message to a paste service and only provide a link. """ # Add this message to set of ignored messages for raw events, these trigger even if # the message was cached, and to prevent double logging, we need to ignore them self._handled_cached.add((message.guild.id, message.id)) if self.is_ignored(message, Event.message_delete): return # Add message to ignore list, to prevent raw event on executing self.bot.log_ignore(Event.message_delete, (message.guild.id, message.id)) response = ( f"**Author:** {message.author.mention}\n" f"**Channel:** {message.channel.mention}\n" f"**Initially created: ** {time_elapsed(message.created_at, max_units=3)}" ) if message.attachments: readable_attachments = ', '.join( attachment.filename for attachment in message.attachments) response += f"\n**Attachment file-name{'s' if len(message.attachments) > 1 else ''}:** {readable_attachments}" # Limit log embed to avoid huge messages cluttering the log, # if message is longer, upload it instead. if len(message.clean_content) > MAX_LOGGED_MESSAGE_SIZE: # NOTE; Text uploading might be happening too often, and might have to be removed # in the future url = await upload_text( self.bot.http_session, message.content, file_name="message.md", paste_name="Automatic message upload.", paste_description= "This paste was automatically generated from removed discrod message." ) if url: response += f"\n**Content:** Message too long, check [message upload]({url})" else: response += "\n**Contet:** Message too long (WARNING: Automatic upload failed)" else: response += f"\n**Content:** {message.content}" response += f"\n[Jump link]({message.jump_url})" embed = Embed(title="Message deleted", description=response, color=Color.dark_red()) embed.timestamp = datetime.datetime.utcnow() embed.set_footer(text=f"Message ID: {message.id}") await self.send_log(message.guild, embed=embed)
async def fetch_track(self): """Task for fetching warzone matches of tracked users.""" logging.info("Starting warzone tracking...") tracked = session.query(wz_model).filter_by(track=True).all() if not len(tracked): return embed_color = [ Color.gold(), Color.light_grey(), Color.dark_orange(), Color.dark_red() ] matches = dict() async with aiohttp.ClientSession() as aiosession: try: await aiosession.get("https://profile.callofduty.com/cod/login" ) cookies = aiosession.cookie_jar.filter_cookies( "https://callofduty.com") params = { "username": getenv("COD_USERNAME"), "password": getenv("COD_PASSWORD"), "remember_me": "true", "_csrf": cookies["XSRF-TOKEN"].value, } await aiosession.post( "https://profile.callofduty.com/do_login?new_SiteId=cod", params=params, allow_redirects=False) except Exception as e: logging.error("Could not acquire session for warzone tracking") return for t in tracked: try: battletag = requests.utils.quote(t.battletag) url = f"https://my.callofduty.com/api/papi-client/crm/cod/v2/title/mw/platform/battle/gamer/{battletag}/matches/wz/start/0/end/0/details?limit=1" async with aiosession.get(url) as resp: response = await resp.json() player_match = response["data"]["matches"][0] player_match["channel_id"] = t.channel_id now = int(datetime.utcnow().strftime("%s")) if t.last_match == player_match[ "matchID"] or now - player_match[ "utcEndSeconds"] > 30 * 60: continue matches.setdefault(player_match["matchID"], dict()).setdefault( player_match["player"]["team"], list()).append(player_match) t.last_match = player_match["matchID"] except Exception as e: logging.error( f"Could not retrieve warzone history for {t.battletag}", exc_info=e) for match in matches.values(): for team in match.values(): p0 = team[0] channel = self.bot.get_channel(p0["channel_id"]) ordinal = lambda n: f'{n}{"tsnrhtdd"[(n//10%10!=1)*(n%10<4)*n%10::4]}' placement = int(p0["playerStats"]["teamPlacement"]) placement_color = placement - 1 if placement < 4 else -1 embed = Embed( title= f"{p0['player']['username']}'s team finished in __{ordinal(placement)}__ against {p0['teamCount']} teams.", color=embed_color[placement_color], timestamp=datetime.fromtimestamp(p0["utcStartSeconds"]), ) embed.add_field( name="Match duration", value=f"{int(p0['duration'] // 60000)} minutes", inline=True) embed.add_field( name="Team survived", value= f"{int(p0['playerStats']['teamSurvivalTime']) // 60000} minutes", inline=True, ) embed.add_field(name=chr(173), value=chr(173), inline=True) # field skip for player in team: stats = f"""**KDA:** {round(player["playerStats"]["kdRatio"], 2)} **Kills:** {int(player["playerStats"]["kills"])} **Deaths:** {int(player["playerStats"]["deaths"])} **Damage:** {int(player["playerStats"]["damageDone"])} """ embed.add_field(name=player["player"]["username"], value=inspect.cleandoc(stats), inline=True) await channel.send(embed=embed) session.commit() logging.info("Warzone tracking finished.")
async def shutdown(self, ctx): """Shut down the bot and whole script Lol""" await ctx.channel.send("Ok") await ctx.bot.config.channels.status.send( embed=Embed(title="<:offline:708886391672537139> shutting Down.....", color=Color.dark_red()) ) exit()
async def on_guild_remove(self, guild: Guild): embed = Embed( title=f"Left guild: {guild}", description=f"ID: {guild.id}", color=Color.dark_red() ).set_thumbnail(url=guild.icon.url if guild.icon else None) await self.bot.status_channels.Guilds.send(embed=embed)
async def on_member_ban(self, guild, user): await self.logembed(user, "Banned", Color.dark_red())
async def check_expired_roles(self): """ Function checks for expired users on community nad removes them if necessary """ print(Fore.GREEN + f"{get_time()} --> CHECKING FOR USERS WITH EXPIRED ROLES ") now = datetime.utcnow().timestamp( ) # Gets current time of the system in unix format merchant_manager = self.backoffice.merchant_manager overdue_members = merchant_manager.get_over_due_users( timestamp=int(now)) # Gets all overdue members from database bot = self.bot if overdue_members: bot_guilds = [guild for guild in bot.guilds ] # get all guilds bot has access to for mem in overdue_members: mem_id = mem['userId'] mem_role_id = mem['roleId'] mem_role_community_id = mem['communityId'] # Check if community where role was created still has bot if [ guild.id for guild in bot_guilds if mem_role_community_id == guild.id ]: # get guild and member guild = bot.get_guild(id=mem_role_community_id) member = guild.get_member(mem_id) # Check if member still exists if member in guild.members: role = guild.get_role( role_id=mem_role_id) # Get the role if role: if role in member.roles: await member.remove_roles( role, reason= 'Merchant notification -> Role expired') if merchant_manager.remove_overdue_user_role( community_id=mem_role_community_id, role_id=mem_role_id, user_id=mem_id): expired = discord.Embed( name=':timer: Expired Role :timer: ', title= '__Role Expiration Notification__', description= 'Your membership has expired. Please check ' 'details below.', color=Color.dark_red()) expired.set_thumbnail( url=bot.user.avatar_url) expired.add_field( name= ':bank: Origin of role expiration:bank: ', value=guild.name, inline=False) expired.add_field( name= ":man_juggling: Expired Role :man_juggling: ", value=f'```{role.name}```') expired.add_field( name= ":information_source: Information :information_source: ", value= " In order to obtain back all privileges please re-purchase" " the role directly from the community." ) await member.send(embed=expired) else: channel_sys = channels["merchant"] # send notification to merchant for system if user could not be removed from database expired_sys = discord.Embed( title= '__Expired user could not be removed from system__', colour=discord.Color.red()) expired_sys.set_thumbnail( url=bot.user.avatar_url) expired_sys.add_field(name='Community', value=guild.name, inline=False) expired_sys.add_field(name="Expired Role", value=role.name) expired_sys.add_field( name="User details", value=f'Role ID: {mem_role_id}\n' f'Community ID: {mem_role_community_id}\n' f'Member ID: {mem_id}') merch_channel = bot.get_channel( id=int(channel_sys)) await merch_channel.send(embed=expired_sys) else: merchant_manager.remove_overdue_user_role( community_id=mem_role_community_id, user_id=mem_id, role_id=mem_role_id) else: merchant_manager.remove_monetized_role_from_system( role_id=mem_role_id, community_id=mem_role_community_id) merchant_manager.bulk_user_clear( community_id=mem_role_community_id, role_id=mem_role_id) else: merchant_manager.delete_user_from_applied( community_id=mem_role_community_id, user_id=mem_id) else: merchant_manager.bulk_user_clear( community_id=mem_role_community_id, role_id=mem_role_id) merchant_manager.remove_all_monetized_roles( guild_id=mem_role_community_id) else: print(Fore.GREEN + 'There are no overdue members in the system going to sleep!') print( '===========================================================')
async def commands(message, client): if message.content.startswith('>help'): txt = "" txt += "**FONCTIONS D\'ANIMATION DU DISCORD**\n" txt += "-----------------------------------\n" txt += ':dog2: | **>ordre** : Donne un ordre à Ohana.\n' txt += '> Paramètres :\n' txt += '> *assis*, *couché* ou *patte* | Liste non exhaustive.A toi de trouver les autres :upside_down:.\n' txt += '> Exemple : **>ordre patte chien**\n' txt += ':frame_photo: | **>race** : affiche une race d\`une espèce aléatoire.\n' txt += '> Paramètres :\n' txt += '> *chien* :dog:, *chat* :cat: ou *cheval* :horse: | Permet de préciser l\'espèce dont la race tirée au sort est associée.\n' txt += '> Exemple : **>race chien**\n' txt += ':teacher: | **>anecdote** : affiche une anecdote sur les animaux.\n' txt += "\n" txt += "**FONCTIONS POUR LES QUIZ**\n" txt += "-----------------------------------\n" txt += ':question: | **>quiz** : commande globale pour toutes les commandes liées aux quiz.\n' txt += '> Paramètres :\n' txt += '> *planning* :calendar: | Affiche la liste des quiz avec leur date.\n' txt += '> *classement* :crown: | Affiche le classement en cours (mois courant).\n' txt += '> *rappel* :notepad_spiral: | Gestion de la liste des joueurs de quiz qui veulent un rappel 10 minutes avant les quiz.\n' txt += "\n" txt += "**FONCTIONS DE GESTION DU DISCORD**\n" txt += "-----------------------------------\n" # txt += ':bar_chart: **>utilisateurs** : affiche des statistiques sur les utilisateurs du Discord.\n' # txt += ':bar_chart: **>messages** : affiche des statistiques sur les messages postés sur le Discord.\n' # txt += ':calendar: **>algo** : affiche le lien vers le flowchart du bot.\n' txt += ':calendar: **>code** : affiche le lien vers la roadmap du bot.\n' txt += ':computer: **>data** : regénère les fichiers de données pour mettre à jour les statistiques.\n' await message.channel.send(txt) if message.content.startswith('>test'): commands = [ '>help', '>race', '>race chat', '>race chien', '>race cheval', '>anecdote', '>ordre assis', '>ordre couché', '>ordre patte', '>ordre high five', '>ordre belle', '>utilisateur', '>messages', '>code', '>data' ] for command in commands: await message.channel.send(command) await asyncio.sleep(1) # INTERACTIONS COMMANDS if message.content.startswith('>ordre'): await functions.apply_order(message) if message.content.startswith('>anecdote'): await functions.anecdote(message) if message.content.startswith('>race'): await functions.race(message) # QUIZ COMMANDS if message.content.startswith('>quiz planning'): import pandas as pd df = pd.read_excel("inputs/xlsx/planning.xlsx") def category(cat): if "Chien" in cat: return ":dog2:" if "Chat" in cat: return ":cat2:" if "Cheval" in cat: return ":racehorse:" if "Oiseau" in cat: return ":bird:" if "NAC" in cat: return ":rabbit2:" if "?" in cat: return ":interrobang:" return ":feet:" txt = "**QUIZ PASSÉS**\n" separator_added = False for id, row in df.iterrows(): # Date Titre Catégorie ts = pd.to_datetime(str(row['Date'])) date = ts.strftime('%d/%m/%Y') d, m, y = date.split("/") d = functions.rank_to_emote(d, type="date") m = functions.rank_to_emote(m, type="date") y = functions.rank_to_emote(y, type="date") import datetime if (ts > datetime.datetime.now() and not separator_added): txt += "**QUIZ FUTURS**\n" separator_added = True # txt += "{}/{}/{} : {} {}\n".format(d,m,y, row['Titre'], category(row['Catégorie'])) txt += ":arrow_forward: {} {} : {}\n".format( category(row['Catégorie']), date, row['Titre']) if len(txt) > 1000: am = discord.AllowedMentions(everyone=False, users=False, roles=False, replied_user=False) await message.channel.send(txt, allowed_mentions=am) txt = "" am = discord.AllowedMentions(everyone=False, users=False, roles=False, replied_user=False) await message.channel.send(txt, allowed_mentions=am) if message.content.startswith('>question'): import pandas as pd df = pd.read_csv("inputs/csv/fci.csv", delimiter="\t") l = list() for key, row in df.sample().iterrows(): r = row while r['id'] in l: for key, row in df.sample().iterrows(): r = row l.append(r['id']) id_b = r['id'] name_b = r['name_fr'] country_b = r['country'] propositions = list() propositions.append(country_b) await message.channel.send("De quel pays provient la race : " + name_b.title()) rows_same_country = df[df['country'] == country_b] rows_diff_country = df.merge( rows_same_country, how='outer', indicator=True).loc[lambda x: x['_merge'] == 'left_only'] other_responses = rows_diff_country.sample(3) for key, row in other_responses.iterrows(): propositions.append(row['country'].title()) for p in propositions: await message.channel.send("- {}".format(p.title())) await message.channel.send(":star: Réponse : ||" + country_b.title() + "||") if message.content.startswith('>quiz classement'): quiz.prepare_csv() functions.create_podium() df_members = pd.read_csv("outputs/members.csv") def get_discriminator(author): return author.split("#")[-1] df_quizz = pd.read_csv("outputs/charts/classement.csv") df_quizz['discriminator'] = df_quizz.apply( lambda x: get_discriminator(x['Username']), axis=1) df_members['discriminator'] = df_members['discriminator'].astype(int) df_quizz['discriminator'] = df_quizz['discriminator'].astype(int) df = df_quizz.merge(df_members, how="left", suffixes=('_quizz', '_data')) await message.channel.send(file=discord.File('outputs/podium.png')) txt = "Classement du mois :\n" for key, row in df.head(10).iterrows(): print(row['id' '']) txt += "{}\n{} [<@{}>]\n:homes: {} |:1234: {}pts\n".format( functions.rank_to_emote(key + 1), row['display_name'].split("-")[0].strip(), row['id'], row['refuge'], row['Points']) if len(txt) > 1000: am = discord.AllowedMentions(everyone=False, users=False, roles=False, replied_user=False) await message.channel.send(txt, allowed_mentions=am) txt = "" am = discord.AllowedMentions(everyone=False, users=False, roles=False, replied_user=False) await message.channel.send(txt, allowed_mentions=am) # await functions.order_not_available(message); if message.content.startswith('>bug'): from discord.utils import get user = get(message.guild.members, name="Cédric") if user: await user.send(content=message.author.name) await user.send(content=message.content) else: print("NON") if message.content.startswith('>quiz rappel'): await functions.order_not_available(message) # ADMIN COMMANDS if message.content.startswith('>algo'): await functions.order_not_available(message) if message.content.startswith('>utilisateurs'): # await functions.order_not_available(message); # return df = pd.read_csv("outputs/members.csv") cjs = df['refuge'].unique() cjs = sorted(cjs) roles = [ 'Administrateurs', 'Modérateurs', 'Responsables de refuge', 'Agents animaliers', 'Référents', 'Encadrants', 'Jeunes' ] colors = dict() colors['Administrateurs'] = Color.red() colors['Modérateurs'] = Color.orange() colors['Responsables de refuge'] = Color.green() colors['Agents animaliers'] = Color.teal() colors['Référents'] = Color.purple() colors['Encadrants'] = Color.blue() colors['Jeunes'] = Color.gold() colors['Non présentés'] = Color.dark_red() for cj in cjs: await message.channel.send(":map: **{}** :map:".format(cj)) df_temp = df[df['refuge'] == cj] for role in roles: l = list() for key, row in df_temp[df_temp['top_role'] == role].iterrows(): l.append(row['display_name']) if len(l) > 0: l = sorted(l) emeb = discord.Embed(title=role, description="\n".join(l), color=colors[role]) await message.channel.send(embed=emeb) if message.content.startswith('>messages'): import time start_time = time.time() await message.channel.send('Bien reçu ! Je vais compter les messages.') await message.channel.send('Je reviens dans quelques secondes ...') df = pd.read_csv("outputs/csv/messages.csv") import seaborn as sns top_five = df['channel'].value_counts().keys()[:5] df_temp = df[df['channel'].isin(top_five)] sns_plot = sns.catplot(y="channel", kind="count", palette="pastel", edgecolor=".6", data=df_temp) sns_plot.savefig("outputs/images/output.png") await message.channel.send('En tout, il y a {} messages.'.format( len(list(df['content'])))) await message.channel.send( 'Répartition dans les salons :', file=discord.File('outputs/images/output.png')) await message.channel.send("J'ai trouvé ce résultat en %d secondes." % int(time.time() - start_time)) return if message.content.startswith('>code'): await message.channel.send( 'Tu veux connaître les prochaines améliorations du bot ? Ca se passe ici !' ) await message.channel.send( 'https://github.com/cedricmaigrot/Discord_laSPA/projects/1') await message.channel.send( 'Tu veux faire ton propre bot comme <@818564026237452350> ? Le code est en open source !' ) await message.channel.send(file=discord.File('inputs/images/work.gif')) if message.content.startswith('>data'): import time start_time = time.time() await message.channel.send('Bien reçu ! Je vais mémoriser les données.' ) await message.channel.send('Je reviens dans quelques secondes ...') for guild in client.guilds: if guild.name in "Clubs Jeunes SPA": # lst = list() # for channel in guild.channels: # print("Channel : " + channel.name) # try: # hist = await channel.history(limit=20000).flatten() # for h in hist: # lst.append([h.activity, h.application, h.attachments, h.author, h.call, h.channel, # h.channel_mentions, h.clean_content, h.content, h.created_at, h.edited_at, # h.embeds, h.flags, h.guild, h.id, h.jump_url, h.mention_everyone, h.mentions, # h.nonce, h.pinned, h.raw_channel_mentions, h.raw_mentions, h.raw_role_mentions, # h.reactions, h.reference, h.role_mentions, h.stickers, h.system_content, h.tts, # h.type, h.webhook_id]) # except: # pass # df_messages = pd.DataFrame(lst, columns=["activity", "application", "attachments", "author", "call", # "channel", "channel_mentions", "clean_content", "content", # "created_at", "edited_at", "embeds", "flags", "guild", "id", # "jump_url", "mention_everyone", "mentions", "nonce", "pinned", # "raw_channel_mentions", "raw_mentions", "raw_role_mentions", # "reactions", "reference", "role_mentions", "stickers", # "system_content", "tts", "type", "webhook_id"]) # df_messages.to_csv("outputs/messages.csv") # df_messages.to_excel("outputs/messages.xlsx") # df_messages.to_html("outputs/messages.html") df_messages = pd.read_excel("outputs/messages.xlsx") lst = list() for member in guild.members: print("Member : " + member.name) lst.append([ member.activities, member.activity, member.avatar, member.avatar_url, member.bot, member.color, member.colour, member.created_at, member.default_avatar, member.default_avatar_url, member.desktop_status, member.discriminator, member.display_name, member.guild, member.guild_permissions, member.id, member.joined_at, member.mention, member.mobile_status, member.name, member.nick, member.pending, member.premium_since, member.public_flags, member.raw_status, member.roles, member.status, member.system, member.top_role, member.voice, member.web_status ]) df_members = pd.DataFrame( lst, columns=[ "activities", "activity", "avatar", "avatar_url", "bot", "color", "colour", "created_at", "default_avatar", "default_avatar_url", "desktop_status", "discriminator", "display_name", "guild", "guild_permissions", "id", "joined_at", "mention", "mobile_status", "name", "nick", "pending", "premium_since", "public_flags", "raw_status", "roles", "status", "system", "top_role", "voice", "web_status" ]) def get_shelter(roles): shelter = "Inconnu" for role in roles: r = discord.utils.get(guild.roles, id=role.id) if "Club Jeunes" in r.name: shelter = r.name print(r.name) return shelter df_members['refuge'] = df_members.apply( lambda x: get_shelter(x['roles']), axis=1) df_members.to_csv("outputs/members.csv") df_members.to_excel("outputs/members.xlsx") df_members.to_html("outputs/members.html") lst = list() for role in guild.roles: print("Role : " + role.name) lst.append([ role.color, role.colour, role.created_at, role.guild, role.hoist, role.id, role.managed, role.members, role.mention, role.mentionable, role.name, role.permissions, role.position, role.tags ]) df_roles = pd.DataFrame(lst, columns=[ "color", "colour", "created_at", "guild", "hoist", "id", "managed", "members", "mention", "mentionable", "name", "permissions", "position", "tags" ]) df_roles.to_csv("outputs/roles.csv") df_roles.to_excel("outputs/roles.xlsx") df_roles.to_html("outputs/roles.html") df_members['discriminator'] = df_members[ 'discriminator'].astype(str) def get_discriminator(author): name = "{}".format(author) return name.split("#")[-1] df_messages['author_discriminator'] = df_messages.apply( lambda x: get_discriminator(x['author']), axis=1) df_messages['author_discriminator'] = df_messages[ 'author_discriminator'].astype(str) df_merge = df_messages.merge(df_members, left_on='author_discriminator', right_on='discriminator', suffixes=('_messages', '_members')) df_merge = df_merge.merge(df_roles, left_on='top_role', right_on='name', suffixes=('', '_role')) # df_messages[(~df_messages['id'].isin(df_merge['id_messages']))]['author'] df_merge.to_html("outputs/merge.html") df_merge.to_csv("outputs/merge.csv") df_merge.to_excel("outputs/merge.xlsx") await message.channel.send('C\'est fait !') await message.channel.send("J'ai fait cela en %d secondes." % int(time.time() - start_time)) return
async def begin_verification(member: Member): main_guild = await get_main_guild() # Create new channel channel_name = f"verification-{generate_id(4)}" # Find the correct category category = find_category_by_id(main_guild, VERIFICATION_CHANNEL_CATEGORY_ID) if not category: raise Exception( f"Could not find category with ID {VERIFICATION_CHANNEL_CATEGORY_ID}" ) permission_overwrites = { main_guild.me: PermissionOverwrite(read_messages=True, send_messages=True, read_message_history=True), member: PermissionOverwrite(read_messages=True, send_messages=True, read_message_history=True), main_guild.default_role: PermissionOverwrite(read_messages=False, send_messages=False) } auth_channel = await main_guild.create_text_channel( channel_name, category=category, overwrites=permission_overwrites, reason=f"Authenticating user {member.id}#{member.discriminator}") random_code = generate_code(4) random_emoji_text, random_emoji_unicode = choice( gets(String.VERIFY_RANDOM_EMOJI_LIST)) await auth_channel.send( gets(String.ON_VERIFICATION_BEGIN).format(user_mention=member.mention)) await auth_channel.send( gets(String.VERIFICATION_HOW).format( code=random_code, random_emoji=random_emoji_text.strip(":"), )) responses = [] embed = None try: failed_tries = 0 def is_correct_response(message: Message): if message.author.id != member.id: return False if message.channel.id != auth_channel.id: return False responses.append(message) content = str(message.content).strip().lower() # Should begin with the code and end with the emoji if random_code.lower() not in content: return False if random_emoji_unicode not in content: return False return True response: Message = await bot.wait_for("message", check=is_correct_response, timeout=120) except TimeoutError: # Tell the user they were too slow and delete the verification channel await member.send(gets(String.VERIFY_FAILED_TIMEOUT)) await auth_channel.delete( reason= f"Verification for {member.name}#{member.discriminator} ({member.id}) " f"failed: timeout") if len(responses) == 0: if LOG_VERIFICATIONS_CONSOLE: log.info( f"Member failed to verify (timeout): {member.name}#{member.discriminator} ({member.id}), " f"expected '{random_code} {random_emoji_unicode}', no responses" ) embed = Embed( title="User failed to verify (timeout)", description= f"*Expected \"{random_code} {random_emoji_unicode}\"*\n" f"*No response*", color=Color.dark_red(), timestamp=datetime.now()) else: last_message = responses[-1] trimmed = last_message.clean_content if len(trimmed) > 1000: trimmed = f"{trimmed[:1000]}[...]" if LOG_VERIFICATIONS_CONSOLE: log.info( f"Member not verified (timeout): {member.name}#{member.discriminator} ({member.id}), " f"expected '{random_code} {random_emoji_unicode}', last response '{trimmed}'" ) embed = Embed( title="Member failed to verify (timeout)", description= f"*Expected \"{random_code} {random_emoji_unicode}\"*\n" f"Last response:\n```{trimmed}```", color=Color.red(), timestamp=datetime.now()) else: await response.add_reaction("✅") # Assign the full member role full_role = await get_verified_role() await member.add_roles(full_role, reason=f"Verification finished") await member.send( gets(String.VERIFY_SUCCESS).format(user_mention=member.mention)) await auth_channel.delete( reason= f"Verification for {member.name}#{member.discriminator} ({member.id}) " f"finished") trimmed = response.clean_content if len(trimmed) > 1000: trimmed = f"{trimmed[:1000]}[...]" if LOG_VERIFICATIONS_CONSOLE: log.info( f"Member verified: {member.name}#{member.discriminator} ({member.id}) with message '{trimmed}' " f"(expected \"{random_code} {random_emoji_unicode}\")") embed = Embed( title="Member verified", description=f"*Expected \"{random_code} {random_emoji_unicode}\"*\n" f"```{trimmed}```", color=Color.green(), timestamp=datetime.now()) finally: # Remove the reaction on the main message trigger_messsage = await get_verify_trigger_message() await trigger_messsage.remove_reaction(VERIFICATION_TRIGGER_EMOJI, member) # Send the log embed if enabled log_channel = await get_logging_channel() if log_channel is not None: embed.set_footer( text= f"Member: {member.name}#{member.discriminator} ({member.id})", icon_url=member.avatar_url) await log_channel.send(embed=embed)