diff --git a/bot.py b/bot.py
index 6771a9c..0a179a4 100755
--- a/bot.py
+++ b/bot.py
@@ -22,7 +22,6 @@ log = logging.getLogger(__name__)
l_extensions = (
'cogs.admin',
- 'cogs.bascics',
'jishaku',
)
diff --git a/cogs/admin.py b/cogs/admin.py
old mode 100755
new mode 100644
index c5586f6..55052b1
--- a/cogs/admin.py
+++ b/cogs/admin.py
@@ -1,407 +1,26 @@
-import aiohttp
from discord.ext import commands
-import discord
-from .utils import checks
-
-from .utils.checks import get_user
+from bot import TuxBot
class Admin(commands.Cog):
- """Commandes secrètes d'administration."""
- def __init__(self, bot):
+ def __init__(self, bot: TuxBot):
self.bot = bot
- self._last_result = None
- self.sessions = set()
+
+ async def cog_check(self, ctx: commands.Context):
+ permissions = ctx.channel.permissions_for(ctx.author)
+ return permissions.administrator
"""---------------------------------------------------------------------"""
- @checks.has_permissions(administrator=True)
- @commands.command(name="upload", pass_context=True)
- async def _upload(self, ctx, *, url=""):
- if len(ctx.message.attachments) >= 1:
- file = ctx.message.attachments[0].url
- elif url != "":
- file = url
- else:
- em = discord.Embed(title='Une erreur est survenue',
- description="Fichier introuvable.",
- colour=0xDC3546)
- await ctx.send(embed=em)
- return
-
- async with aiohttp.ClientSession() as session:
- async with session.get(file) as r:
- image = await r.content.read()
-
- with open(f"data/tmp/{str(ctx.author.id)}.png", 'wb') as f:
- f.write(image)
- f.close()
- await ctx.send(file=discord.File(f"data/tmp/{str(ctx.author.id)}.png"))
-
- @checks.has_permissions(administrator=True)
- @commands.command(name="ban", pass_context=True)
- async def _ban(self, ctx, user, *, reason=""):
- """Ban user"""
- user = get_user(ctx.message, user)
- if user and str(user.id) not in self.bot.config.unkickable_id:
- try:
- await user.ban(reason=reason)
- return_msg = f"`{user.mention}` a été banni\n"
- if reason:
- return_msg += f"raison : `{reason}`"
- return_msg += "."
- await ctx.send(return_msg)
- except discord.Forbidden:
- await ctx.send('Impossible de bannir cet user,'
- ' probleme de permission.')
- else:
- return await ctx.send('Impossible de trouver l\'user.')
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @commands.command(name="kick", pass_context=True)
- async def _kick(self, ctx, user, *, reason=""):
- """Kick a user"""
- user = get_user(ctx.message, user)
- if user and str(user.id) not in self.bot.config.unkickable_id:
- try:
- await user.kick(reason=reason)
- return_msg = f"`{user.mention}` a été kické\n"
- if reason:
- return_msg += f"raison : `{reason}`"
- return_msg += "."
- await ctx.send(return_msg)
- except discord.Forbidden:
- await ctx.send('Impossible de kicker cet user,'
- ' probleme de permission.')
- else:
- return await ctx.send('Impossible de trouver l\'user.')
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @commands.command(name='clear', pass_context=True)
- async def _clear(self, ctx, number: int, silent: str = True):
- """Clear <number> of message(s)"""
- try:
- await ctx.message.delete()
- except Exception:
- print(f"Impossible de supprimer le message "
- f"\"{str(ctx.message.content)}\"")
- if number < 1000:
- try:
- await ctx.message.channel.purge(limit=number)
- except Exception as e: # TODO : A virer dans l'event on_error
- if silent is not True:
- await ctx.send(f':sob: Une erreur est survenue : \n'
- f' {type(e).__name__}: {e}')
- if silent is not True:
- await ctx.send("Hop voila j'ai viré des messages! Hello World")
- print(f"{str(number)} messages ont été supprimés")
- else:
- await ctx.send('Trop de messages, entre un nombre < 1000')
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
@commands.command(name='say', pass_context=True)
- async def _say(self, ctx, *, tosay: str):
- """Say a message in the current channel"""
- try:
- try:
- await ctx.message.delete()
- except Exception:
- print(f"Impossible de supprimer le message "
- f"\"{str(ctx.message.content)}\"")
- await ctx.send(tosay)
- except Exception as e: # TODO : A virer dans l'event on_error
- await ctx.send(f':sob: Une erreur est survenue : \n'
- f' {type(e).__name__}: {e}')
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @commands.command(name='sayto', pass_context=True)
- async def _sayto(self, ctx, channel_id: int, *, tosay: str):
- """Say a message in the <channel_id> channel"""
- try:
- chan = self.bot.get_channel(channel_id)
- try:
- await ctx.message.delete()
- except Exception:
- print(f"Impossible de supprimer le message "
- f"\"{str(ctx.message.content)}\"")
- try:
- await chan.send(tosay)
- except Exception:
- print(f"Impossible d'envoyer le message dans {str(channel_id)}")
- except Exception as e: # TODO : A virer dans l'event on_error
- await ctx.send(f':sob: Une erreur est survenue : \n'
- f' {type(e).__name__}: {e}')
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @commands.command(name='sayto_dm', pass_context=True)
- async def _sayto_dm(self, ctx, user_id: int, *, tosay: str):
- """Say a message to the <user_id> user"""
- try:
- user = self.bot.get_user(user_id)
- try:
- await ctx.message.delete()
- except Exception:
- print(f"Impossible de supprimer le message "
- f"\"{str(ctx.message.content)}\"")
- try:
- await user.send(tosay)
- except Exception:
- print(f"Impossible d'envoyer le message dans {str(user_id)}")
- except Exception as e: # TODO : A virer dans l'event on_error
- await ctx.send(f':sob: Une erreur est survenue : \n'
- f' {type(e).__name__}: {e}')
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @commands.command(name='editsay', pass_context=True)
- async def _editsay(self, ctx, message_id: int, *, new_content: str):
- """Edit a bot's message"""
- try:
- try:
- await ctx.message.delete()
- except Exception:
- print(f"Impossible de supprimer le message "
- f"\"{str(ctx.message.content)}\"")
- toedit = await ctx.channel.fetch_message(message_id)
- except discord.errors.NotFound:
- await ctx.send(f"Impossible de trouver le message avec l'id "
- f"`{message_id}` sur ce salon")
- return
- try:
- await toedit.edit(content=str(new_content))
- except discord.errors.Forbidden:
- await ctx.send("J'ai po les perms pour editer mes messages :(")
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @commands.command(name='addreaction', pass_context=True)
- async def _addreaction(self, ctx, message_id: int, reaction: str):
- """Add reactions to a message"""
- try:
- try:
- await ctx.message.delete()
- except Exception:
- print(f"Impossible de supprimer le message "
- f"\"{str(ctx.message.content)}\"")
- toadd = await ctx.channel.fetch_message(message_id)
- except discord.errors.NotFound:
- await ctx.send(f"Impossible de trouver le message avec l'id "
- f"`{message_id}` sur ce salon")
- return
- try:
- await toadd.add_reaction(reaction)
- except discord.errors.Forbidden:
- await ctx.send("J'ai po les perms pour ajouter des réactions :(")
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @commands.command(name='delete', pass_context=True)
- async def _delete(self, ctx, message_id: int):
- """Delete message in current channel"""
- try:
- try:
- await ctx.message.delete()
- except Exception:
- print(f"Impossible de supprimer le message "
- f"\"{str(ctx.message.content)}\"")
- todelete = await ctx.channel.fetch_message(message_id)
- except discord.errors.NotFound:
- await ctx.send(f"Impossible de trouver le message avec l'id "
- f"`{message_id}` sur ce salon")
- return
- try:
- await todelete.delete()
- except discord.errors.Forbidden:
- await ctx.send("J'ai po les perms pour supprimer des messages :(")
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @commands.command(name='deletefrom', pass_context=True)
- async def _deletefrom(self, ctx, chan_id: int, *, message_id: int):
- """Delete message in <chan_id> channel"""
- try:
- chan = self.bot.get_channel(chan_id)
- try:
- await ctx.message.delete()
- except Exception:
- print(f"Impossible de supprimer le message "
- f"\"{str(ctx.message.content)}\"")
- todelete = await chan.fetch_message(message_id)
- except discord.errors.NotFound:
- await ctx.send(f"Impossible de trouver le message avec l'id "
- f"`{id}` sur le salon")
- return
- try:
- await todelete.delete()
- except discord.errors.Forbidden:
- await ctx.send("J'ai po les perms pour supprimer le message :(")
-
- """---------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @commands.command(name='embed', pass_context=True)
- async def _embed(self, ctx, *, msg: str = "help"):
- """Send an embed"""
- if msg != "help":
- ptext = title \
- = description \
- = image \
- = thumbnail \
- = color \
- = footer \
- = author \
- = None
- timestamp = discord.Embed.Empty
- embed_values = msg.split('|')
- for i in embed_values:
- if i.strip().lower().startswith('ptext='):
- ptext = i.strip()[6:].strip()
- elif i.strip().lower().startswith('title='):
- title = i.strip()[6:].strip()
- elif i.strip().lower().startswith('description='):
- description = i.strip()[12:].strip()
- elif i.strip().lower().startswith('desc='):
- description = i.strip()[5:].strip()
- elif i.strip().lower().startswith('image='):
- image = i.strip()[6:].strip()
- elif i.strip().lower().startswith('thumbnail='):
- thumbnail = i.strip()[10:].strip()
- elif i.strip().lower().startswith('colour='):
- color = i.strip()[7:].strip()
- elif i.strip().lower().startswith('color='):
- color = i.strip()[6:].strip()
- elif i.strip().lower().startswith('footer='):
- footer = i.strip()[7:].strip()
- elif i.strip().lower().startswith('author='):
- author = i.strip()[7:].strip()
- elif i.strip().lower().startswith('timestamp'):
- timestamp = ctx.message.created_at
- else:
- if description is None and not i.strip()\
- .lower().startswith('field='):
- description = i.strip()
-
- if color:
- if color.startswith('#'):
- color = color[1:]
- if not color.startswith('0x'):
- color = '0x' + color
-
- if ptext \
- is title \
- is description \
- is image \
- is thumbnail \
- is color \
- is footer \
- is author \
- is None \
- and 'field=' not in msg:
- try:
- await ctx.message.delete()
- except Exception:
- print("Impossible de supprimer le message \"" + str(
- ctx.message.content) + "\"")
- return await ctx.send(content=None,
- embed=discord.Embed(description=msg))
-
- if color:
- em = discord.Embed(timestamp=timestamp, title=title,
- description=description,
- color=int(color, 16))
- else:
- em = discord.Embed(timestamp=timestamp, title=title,
- description=description)
- for i in embed_values:
- if i.strip().lower().startswith('field='):
- field_inline = True
- field = i.strip().lstrip('field=')
- field_name, field_value = field.split('value=')
- if 'inline=' in field_value:
- field_value, field_inline = field_value.split(
- 'inline=')
- if 'false' in field_inline.lower() \
- or 'no' in field_inline.lower():
- field_inline = False
- field_name = field_name.strip().lstrip('name=')
- em.add_field(name=field_name, value=field_value.strip(),
- inline=field_inline)
- if author:
- if 'icon=' in author:
- text, icon = author.split('icon=')
- if 'url=' in icon:
- em.set_author(name=text.strip()[5:],
- icon_url=icon.split('url=')[0].strip(),
- url=icon.split('url=')[1].strip())
- else:
- em.set_author(name=text.strip()[5:], icon_url=icon)
- else:
- if 'url=' in author:
- em.set_author(name=author.split('url=')[0].strip()[5:],
- url=author.split('url=')[1].strip())
- else:
- em.set_author(name=author)
-
- if image:
- em.set_image(url=image)
- if thumbnail:
- em.set_thumbnail(url=thumbnail)
- if footer:
- if 'icon=' in footer:
- text, icon = footer.split('icon=')
- em.set_footer(text=text.strip()[5:], icon_url=icon)
- else:
- em.set_footer(text=footer)
-
- try:
- await ctx.message.delete()
- except Exception:
- print("Impossible de supprimer le message \"" + str(
- ctx.message.content) + "\"")
- await ctx.send(content=ptext, embed=em)
-
- else:
- embed = discord.Embed(
- title="Aide sur l'utilisation de la commande .embed:")
- embed.add_field(name="Titre:", value="title=<le titre>",
- inline=True)
- embed.add_field(name="Description:",
- value="description=<la description>", inline=True)
- embed.add_field(name="Couleur:", value="color=<couleur en hexa>",
- inline=True)
- embed.add_field(name="Image:",
- value="image=<url de l'image (en https)>",
- inline=True)
- embed.add_field(name="Thumbnail:",
- value="thumbnail=<url de l'image>", inline=True)
- embed.add_field(name="Auteur:", value="author=<nom de l'auteur>",
- inline=True)
- embed.add_field(name="Icon", value="icon=<url de l'image>",
- inline=True)
- embed.add_field(name="Footer", value="footer=<le footer>",
- inline=True)
- embed.set_footer(text="Exemple: .embed title=Un titre |"
- " description=Une description |"
- " color=3AB35E |"
- " field=name=test value=test")
-
- await ctx.send(embed=embed)
+ async def _say(self, ctx: commands.Context, *, to_say: str):
+ # try:
+ await ctx.message.delete()
+ await ctx.send(to_say)
+ # except:
+ # await ctx.send(to_say)
-def setup(bot):
+def setup(bot: TuxBot):
bot.add_cog(Admin(bot))
diff --git a/cogs/afk.py b/cogs/afk.py
deleted file mode 100755
index d53d35f..0000000
--- a/cogs/afk.py
+++ /dev/null
@@ -1,68 +0,0 @@
-from discord.ext import commands
-import discord
-import random
-
-
-class AFK(commands.Cog):
- """Commandes utilitaires."""
-
- def __init__(self, bot):
- self.bot = bot
- self.afk_users = []
-
- """---------------------------------------------------------------------"""
-
- @commands.command(pass_context=True)
- async def afk(self, ctx, action: str = ""):
-
- if action.lower() == "list":
- try:
- await ctx.send(*self.afk_users)
- except discord.HTTPException:
- await ctx.send("Il n'y a personne d'afk...")
- else:
- user = ctx.author
- self.afk_users.append(user)
- msgs = ["s'absente de discord quelques instants",
- "se casse de son pc",
- "va sortir son chien",
- "reviens bientôt",
- "va nourrir son cochon",
- "va manger des cookies",
- "va manger de la poutine",
- "va faire caca",
- "va faire pipi"]
-
- await ctx.send(f"**{user.mention}** {random.choice(msgs)}...")
-
- """---------------------------------------------------------------------"""
-
- @commands.Cog.listener()
- async def on_message(self, message):
- if message.author.bot \
- or message.guild.id != int(self.bot.config.main_server_id):
- return
-
- user = message.author
-
- if user in self.afk_users \
- and message.content != self.bot.config.prefix[0] + "afk":
- self.afk_users.remove(user)
-
- msgs = ["a réssuscité",
- "est de nouveau parmi nous",
- "a fini de faire caca",
- "a fini d'uriner",
- "n'est plus mort",
- "est de nouveau sur son PC",
- "a fini de manger sa poutine",
- "a fini de danser",
- "s'est réveillé",
- "est de retour dans ce monde cruel"]
-
- await message.channel.send(f"**{user.mention}**"
- f" {random.choice(msgs)}...")
-
-
-def setup(bot):
- bot.add_cog(AFK(bot))
diff --git a/cogs/atc.py b/cogs/atc.py
deleted file mode 100755
index ea50ed3..0000000
--- a/cogs/atc.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import asyncio
-
-from bs4 import BeautifulSoup
-import requests
-import re
-
-import discord
-from discord.ext import commands
-
-
-class ATC(commands.Cog):
-
- def __init__(self, bot):
- self.bot = bot
- self.playing = False
- self.author = None
- self.voice = None
-
- @staticmethod
- async def extra(self, ctx, icao):
- if icao == "stop_playing":
- if self.playing and (
- ctx.author.id == self.author.id
- or ctx.message.channel.permissions_for(ctx.message.author).administrator is True
- ):
- await self.voice.disconnect()
- self.playing = False
- await ctx.send("Écoute terminée !")
- return "quit"
- else:
- await ctx.send("Veuillez specifier un icao")
- return "quit"
- if icao == "info":
- em = discord.Embed(title=f"Infos sur les services utilisés par {self.bot.config.prefix[0]}atc")
- em.add_field(name="Service pour les communications:",
- value="[liveatc.net](https://www.liveatc.net/)",
- inline=False)
- em.add_field(name="Service pour les plans des aéroports:",
- value="[universalweather.com](http://www.universalweather.com/)",
- inline=False)
- await ctx.send(embed=em)
- return "quit"
-
- """---------------------------------------------------------------------"""
-
- @commands.command(name="atc", no_pm=True, pass_context=True)
- async def _atc(self, ctx, icao="stop_playing"):
- user = ctx.author
- if not user.voice:
- await ctx.send('Veuillez aller dans un channel vocal.')
- return
-
- if await self.extra(self, ctx, icao) == "quit":
- return
-
- if self.playing:
- await ctx.send(f"Une écoute est déja en court, "
- f"demandez à {self.author.mention} de faire "
- f"`.atc stop_playing` pour l'arreter")
- return
- self.author = user
- headers = {
- 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.35 Safari/537.36',
- }
- req = requests.post("https://www.liveatc.net/search/",
- data={'icao': icao},
- headers=headers)
- html = BeautifulSoup(req.text, features="lxml")
- regex = r"(javascript: pageTracker\._trackPageview\('\/listen\/)(.*)(\'\)\;)"
-
- possibilities = {}
- emojis = ['1⃣', '2⃣', '3⃣', '4⃣', '5⃣', '6⃣', '7⃣', '8⃣', '9⃣', '🔟',
- '0⃣', '🇦', '🇧', '🇨', '🇩', '🇪', '🇫', '🇬', '🇭', '🇮']
- to_react = []
-
- idx = 0
- for a in html.findAll("a", onclick=True):
- val = a.get('onclick')
- for match in re.finditer(regex, val):
- possibilities[idx] = f"{emojis[idx]} - {match.groups()[1]}\n"
- to_react.append(emojis[idx])
- idx += 1
-
- em = discord.Embed(title='Résultats pour : ' + icao,
- description=str(''.join(possibilities.values())),
- colour=0x4ECDC4)
- em.set_image(
- url=f"http://www.universalweather.com/regusers/mod-bin/uvtp_airport_image?icao={icao}")
-
- poll_msg = await ctx.send(embed=em)
- for emote in to_react:
- await poll_msg.add_reaction(emote)
-
- def check(reaction, user):
- return user == ctx.author and reaction.emoji in to_react and \
- reaction.message.id == poll_msg.id
-
- async def waiter(future: asyncio.Future):
- reaction, user = await self.bot.wait_for('reaction_add',
- check=check)
-
- future.set_result(emojis.index(reaction.emoji))
-
- added_emoji = asyncio.Future()
- self.bot.loop.create_task(waiter(added_emoji))
-
- while not added_emoji.done():
- await asyncio.sleep(0.1)
-
- freq = possibilities[added_emoji.result()].split('- ')[1]
-
- if possibilities:
- self.playing = True
- self.voice = await user.voice.channel.connect()
- self.voice.play(
- discord.FFmpegPCMAudio(f"http://yyz.liveatc.net/{freq}"))
- await poll_msg.delete()
- await ctx.send(f"Écoute de {freq}")
- else:
- await ctx.send(f"Aucun résultat trouvé pour {icao} {freq}")
-
-
-def setup(bot):
- bot.add_cog(ATC(bot))
diff --git a/cogs/basics.py b/cogs/basics.py
deleted file mode 100755
index 51b6d92..0000000
--- a/cogs/basics.py
+++ /dev/null
@@ -1,51 +0,0 @@
-import platform
-import socket
-
-import discord
-from discord.ext import commands
-from discord.http import Route
-
-
-class Basics(commands.Cog):
- """Commandes générales."""
-
- def __init__(self, bot: discord.ext.commands.AutoShardedBot):
- self.bot = bot
-
- @commands.command()
- async def ping(self, ctx: discord.ext.commands.context.Context):
- delta = await ctx.send(self.bot.latency * 1000)
- await ctx.send((delta.created_at-ctx.message.created_at)
- .microseconds/1000)
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def info(self, ctx):
- """Affiches des informations sur le bot"""
- text = open('texts/info.md').read()
- os_info = str(platform.system()) + " / " + str(platform.release())
- em = discord.Embed(title='Informations sur TuxBot',
- description=text.format(os_info,
- platform.python_version(),
- socket.gethostname(),
- discord.__version__,
- Route.BASE),
- colour=0x89C4F9)
- em.set_footer(text="/home/****/bot.py")
- await ctx.send(embed=em)
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def help(self, ctx):
- """Affiches l'aide du bot"""
- text = open('texts/help.md').read().split("[split]")
- for txt in text:
- em = discord.Embed(title='Commandes de TuxBot', description=txt,
- colour=0x89C4F9)
- await ctx.send(embed=em)
-
-
-def setup(bot):
- bot.add_cog(Basics(bot))
diff --git a/cogs/ci.py b/cogs/ci.py
deleted file mode 100755
index 17a14d1..0000000
--- a/cogs/ci.py
+++ /dev/null
@@ -1,311 +0,0 @@
-import datetime
-import random
-
-import discord
-import requests
-from discord.ext import commands
-
-from .utils import checks
-from .utils import db
-from .utils.checks import get_user, check_date
-
-
-class Identity(commands.Cog):
- """Commandes des cartes d'identité ."""
-
- def __init__(self, bot):
- self.bot = bot
-
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- self.cursor.execute("""SHOW TABLES LIKE 'users'""")
- result = self.cursor.fetchone()
-
- if not result:
- # Creation table Utilisateur si premiere fois
- sql = "CREATE TABLE users ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, userid TEXT null, username TEXT null, os TEXT null, config TEXT null, useravatar TEXT null, userbirth TEXT null, pays TEXT null, cidate TEXT null, cibureau TEXT null);"
- self.cursor.execute(sql)
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @commands.group(name="ci", no_pm=True, pass_context=True)
- async def _ci(self, ctx):
- """Cartes d'identité"""
-
- if ctx.invoked_subcommand is None:
- text = open('texts/ci-info.md').read()
- em = discord.Embed(title='Commandes de carte d\'identité de TuxBot', description=text, colour=0x89C4F9)
- await ctx.send(embed=em)
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @_ci.command(pass_context=True, name="show")
- async def ci_show(self, ctx, args: str = None):
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- if args == None:
- user = get_user(ctx.message, ctx.author.name)
- else:
- user = get_user(ctx.message, args)
-
- if user:
- self.cursor.execute("""SELECT userid, username, useravatar, userbirth, cidate, cibureau, os, config, pays, id FROM users WHERE userid=%s""",(str(user.id)))
- result = self.cursor.fetchone()
-
- def isexist(var):
- if not var:
- return "Non renseigné."
- else:
- return var
-
- if not result:
- await ctx.send(f"{ctx.author.mention}> :x: Désolé mais {user.mention} est sans papier !")
- else:
- try:
- user_birth = datetime.datetime.fromisoformat(result[3])
- user_birth_day = check_date(str(user_birth.day))
- user_birth_month = check_date(str(user_birth.month))
-
- formated_user_birth = str(user_birth_day) + "/" + str(user_birth_month) + "/" + str(user_birth.year)
-
- try: ## a virer une fois le patch appliqué pour tout le monde
- cidate = datetime.datetime.fromisoformat(result[4])
- cidate_day = check_date(str(cidate.day)) ## a garder
- cidate_month = check_date(str(cidate.month)) ## a garder
-
- formated_cidate = str(cidate_day) + "/" + str(cidate_month) + "/" + str(cidate.year) ## a garder
- except ValueError: ## a virer une fois le patch appliqué pour tout le monde
- formated_cidate = str(result[4]).replace('-', '/') ## a virer une fois le patch appliqué pour tout le monde
- await ctx.send(f"{user.mention} vous êtes prié(e) de faire la commande `.ci update` afin de regler un probleme de date coté bdd") ## a virer une fois le patch appliqué pour tout le monde
-
- embed=discord.Embed(title="Carte d'identité | Communisme Linuxien")
- embed.set_author(name=result[1], icon_url=result[2])
- embed.set_thumbnail(url = result[2])
- embed.add_field(name="Nom :", value=result[1], inline=True)
- embed.add_field(name="Système d'exploitation :", value=isexist(result[6]), inline=True)
- embed.add_field(name="Configuration Système : ", value=isexist(result[7]), inline=True)
- embed.add_field(name="Date de naissance sur discord : ", value=formated_user_birth, inline=True)
- embed.add_field(name="Pays : ", value=isexist(result[8]), inline=True)
- embed.add_field(name="Profil sur le web : ", value=f"https://tuxbot.gnous.eu/users/{result[9]}", inline=True)
- embed.set_footer(text=f"Enregistré dans le bureau {result[5]} le {formated_cidate}.")
- await ctx.send(embed=embed)
- except Exception as e:
- await ctx.send(f"{ctx.author.mention}> :x: Désolé mais la carte d'identité de {user.mention} est trop longue de ce fait je ne peux te l'envoyer, essaye de l'aléger, {user.mention} :wink: !")
- await ctx.send(f':sob: Une erreur est survenue : \n {type(e).__name__}: {e}')
- else:
- return await ctx.send('Impossible de trouver l\'user.')
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @_ci.command(pass_context=True, name="register")
- async def ci_register(self, ctx):
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- self.cursor.execute("""SELECT id, userid FROM users WHERE userid=%s""", (str(ctx.author.id)))
- result = self.cursor.fetchone()
-
- if result:
- await ctx.send("Mais tu as déja une carte d'identité ! u_u")
- else:
- now = datetime.datetime.now()
-
- self.cursor.execute("""INSERT INTO users(userid, username, useravatar, userbirth, cidate, cibureau) VALUES(%s, %s, %s, %s, %s, %s)""", (str(ctx.author.id), str(ctx.author), str(ctx.author.avatar_url_as(format="jpg", size=512)), str(ctx.author.created_at), now, str(ctx.message.guild.name)))
- self.conn.commit()
- await ctx.send(f":clap: Bievenue à toi {ctx.author.name} dans le communisme {ctx.message.guild.name} ! Fait ``.ci`` pour plus d'informations !")
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @_ci.command(pass_context=True, name="delete")
- async def ci_delete(self, ctx):
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- self.cursor.execute("""SELECT id, userid FROM users WHERE userid=%s""", (str(ctx.author.id)))
- result = self.cursor.fetchone()
-
- if result:
- self.cursor.execute("""DELETE FROM users WHERE userid =%s""", (str(ctx.author.id)))
- self.conn.commit()
- await ctx.send("Tu es maintenant sans papiers !")
- else:
- await ctx.send("Déja enregistre ta carte d'identité avant de la supprimer u_u (après c'est pas logique...)")
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @_ci.command(pass_context=True, name="update")
- async def ci_update(self, ctx):
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- try:
- self.cursor.execute("""SELECT id, userid FROM users WHERE userid=%s""", (str(ctx.author.id)))
- result = self.cursor.fetchone()
-
- if result:
- self.cursor.execute("""SELECT cidate FROM users WHERE userid=%s""",(str(ctx.author.id)))
- old_ci_date = self.cursor.fetchone()
-
- try:
- new_ci_date = datetime.datetime.fromisoformat(old_ci_date[0])
- except ValueError:
- old_ci_date = datetime.datetime.strptime(old_ci_date[0].replace('/', '-'), '%d-%m-%Y')
-
- old_ci_date_day = check_date(str(old_ci_date.day))
- old_ci_date_month = check_date(str(old_ci_date.month))
-
- new_ci_date = f"{str(old_ci_date.year)}-{str(old_ci_date_month)}-{str(old_ci_date_day)} 00:00:00.000000"
-
- await ctx.send("succes update")
-
- self.cursor.execute("""UPDATE users SET cidate = %s WHERE userid = %s""", (str(new_ci_date), str(ctx.author.id)))
- self.conn.commit()
-
- self.cursor.execute("""UPDATE users SET useravatar = %s, username = %s, cibureau = %s WHERE userid = %s""", (str(ctx.author.avatar_url_as(format="jpg", size=512)), str(ctx.author), str(ctx.message.guild), str(ctx.author.id)))
- self.conn.commit()
- await ctx.send(f"{ctx.author.mention}> Tu viens, en quelques sortes, de renaitre !")
- else:
- await ctx.send(f"{ctx.author.mention}> :x: Veuillez enregistrer votre carte d'identité pour commencer !")
-
- except Exception as e: #TODO : A virer dans l'event on_error
- await ctx.send(':( Erreur veuillez contacter votre administrateur :')
- await ctx.send(f'{type(e).__name__}: {e}')
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @_ci.command(pass_context=True, name="setconfig")
- async def ci_setconfig(self, ctx, *, conf: str = None):
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- if conf:
- self.cursor.execute("""SELECT id, userid FROM users WHERE userid=%s""", (str(ctx.author.id)))
- result = self.cursor.fetchone()
-
- if result:
- self.cursor.execute("""UPDATE users SET config = %s WHERE userid = %s""", (str(conf), str(ctx.author.id)))
- self.conn.commit()
- await ctx.send(f"{ctx.author.mention}> :ok_hand: Carte d'identité mise à jour !")
- else:
- await ctx.send(f"{ctx.author.mention}> :x: Veuillez enregistrer votre carte d'identité pour commencer !")
- else:
- await ctx.send(f"{ctx.author.mention}> :x: Il manque un paramètre !")
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @_ci.command(pass_context=True, name="setos")
- async def ci_setos(self, ctx, *, conf: str = None):
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- if conf:
- self.cursor.execute("""SELECT id, userid FROM users WHERE userid=%s""", (str(ctx.author.id)))
- result = self.cursor.fetchone()
-
- if result:
- self.cursor.execute("""UPDATE users SET os = %s WHERE userid = %s""", (str(conf), str(ctx.author.id)))
- self.conn.commit()
- await ctx.send(f"{ctx.author.mention}> :ok_hand: Carte d'identité mise à jour !")
- else:
- await ctx.send(f"{ctx.author.mention}> :x: Veuillez enregistrer votre carte d'identité pour commencer !")
- else:
- await ctx.send(f"{ctx.author.mention}> :x: Il manque un paramètre !")
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @_ci.command(pass_context=True, name="setcountry")
- async def ci_setcountry(self, ctx, *, country: str = None):
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- if country:
- self.cursor.execute("""SELECT id, userid FROM users WHERE userid=%s""", (str(ctx.author.id)))
- result = self.cursor.fetchone()
-
- if result:
- self.cursor.execute("""UPDATE users SET pays = %s WHERE userid = %s""", (str(country), str(ctx.author.id)))
- self.conn.commit()
- await ctx.send(f"{ctx.author.mention}> :ok_hand: Carte d'identité mise à jour !")
- else:
- await ctx.send(f"{ctx.author.mention}> :x: Veuillez enregistrer votre carte d'identité pour commencer !")
- else:
- await ctx.send(f"{ctx.author.mention}> :x: Il manque un paramètre !")
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @_ci.command(pass_context=True, name="online_edit")
- async def ci_online_edit(self, ctx):
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- self.cursor.execute("""SELECT id FROM users WHERE userid=%s""",(str(ctx.author.id)))
- result = self.cursor.fetchone()
-
- if not result:
- return await ctx.send(f"Déja enregistre ta carte d'identité avant de l'éditer u_u (après c'est pas logique...)")
-
- dm = await ctx.author.create_dm()
-
- try:
- def is_exist(key, value):
- self.cursor.execute("""SELECT * FROM sessions WHERE {}=%s""".format(str(key)), (str(value)))
- return self.cursor.fetchone()
-
- user_id = result[0]
- is_admin = '1' if str(ctx.author.id) in self.bot.config.authorized_id else '0'
- token = ''.join(random.sample('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'*25, 25))
- created_at = datetime.datetime.utcnow()
-
- while is_exist('token', token):
- token = ''.join(random.sample('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'*25, 25))
-
- if is_exist('user_id', user_id):
- self.cursor.execute("""UPDATE sessions SET is_admin = %s, token = %s, updated_at = %s WHERE user_id = %s""", (str(is_admin), str(token), str(created_at), str(user_id)))
- self.conn.commit()
- else:
- self.cursor.execute("""INSERT INTO sessions(user_id, is_admin, token, created_at, updated_at) VALUES(%s, %s, %s, %s, %s)""", (str(user_id), str(is_admin), str(token), str(created_at), str(created_at)))
- self.conn.commit()
-
- embed=discord.Embed(title="Clé d'édition pour tuxweb", description=f"Voici ta clé d'édition, vas sur [https://tuxbot.gnous.eu/fr/users/{user_id}](https://tuxbot.gnous.eu/fr/users/{user_id}) puis cliques sur `editer` et entre la clé afin de pouvoir modifier ta ci", colour=0x89C4F9)
- embed.set_footer(text=f"Cette clé sera valide durant les 10 prochaines minutes, ne la communiques à personne !")
- await dm.send(embed=embed)
- await dm.send(token)
-
- await ctx.send(f"{ctx.author.mention} ta clé d'édition t'a été envoyée en message privé")
-
- except Exception as e:
- await ctx.send(f"{ctx.author.mention}, je ne peux pas t'envoyer de message privé :(. Penses à autoriser les messages privés provenant des membres du serveur pour que je puisse te donner ta clef d'édition")
-
- """--------------------------------------------------------------------------------------------------------------------------"""
-
- @checks.has_permissions(administrator=True)
- @_ci.command(pass_context=True, name="list")
- async def ci_list(self, ctx):
- self.conn = db.connect_to_db(self)
- self.cursor = self.conn.cursor()
-
- self.cursor.execute("""SELECT id, username FROM users""")
- rows = self.cursor.fetchall()
- msg = ""
- try:
- for row in rows:
- row_id = row[0]
- row_name = row[1].encode('utf-8')
- msg += f"{str(row_id)} : {str(row_name)} \n"
- post = requests.post("https://hastebin.com/documents", data=msg)
- await ctx.send(f"{ctx.author.mention} liste posté avec succès sur :\nhttps://hastebin.com/{post.json()['key']}.txt")
-
- with open('ci_list.txt', 'w', encoding='utf-8') as fp:
- for row in rows:
- row_id = row[0]
- row_name = row[1]
-
- fp.write(f"{str(row_id)} : {str(row_name)} \n")
-
- except Exception as e:
- await ctx.send(f':sob: Une erreur est survenue : \n {type(e).__name__}: {e}')
-
-def setup(bot):
- bot.add_cog(Identity(bot))
diff --git a/cogs/filter_messages.py b/cogs/filter_messages.py
deleted file mode 100755
index 396b47c..0000000
--- a/cogs/filter_messages.py
+++ /dev/null
@@ -1,60 +0,0 @@
-from discord.ext import commands
-import re
-
-
-class FilterMessages(commands.Cog):
- """Flitre des messages"""
-
- def __init__(self, bot):
- self.bot = bot
-
- @commands.Cog.listener()
- async def on_message(self, message):
- no_pub_guild = [280805240977227776, 303633056944881686,
- 274247231534792704]
- lien_channel = [280805783795662848, 508794201509593088,
- 516017286948061204]
- sondage_channel = [394146769107419146, 477147964393914388]
-
- if message.author.bot \
- or str(message.author.id) in self.bot.config.authorized_id \
- or message.channel.permissions_for(message.author).administrator is True:
- return
-
- discord_invite_regex = re.compile(r"(discord\.(gg|io|me|li)|discordapp\.com\/invite)\/[0-9A-Za-z]*", re.IGNORECASE)
- invalid_link_regex = re.compile(r"^(\[[^\]]+\]|<\:[a-z0-9]+\:[0-9]+>) .+ https?:\/\/\S*$", re.IGNORECASE)
-
- try:
- if message.guild.id in no_pub_guild:
- if isinstance(discord_invite_regex.search(message.content), re.Match):
- author = self.bot.get_user(message.author.id)
- await message.delete()
- await author.send("La pub pour les serveurs discord n'est pas autorisée ici")
-
- if message.channel.id in lien_channel \
- and not isinstance(invalid_link_regex.search(message.content), re.Match):
- author = self.bot.get_user(message.author.id)
- await message.delete()
- await author.send(f"Votre message `{message.content}` a été "
- f"supprimé du channel `liens` ou `projets` "
- f"car il ne respecte pas la structure "
- f"définie. Pour partager un lien veuillez "
- f"suivre la structure suivante :"
- f" ` [Sujet] Descirption http(s)://....`")
- await author.send("Si vous voulez commenter ou discuter à "
- "propos d'un lien ou d'un projet, veuillez "
- "le faire dans le channel"
- " `#discussion-des-liens` ou"
- " `#discussion-projets`.")
-
- if message.channel.id in sondage_channel:
- prefix_lenght = len(await self.bot.get_prefix(message))
- command = (message.content.split()[0])[prefix_lenght:]
- if command != "sondage":
- await message.delete()
- except AttributeError:
- pass
-
-
-def setup(bot):
- bot.add_cog(FilterMessages(bot))
diff --git a/cogs/funs.py b/cogs/funs.py
deleted file mode 100755
index 0ebd204..0000000
--- a/cogs/funs.py
+++ /dev/null
@@ -1,190 +0,0 @@
-from discord.ext import commands
-import asyncio
-import discord
-import urllib.request
-import json
-import random
-import requests
-
-
-class Funs(commands.Cog):
- """Commandes funs."""
-
- def __init__(self, bot):
- self.bot = bot
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def avatar(self, ctx, user: discord.Member = None):
- """Récuperer l'avatar de ..."""
-
- if user is None:
- user = ctx.message.author
-
- embed = discord.Embed(title="Avatar de " + user.name,
- description=f"[Ouvrir dans mon navigateur]"
- f"({user.avatar_url_as(format='png')})")
- embed.set_image(url=user.avatar_url_as(format='png'))
- await ctx.send(embed=embed)
-
- """---------------------------------------------------------------------"""
-
- @commands.command(pass_context=True)
- async def poke(self, ctx, user: discord.Member):
- """Poke quelqu'un"""
- await ctx.send(f":clap: Hey {user.mention} tu t'es fait poker par"
- f" {ctx.message.author} !")
- await ctx.message.delete()
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def btcprice(self, ctx):
- """Le prix du BTC"""
- loading = await ctx.send("_réfléchis..._")
- try:
- url = urllib.request.urlopen("https://blockchain.info/fr/ticker")
- btc = json.loads(url.read().decode())
- except KeyError:
- btc = 1
-
- if btc == 1:
- await loading.edit(content="Impossible d'accèder à l'API"
- " blockchain.info, veuillez réessayer"
- " ultérieurment ! :c")
- else:
- frbtc = str(btc["EUR"]["last"]).replace(".", ",")
- usbtc = str(btc["USD"]["last"]).replace(".", ",")
- await loading.edit(content=f"Un bitcoin est égal à :"
- f" {usbtc}$US soit {frbtc}€.")
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def joke(self, ctx, number: str = 0):
- """Print a random joke in a json file"""
- with open('texts/jokes.json') as js:
- jk = json.load(js)
-
- try:
- if 15 >= int(number) > 0:
- clef = str(number)
- else:
- clef = str(random.randint(1, 15))
- except Exception:
- clef = str(random.randint(1, 15))
-
- joke = jk["{}".format(clef)]
-
- embed = discord.Embed(title="Blague _{}_ : ".format(clef),
- description=joke['content'], colour=0x03C9A9)
- embed.set_footer(text="Par " + joke['author'])
- embed.set_thumbnail(url='https://outout.tech/tuxbot/blobjoy.png')
- await ctx.send(embed=embed)
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def ethylotest(self, ctx):
- """Ethylotest simulator 2018"""
- results_poulet = ["Désolé mais mon ethylotest est sous Windows Vista, "
- "merci de patienter...",
- "_(ethylotest)_ : Une erreur est survenue. Windows "
- "cherche une solution à se problème.",
- "Mais j'l'ai foutu où ce p\\*\\*\\* d'ethylotest de m\\*\\*\\* "
- "bordel fait ch\\*\\*\\*",
- "C'est pas possible z'avez cassé l'ethylotest !"]
- results_client = ["D'accord, il n'y a pas de problème à cela je suis "
- "complètement clean",
- "Bien sur si c'est votre devoir !", "Suce bi\\*e !",
- "J'ai l'air d'être bourré ?",
- "_laissez moi prendre un bonbon à la menthe..._"]
-
- result_p = random.choice(results_poulet)
- result_c = random.choice(results_client)
-
- await ctx.send(":oncoming_police_car: Bonjour bonjour, contrôle "
- "d'alcoolémie !")
- await asyncio.sleep(0.5)
- await ctx.send(":man: " + result_c)
- await asyncio.sleep(1)
- await ctx.send(":police_car: " + result_p)
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def coin(self, ctx):
- """Coin flip simulator 2025"""
- starts_msg = ["Je lance la pièce !", "C'est parti !", "C'est une pièce"
- " d'un cent faut"
- " pas la perdre",
- "C'est une pièce d'un euro faut pas la perdre",
- "Je lance !"]
- results_coin = ["{0} pile", "{0} face", "{1} Heu c'est quoi pile c'est"
- " quoi face enfaite ?",
- "{1} Oh shit, je crois que je l'ai perdue",
- "{1} Et bim je te vol ta pièce !",
- "{0} Oh une erreur d'impression il n'y a ni pile ni"
- " face !"]
-
- start = random.choice(starts_msg)
- result = random.choice(results_coin)
-
- await ctx.send(start)
- await asyncio.sleep(0.6)
- await ctx.send(result.format(":moneybag: Et la pièce retombe sur ...",
- ":robot:"))
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def pokemon(self, ctx):
- """Random pokemon fight"""
- with open('texts/pokemons.json') as js:
- jk = json.load(js)
-
- poke1 = jk[random.randint(1, 150)]
- poke2 = jk[random.randint(1, 150)]
-
- try:
- if poke1['MaxHP'] > poke2['MaxHP']:
- winer = poke1
- else:
- winer = poke2
- except KeyError:
- winer = poke1
-
- await ctx.send(":flag_white: **Le combat commence !**")
- await asyncio.sleep(1)
- await ctx.send(":loudspeaker: Les concurants sont {} contre {} ! Bonne"
- " chance à eux !".format(poke1["Name"], poke2["Name"]))
- await asyncio.sleep(0.5)
- await ctx.send(":boom: {} commence et utilise {}".format(
- poke1["Name"], poke1["Fast Attack(s)"][0]["Name"]))
- await asyncio.sleep(1)
- await ctx.send(":dash: {} réplique avec {}".format(
- poke2["Name"], poke2["Fast Attack(s)"][0]["Name"]))
- await asyncio.sleep(1.2)
- await ctx.send("_le combat continue de se dérouler..._")
- await asyncio.sleep(1.5)
- await ctx.send(":trophy: Le gagnant est **{}** !".format(
- winer["Name"]))
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def randomcat(self, ctx):
- """Display a random cat"""
- r = requests.get('http://aws.random.cat/meow')
- cat = str(r.json()['file'])
- embed = discord.Embed(title="Meow",
- description="[Voir le chat plus grand]({})".
- format(cat), colour=0x03C9A9)
- embed.set_thumbnail(url=cat)
- embed.set_author(name="Random.cat", url='https://random.cat/')
- await ctx.send(embed=embed)
-
-
-def setup(bot):
- bot.add_cog(Funs(bot))
diff --git a/cogs/role.py b/cogs/role.py
deleted file mode 100755
index c16169e..0000000
--- a/cogs/role.py
+++ /dev/null
@@ -1,152 +0,0 @@
-from discord.ext import commands
-import discord
-
-
-class Role(commands.Cog):
- """Commandes role."""
-
- def __init__(self, bot):
- self.bot = bot
-
- self.ARCH_ROLE = 393077257826205706
- self.DEBIAN_ROLE = 393077933209550859
- self.RHEL_ROLE = 393078333245751296
- self.ANDROID_ROLE = 393087862972612627
- self.BSD_ROLE = 401791543708745738
-
- @commands.group(name="role", no_pm=True, pass_context=True,
- case_insensitive=True)
- async def _role(self, ctx):
- """Affiche l'aide sur la commande role"""
- if ctx.message.guild.id != 280805240977227776:
- return
-
- if ctx.invoked_subcommand is None:
- text = open('texts/roles.md').read()
- em = discord.Embed(title='Gestionnaires de rôles',
- description=text, colour=0x89C4F9)
- await ctx.send(embed=em)
-
- """---------------------------------------------------------------------"""
-
- @_role.command(name="arch", aliases=["archlinux", "arch_linux"],
- pass_context=True)
- async def role_arch(self, ctx):
- """Ajoute/retire le role 'Arch user'"""
- roles = ctx.message.author.roles
- role_id = []
- for role in roles:
- role_id.append(role.id)
-
- user = ctx.message.author
- if self.ARCH_ROLE in role_id:
- await user.remove_roles(discord.Object(id=self.ARCH_ROLE))
- await ctx.send(f"{ctx.message.author.mention} > Pourquoi tu viens "
- f"de supprimer Arch Linux, c'était trop compliqué "
- f"pour toi ? <:sad:343723037331292170>")
- else:
- await user.add_roles(discord.Object(id=self.ARCH_ROLE))
- await ctx.send(f"{ctx.message.author.mention} > How un "
- f"ArchLinuxien, c'est bon les ``yaourt`` ? "
- f"<:hap:354275645574086656>")
-
- """---------------------------------------------------------------------"""
-
- @_role.command(name="debian", pass_context=True)
- async def role_debian(self, ctx):
- """Ajoute/retire le role 'debian user'"""
- roles = ctx.message.author.roles
- role_id = []
- for role in roles:
- role_id.append(role.id)
-
- user = ctx.message.author
- if self.DEBIAN_ROLE in role_id:
- await user.remove_roles(discord.Object(id=self.DEBIAN_ROLE))
- await ctx.send(f"{ctx.message.author.mention} > Adieu ! Tu verras, "
- f"APT te manquera ! ")
- else:
- await user.add_roles(discord.Object(id=self.DEBIAN_ROLE))
- await ctx.send(f"{ctx.message.author.mention} > Un utilisateur de "
- f"Debian, encore et encore ! "
- f"<:stuck_out_tongue:343723077412323339>")
-
- """---------------------------------------------------------------------"""
-
- @_role.command(name="rhel", pass_context=True)
- async def role_rhel(self, ctx):
- """Ajoute/retire le role 'rhel user'"""
- roles = ctx.message.author.roles
- role_id = []
- for role in roles:
- role_id.append(role.id)
-
- user = ctx.message.author
- if self.RHEL_ROLE in role_id:
- await user.remove_roles(discord.Object(id=self.RHEL_ROLE))
- await ctx.send(f"{ctx.message.author.mention} > Pourquoi tu t'en "
- f"vas, il sont déjà assez seul là-bas "
- f"<:sad:343723037331292170>")
- else:
- await user.add_roles(discord.Object(id=self.RHEL_ROLE))
- await ctx.send(f"{ctx.message.author.mention} > Mais, voila "
- f"quelqu'un qui porte des chapeaux ! "
- f"<:hap:354275645574086656>")
-
- """---------------------------------------------------------------------"""
-
- @_role.command(name="android", pass_context=True)
- async def role_android(self, ctx):
- """Ajoute/retire le role 'android user'"""
- roles = ctx.message.author.roles
- role_id = []
- for role in roles:
- role_id.append(role.id)
-
- user = ctx.message.author
- if self.ANDROID_ROLE in role_id:
- await user.remove_roles(discord.Object(id=self.ANDROID_ROLE))
- await ctx.send(f"{ctx.message.author.mention} >How, me dit pas "
- f"que tu as compris que les Android's allaient "
- f"exterminer le monde ? "
- f"<:trollface:375327667160875008>")
- else:
- await user.add_roles(discord.Object(id=self.ANDROID_ROLE))
- await ctx.send(f"{ctx.message.author.mention} > Hey, un utilisateur"
- f" d'Android, prêt à continuer l'extermination de "
- f"WP et iOS ? "
- f"<:stuck_out_tongue:343723077412323339>")
-
- """---------------------------------------------------------------------"""
-
- @_role.command(name="bsd", pass_context=True)
- async def role_bsd(self, ctx):
- """Ajoute/retire le role 'BSD user'"""
- roles = ctx.message.author.roles
- role_id = []
- for role in roles:
- role_id.append(role.id)
-
- user = ctx.message.author
- if self.BSD_ROLE in role_id:
- await user.remove_roles(discord.Object(id=self.BSD_ROLE))
- await ctx.send(f"{ctx.message.author.mention} > Ohhhh fait gaffe "
- f"ou le démon va te piquer")
- else:
- await user.add_roles(discord.Object(id=self.BSD_ROLE))
- await ctx.send(f"{ctx.message.author.mention} > Quelqu'un sous "
- f"BSD ! Au moins il a pas besoin de mettre GNU "
- f"devant son OS à chaque fois :d")
-
- """---------------------------------------------------------------------"""
-
- @_role.command(name="staff", pass_context=True, hidden=True)
- async def role_staff(self, ctx):
- """Easter egg"""
-
- await ctx.send(f"{ctx.message.author.mention} > Vous n'avez pas "
- f"le rôle staff, tu crois quoi :joy:")
-
-
-def setup(bot):
- bot.add_cog(Role(bot))
diff --git a/cogs/search.py b/cogs/search.py
deleted file mode 100755
index 536413f..0000000
--- a/cogs/search.py
+++ /dev/null
@@ -1,157 +0,0 @@
-from discord.ext import commands
-import discord
-import asyncio
-import urllib.request
-import wikipedia
-
-wikipedia.set_lang("fr")
-
-
-class Search(commands.Cog):
- """Commandes de WWW."""
-
- def __init__(self, bot):
- self.bot = bot
-
- @commands.group(name="search", no_pm=True, pass_context=True)
- async def _search(self, ctx):
- """Rechercher sur le world wide web"""
- if ctx.invoked_subcommand is None:
- text = open('texts/search.md').read()
- em = discord.Embed(title='Commandes de search TuxBot',
- description=text,
- colour=0x89C4F9)
- await ctx.send(embed=em)
-
- @_search.command(pass_context=True, name="docubuntu")
- async def search_docubuntu(self, ctx, args):
- attends = await ctx.send("_Je te cherche ça {} !_".format(
- ctx.message.author.mention))
- html = urllib.request.urlopen("https://doc.ubuntu-fr.org/" +
- args).read()
- if "avez suivi un lien" in str(html):
- await attends.edit(content=":sob: Nooooon ! Cette page n'existe "
- "pas, mais tu peux toujours la créer : "
- "https://doc.ubuntu-fr.org/" + args)
- else:
- await attends.delete()
- embed = discord.Embed(description="Voila j'ai trouvé ! Voici la "
- "page ramenant à votre recherche,"
- " toujours aussi bien rédigée "
- ":wink: : https://doc.ubuntu-fr."
- "org/" + args,
- url='http://doc.ubuntu-fr.org/')
- embed.set_author(name="DocUbuntu-Fr",
- url='http://doc.ubuntu-fr.org/',
- icon_url='https://tuxbot.outout.xyz/data/ubuntu.png')
- embed.set_thumbnail(url='https://tuxbot.outout.xyz/data/ubuntu.png')
- embed.set_footer(text="Merci à ceux qui ont pris le temps d'écrire "
- "cette documentation")
- await ctx.send(embed=embed)
-
- @_search.command(pass_context=True, name="docarch")
- async def search_docarch(self, ctx, args):
- attends = await ctx.send("_Je te cherche ça {} !_".format(
- ctx.message.author.mention))
- html = urllib.request.urlopen("https://wiki.archlinux.org/index.php/" +
- args).read()
- if "There is currently no text in this page" in str(html):
- await attends.edit(content=":sob: Nooooon ! Cette page n'existe "
- "pas.")
- else:
- await attends.delete()
- embed = discord.Embed(description="Voila j'ai trouvé ! Voici la "
- "page ramenant à votre recherche,"
- " toujours aussi bien rédigée "
- ":wink: : https://wiki.archlinux."
- "org/index.php/" + args,
- url='https://wiki.archlinux.org/index.php/')
- embed.set_author(name="Doc ArchLinux",
- url='https://wiki.archlinux.org/index.php/',
- icon_url='https://tuxbot.outout.xyz/data/arch.png')
- embed.set_thumbnail(url='https://tuxbot.outout.xyz/data/arch.png')
- embed.set_footer(text="Merci à ceux qui ont pris le temps d'écrire "
- "cette documentation")
- await ctx.send(embed=embed)
-
- @_search.command(pass_context=True, name="wikipedia")
- async def search_wikipedia(self, ctx: commands.Context, args):
- """Fait une recherche sur wikipd"""
-
- wait = await ctx.send("_Je cherche..._")
- results = wikipedia.search(args)
- nbmr = 0
- mmssgg = ""
-
- for value in results:
- nbmr = nbmr + 1
- mmssgg = mmssgg + "**{}**: {} \n".format(str(nbmr), value)
-
- em = discord.Embed(title='Résultats de : ' + args,
- description = mmssgg,
- colour=0x4ECDC4)
- em.set_thumbnail(url="https://upload.wikimedia.org/wikipedia/commons/"
- "2/26/Paullusmagnus-logo_%28large%29.png")
- await wait.delete()
-
- sending = ["1⃣", "2⃣", "3⃣", "4⃣", "5⃣", "6⃣", "7⃣", "8⃣", "9⃣", "🔟"]
-
- def check(reaction, user):
- return user == ctx.author and reaction.emoji in sending and \
- reaction.message.id == msg.id
-
- async def waiter(future: asyncio.Future):
- reaction, user = await self.bot.wait_for('reaction_add',
- check=check)
- future.set_result(reaction.emoji)
-
- emoji = asyncio.Future()
- self.bot.loop.create_task(waiter(emoji))
-
- msg = await ctx.send(embed=em)
- for e in sending:
- await msg.add_reaction(e)
- if emoji.done():
- break
-
- while not emoji.done():
- await asyncio.sleep(0.1)
-
- page = int(sending.index(emoji.result()))
-
- args_ = results[page]
-
- try:
- await msg.delete()
- await ctx.trigger_typing()
- wait = await ctx.send(ctx.message.author.mention +
- " ah ok sympa cette recherche, je l'effectue de suite !")
- wp = wikipedia.page(args_)
- wp_contenu = wp.summary[:200] + "..."
- em = discord.Embed(title='Wikipedia : ' + wp.title,
- description = "{} \n_Lien_ : {} ".format(
- wp_contenu, wp.url),
- colour=0x9B59B6)
- em.set_author(name="Wikipedia",
- url='http://wikipedia.org',
- icon_url='https://upload.wikimedia.org/wikipedia/'
- 'commons/2/26/Paullusmagnus-logo_%28large'
- '%29.png')
- em.set_thumbnail(url = "https://upload.wikimedia.org/wikipedia/"
- "commons/2/26/Paullusmagnus-logo_%28large"
- "%29.png")
- em.set_footer(text="Merci à eux de nous fournir une encyclopédie "
- "libre !")
- await wait.delete()
- await ctx.send(embed=em)
-
- except wikipedia.exceptions.PageError:
- # TODO : A virer dans l'event on_error
- await ctx.send(":open_mouth: Une **erreur interne** est survenue,"
- " si cela ce reproduit contactez votre"
- " administrateur ou faites une Issue sur"
- " ``gitea`` !")
-
-
-def setup(bot):
- bot.add_cog(Search(bot))
diff --git a/cogs/send_logs.py b/cogs/send_logs.py
deleted file mode 100755
index 46c8952..0000000
--- a/cogs/send_logs.py
+++ /dev/null
@@ -1,105 +0,0 @@
-import datetime
-import socket
-
-import discord
-from discord.ext import commands
-
-
-class SendLogs(commands.Cog):
- """Send logs to a specific channel"""
-
- def __init__(self, bot):
-
- self.bot = bot
- self.log_channel = None
- self.main_server_id = int(self.bot.config.main_server_id)
-
- @commands.Cog.listener()
- async def on_resumed(self):
- em = discord.Embed(title="Et hop je me reconnecte à l'api 😃",
- colour=0x5cb85c)
- em.timestamp = datetime.datetime.utcnow()
- await self.log_channel.send(embed=em)
-
- @commands.Cog.listener()
- async def on_ready(self):
- self.log_channel = await self.bot.fetch_channel(int(self.bot.config.log_channel_id))
- em = discord.Embed(title="Je suis opérationnel 😃",
- description=f"*Instance lancée sur "
- f"{socket.gethostname()}*", colour=0x5cb85c)
- em.timestamp = datetime.datetime.utcnow()
- await self.log_channel.send(embed=em)
-
- """---------------------------------------------------------------------"""
-
- @commands.Cog.listener()
- async def on_guild_join(self, guild: discord.Guild):
- em = discord.Embed(title=f"On m'a ajouté à : {str(guild.name)} 😃",
- colour=0x51A351)
- em.timestamp = datetime.datetime.utcnow()
- await self.log_channel.send(embed=em)
-
- @commands.Cog.listener()
- async def on_guild_remove(self, guild: discord.Guild):
- em = discord.Embed(title=f"On m'a viré de : {str(guild.name)} 😦",
- colour=0xBD362F)
- em.timestamp = datetime.datetime.utcnow()
- await self.log_channel.send(embed=em)
-
- """---------------------------------------------------------------------"""
-
- @commands.Cog.listener()
- async def on_member_join(self, member):
- if member.guild.id == self.main_server_id:
- em = discord.Embed(title=f"{str(member)} *`({str(member.id)})`* "
- f"nous a rejoint 😃", colour=0x51A351)
- em.set_footer(text=f"Compte crée le {member.created_at}")
- em.timestamp = datetime.datetime.utcnow()
- await self.log_channel.send(embed=em)
-
- @commands.Cog.listener()
- async def on_member_remove(self, member):
- if member.guild.id == self.main_server_id:
- em = discord.Embed(title=f"{str(member)} *`({str(member.id)})`* "
- f"nous a quitté 😦", colour=0xBD362F)
- em.timestamp = datetime.datetime.utcnow()
- await self.log_channel.send(embed=em)
-
- """---------------------------------------------------------------------"""
-
- @commands.Cog.listener()
- async def on_message_delete(self, message):
- if message.guild.id == self.main_server_id and not message.author.bot:
- async def is_a_command(message):
- prefix_lenght = len(await self.bot.get_prefix(message))
- command = (message.content.split()[0])[prefix_lenght:]
- if command == '':
- command = "not_a_command"
-
- return self.bot.get_command(str(command))
-
- if await is_a_command(message) is None:
- em = discord.Embed(title=f"Message supprimé dans :"
- f" {str(message.channel.name)}",
- colour=0xBD362F)
- em.add_field(name=f"{str(message.author)} "
- f"*`({str(message.author.id)})`* "
- f"a supprimé :", value=str(message.content))
- em.timestamp = datetime.datetime.utcnow()
- await self.log_channel.send(embed=em)
-
- @commands.Cog.listener()
- async def on_message_edit(self, before, after):
- if before.guild.id == self.main_server_id and not before.author.bot:
- em = discord.Embed(title=f"Message edité dans : "
- f"{before.channel.name}", colour=0x0088CC)
- em.add_field(name=f"{str(before.author)} "
- f"*`({str(before.author.id)})`* a"
- f" edité :", value=str(before.content))
- em.add_field(name="Pour remplacer par :", value=str(after.content))
- em.timestamp = datetime.datetime.utcnow()
- await self.log_channel.send(embed=em)
-
-
-def setup(bot):
- bot.add_cog(SendLogs(bot))
diff --git a/cogs/sondage.py b/cogs/sondage.py
deleted file mode 100755
index d113419..0000000
--- a/cogs/sondage.py
+++ /dev/null
@@ -1,98 +0,0 @@
-import asyncio
-
-import discord
-from discord.ext import commands
-
-
-class Sondage(commands.Cog):
- """Commandes sondage."""
-
- def __init__(self, bot):
- self.bot = bot
-
- @commands.command(pass_context=True)
- async def sondage(self, ctx, *, msg="help"):
- if msg != "help":
- await ctx.message.delete()
- options = msg.split(" | ")
-
- times = [x for x in options if x.startswith("time=")]
-
- if times:
- time = int(times[0].strip("time="))
- options.remove(times[0])
- else:
- time = 0
-
- if len(options) <= 1:
- raise commands.errors.MissingRequiredArgument
- if len(options) >= 22:
- return await ctx.send(f"{ctx.message.author.mention}> "
- f":octagonal_sign: Vous ne pouvez pas "
- f"mettre plus de 20 réponses !")
-
- emoji = ['1⃣', '2⃣', '3⃣', '4⃣', '5⃣', '6⃣', '7⃣', '8⃣', '9⃣', '🔟', '0⃣',
- '🇦', '🇧', '🇨', '🇩', '🇪', '🇫', '🇬', '🇭', '🇮']
- to_react = []
- confirmation_msg = f"**{options[0].rstrip('?')}?**:\n\n"
-
- for idx, option in enumerate(options[1:]):
- confirmation_msg += f"{emoji[idx]} - {option}\n"
- to_react.append(emoji[idx])
-
- confirmation_msg += "*Sondage proposé par* " + \
- str(ctx.message.author.mention)
- if time == 0:
- confirmation_msg += ""
- else:
- confirmation_msg += f"\n\nVous avez {time} secondes pour voter!"
-
- poll_msg = await ctx.send(confirmation_msg)
- for emote in to_react:
- await poll_msg.add_reaction(emote)
-
- if time != 0:
- await asyncio.sleep(time)
- async for message in ctx.message.channel.history():
- if message.id == poll_msg.id:
- poll_msg = message
-
- results = {}
-
- for reaction in poll_msg.reactions:
- if reaction.emoji in to_react:
- results[reaction.emoji] = reaction.count - 1
- end_msg = "Le sondage est términé. Les résultats sont:\n\n"
-
- for result in results:
- end_msg += "{} {} - {} votes\n". \
- format(result,
- options[emoji.index(result)+1],
- results[result])
-
- top_result = max(results, key=lambda key: results[key])
-
- if len([x for x in results
- if results[x] == results[top_result]]) > 1:
- top_results = []
- for key, value in results.items():
- if value == results[top_result]:
- top_results.append(options[emoji.index(key)+1])
- end_msg += "\nLes gagnants sont : {}". \
- format(", ".join(top_results))
- else:
- top_result = options[emoji.index(top_result)+1]
- end_msg += "\n\"{}\" est le gagnant!".format(top_result)
- await ctx.send(end_msg)
- else:
- await ctx.message.delete()
-
- text = open('texts/rpoll.md').read()
- em = discord.Embed(title='Aide sur le sondage',
- description=text,
- colour=0xEEEEEE)
- await ctx.send(embed=em)
-
-
-def setup(bot):
- bot.add_cog(Sondage(bot))
diff --git a/cogs/utility.py b/cogs/utility.py
deleted file mode 100755
index 30d5f49..0000000
--- a/cogs/utility.py
+++ /dev/null
@@ -1,363 +0,0 @@
-import datetime
-import json
-import pytz
-import random
-import urllib
-
-import discord
-import requests
-from discord.ext import commands
-import socket
-
-class Utility(commands.Cog):
- """Commandes utilitaires."""
-
- def __init__(self, bot):
- self.bot = bot
-
- @commands.group(name="clock", pass_context=True, case_insensitive=True)
- async def clock(self, ctx):
- """Display hour in a country"""
-
- if ctx.invoked_subcommand is None:
- text = open('texts/clocks.md').read()
- em = discord.Embed(title='Liste des Horloges', description=text, colour=0xEEEEEE)
- await ctx.send(embed=em)
-
- @clock.command(name="montréal", aliases=["mtl", "montreal"], pass_context=True)
- async def clock_montreal(self, ctx):
- then = datetime.datetime.now(pytz.utc)
-
- utc = then.astimezone(pytz.timezone('America/Montreal'))
- site = "http://ville.montreal.qc.ca/"
- img = "https://upload.wikimedia.org/wikipedia/commons/e/e0/Rentier_fws_1.jpg"
- country = "au Canada, Québec"
- description = "Montréal est la deuxième ville la plus peuplée du Canada. Elle se situe dans la région du Québec"
-
- form = '%H heures %M'
- tt = utc.strftime(form)
-
- em = discord.Embed(title='Heure à Montréal', description=f"A [Montréal]({site}) {country}, Il est **{str(tt)}** ! \n {description} \n _source des images et du texte : [Wikimedia foundation](http://commons.wikimedia.org/)_", colour=0xEEEEEE)
- em.set_thumbnail(url = img)
- await ctx.send(embed=em)
-
- @clock.command(name="vancouver", pass_context=True)
- async def clock_vancouver(self, ctx):
- then = datetime.datetime.now(pytz.utc)
-
- utc = then.astimezone(pytz.timezone('America/Vancouver'))
- site = "http://vancouver.ca/"
- img = "https://upload.wikimedia.org/wikipedia/commons/f/fe/Dock_Vancouver.JPG"
- country = "au Canada"
- description = "Vancouver, officiellement City of Vancouver, est une cité portuaire au Canada"
-
- form = '%H heures %M'
- tt = utc.strftime(form)
-
- em = discord.Embed(title='Heure à Vancouver', description=f"A [Vancouver]({site}) {country}, Il est **{str(tt)}** ! \n {description} \n _source des images et du texte : [Wikimedia foundation](http://commons.wikimedia.org/)_", colour=0xEEEEEE)
- em.set_thumbnail(url = img)
- await ctx.send(embed=em)
-
- @clock.command(name="new-york",aliases=["ny", "n-y", "new york"], pass_context=True)
- async def clock_new_york(self, ctx):
- then = datetime.datetime.now(pytz.utc)
-
- utc = then.astimezone(pytz.timezone('America/New_York'))
- site = "http://www1.nyc.gov/"
- img = "https://upload.wikimedia.org/wikipedia/commons/e/e3/NewYork_LibertyStatue.jpg"
- country = "aux U.S.A."
- description = "New York, est la plus grande ville des États-Unis en termes d'habitants et l'une des plus importantes du continent américain. "
-
- form = '%H heures %M'
- tt = utc.strftime(form)
-
- em = discord.Embed(title='Heure à New York', description=f"A [str(New York]({site}) {country}, Il est **{str(tt)}** ! \n {description} \n _source des images et du texte : [Wikimedia foundation](http://commons.wikimedia.org/)_", colour=0xEEEEEE)
- em.set_thumbnail(url = img)
- await ctx.send(embed=em)
-
- @clock.command(name="la", aliases=["los-angeles", "losangeles", "l-a", "los angeles"], pass_context=True)
- async def clock_la(self, ctx):
- then = datetime.datetime.now(pytz.utc)
-
- utc = then.astimezone(pytz.timezone('America/Los_Angeles'))
- site = "https://www.lacity.org/"
- img = "https://upload.wikimedia.org/wikipedia/commons/thumb/5/57/LA_Skyline_Mountains2.jpg/800px-LA_Skyline_Mountains2.jpg"
- country = "aux U.S.A."
- description = "Los Angeles est la deuxième ville la plus peuplée des États-Unis après New York. Elle est située dans le sud de l'État de Californie, sur la côte pacifique."
-
- form = '%H heures %M'
- tt = utc.strftime(form)
-
- em = discord.Embed(title='Heure à Los Angeles', description=f"A [Los Angeles]({site}) {country}, Il est **{str(tt)}** ! \n {description} \n _source des images et du texte : [Wikimedia foundation](http://commons.wikimedia.org/)_", colour=0xEEEEEE)
- em.set_thumbnail(url = img)
- await ctx.send(embed=em)
-
- @clock.command(name="paris", aliases=["baguette"],pass_context=True)
- async def clock_paris(self, ctx):
- then = datetime.datetime.now(pytz.utc)
-
- utc = then.astimezone(pytz.timezone('Europe/Paris'))
- site = "http://www.paris.fr/"
- img = "https://upload.wikimedia.org/wikipedia/commons/a/af/Tour_eiffel_at_sunrise_from_the_trocadero.jpg"
- country = "en France"
- description = "Paris est la capitale de la France. Elle se situe au cœur d'un vaste bassin sédimentaire aux sols fertiles et au climat tempéré, le bassin parisien."
-
- form = '%H heures %M'
- tt = utc.strftime(form)
-
- em = discord.Embed(title='Heure à Paris', description=f"A [Paris]({site}) {country}, Il est **{str(tt)}** ! \n {description} \n _source des images et du texte : [Wikimedia foundation](http://commons.wikimedia.org/)_", colour=0xEEEEEE)
- em.set_thumbnail(url = img)
- await ctx.send(embed=em)
-
- @clock.command(name="berlin", pass_context=True)
- async def clock_berlin(self, ctx):
- then = datetime.datetime.now(pytz.utc)
-
- utc = then.astimezone(pytz.timezone('Europe/Berlin'))
- site = "http://www.berlin.de/"
- img = "https://upload.wikimedia.org/wikipedia/commons/9/91/Eduard_Gaertner_Schlossfreiheit.jpg"
- country = "en Allemagne"
- description = "Berlin est la capitale et la plus grande ville d'Allemagne. Située dans le nord-est du pays, elle compte environ 3,5 millions d'habitants. "
-
- form = '%H heures %M'
- tt = utc.strftime(form)
-
- em = discord.Embed(title='Heure à Berlin', description=f"A [Berlin]({site}) {country}, Il est **{str(tt)}** ! \n {description} \n _source des images et du texte : [Wikimedia foundation](http://commons.wikimedia.org/)_", colour=0xEEEEEE)
- em.set_thumbnail(url = img)
- await ctx.send(embed=em)
-
- @clock.command(name="berne", aliases=["zurich", "bern"], pass_context=True)
- async def clock_berne(self, ctx):
- then = datetime.datetime.now(pytz.utc)
-
- utc = then.astimezone(pytz.timezone('Europe/Zurich'))
- site = "http://www.berne.ch/"
- img = "https://upload.wikimedia.org/wikipedia/commons/d/db/Justitia_Statue_02.jpg"
- country = "en Suisse"
- description = "Berne est la cinquième plus grande ville de Suisse et la capitale du canton homonyme. Depuis 1848, Berne est la « ville fédérale »."
-
- form = '%H heures %M'
- tt = utc.strftime(form)
-
- em = discord.Embed(title='Heure à Berne', description=f"A [Berne]({site}) {country}, Il est **{str(tt)}** ! \n {description} \n _source des images et du texte : [Wikimedia foundation](http://commons.wikimedia.org/)_", colour=0xEEEEEE)
- em.set_thumbnail(url = img)
- await ctx.send(embed=em)
-
- @clock.command(name="tokyo", pass_context=True)
- async def clock_tokyo(self, ctx):
- then = datetime.datetime.now(pytz.utc)
-
- utc = then.astimezone(pytz.timezone('Asia/Tokyo'))
- site = "http://www.gotokyo.org/"
- img = "https://upload.wikimedia.org/wikipedia/commons/3/37/TaroTokyo20110213-TokyoTower-01.jpg"
- country = "au Japon"
- description = "Tokyo, anciennement Edo, officiellement la préfecture métropolitaine de Tokyo, est la capitale du Japon."
-
- form = '%H heures %M'
- tt = utc.strftime(form)
-
- em = discord.Embed(title='Heure à Tokyo', description=f"A [Tokyo]({site}) {country}, Il est **{str(tt)}** ! \n {description} \n _source des images et du texte : [Wikimedia foundation](http://commons.wikimedia.org/)_", colour=0xEEEEEE)
- em.set_thumbnail(url = img)
- await ctx.send(embed=em)
-
- @clock.command(name="moscou", aliases=["moscow", "moskova"], pass_context=True)
- async def clock_moscou(self, ctx):
- then = datetime.datetime.now(pytz.utc)
-
- utc = then.astimezone(pytz.timezone('Europe/Moscow'))
- site = "https://www.mos.ru/"
- img = "https://upload.wikimedia.org/wikipedia/commons/f/f7/Andreyevsky_Zal.jpg"
- country = "en Russie"
- description = "Moscou est la capitale de la Fédération de Russie et la plus grande ville d'Europe. Moscou est situé sur la rivière Moskova. "
-
- form = '%H heures %M'
- tt = utc.strftime(form)
-
- em = discord.Embed(title='Heure à Moscou', description=f"A [Moscou]({site}) {country}, Il est **{str(tt)}** ! \n {description} \n _source des images et du texte : [Wikimedia foundation](http://commons.wikimedia.org/)_", colour=0xEEEEEE)
- em.set_thumbnail(url = img)
- await ctx.send(embed=em)
-
- """---------------------------------------------------------------------"""
-
- @commands.command()
- async def ytdiscover(self, ctx):
- """Random youtube channel"""
- with open('texts/ytb.json') as js:
- ytb = json.load(js)
-
- clef = str(random.randint(0,12))
- chaine = ytb["{}".format(clef)]
-
- embed = discord.Embed(title=chaine['name'],
- url=chaine['url'],
- description=f"**{chaine['name']}**, {chaine['desc']} \n[Je veux voir ça]({chaine['url']})")
- embed.set_thumbnail(url='https://outout.tech/tuxbot/yt.png')
- await ctx.send(embed=embed)
-
- """---------------------------------------------------------------------"""
-
- @commands.command(name='iplocalise', pass_context=True)
- async def _iplocalise(self, ctx, ipaddress, iptype=""):
- realipaddress = ipaddress
- """Recup headers."""
- if ipaddress.startswith("http://"):
- if ipaddress[-1:] == '/':
- ipaddress = ipaddress[:-1]
- ipaddress = ipaddress.split("http://")[1]
- if ipaddress.startswith("https://"):
- if ipaddress[-1:] == '/':
- ipaddress = ipaddress[:-1]
- ipaddress = ipaddress.split("https://")[1]
-
- if(iptype=="ipv6" or iptype=="v6"):
- try:
- ipaddress = socket.getaddrinfo(ipaddress, None, socket.AF_INET6)[1][4][0]
-
- if (ipaddress == "2602:fe53:b:1::87") and not ("gnous" in realipaddress):
- await ctx.send("Erreur, cette adresse n'est pas disponible en IPv6.")
- return
- except Exception as e:
- await ctx.send("Erreur, cette adresse n'est pas disponible en IPv6.")
- print(e)
- return
-
- iploading = await ctx.send("_réfléchis..._")
- ipapi = urllib.request.urlopen("http://ip-api.com/json/" + ipaddress)
- ipinfo = json.loads(ipapi.read().decode())
-
- if ipinfo["status"] != "fail":
- if ipinfo['query']:
- embed = discord.Embed(title=f"Informations pour ``{realipaddress}`` *`({ipinfo['query']})`*", color=0x5858d7)
-
- if ipinfo['org']:
- embed.add_field(name="Appartient à :", value=ipinfo['org'], inline = False)
-
- if ipinfo['city']:
- embed.add_field(name="Se situe à :", value=ipinfo['city'], inline = True)
-
-
- if ipinfo['country']:
- if ipinfo['regionName']:
- regionName = ipinfo['regionName']
- else:
- regionName = "N/A"
- embed.add_field(name="Region :", value=f"{regionName} ({ipinfo['country']})", inline = True)
-
- embed.set_thumbnail(url=f"https://www.countryflags.io/{ipinfo['countryCode']}/flat/64.png")
- await ctx.send(embed=embed)
- else:
- await ctx.send(content=f"Erreur, impossible d'avoir des informations sur l'adresse IP ``{ipinfo['query']}``")
- await iploading.delete()
-
- """---------------------------------------------------------------------"""
- @commands.command(name='getheaders', pass_context=True)
- async def _getheaders(self, ctx, *, adresse):
- """Recuperer les HEADERS :d"""
- if adresse.startswith("http://") != True and adresse.startswith("https://") != True:
- adresse = "http://" + adresse
- if len(adresse) > 200:
- await ctx.send("{0} Essaye d'entrer une adresse de moins de 200 caractères plutôt.".format(ctx.author.mention))
-
- elif adresse.startswith("http://") or adresse.startswith("https://") or adresse.startswith("ftp://"):
- try:
- get = urllib.request.urlopen(adresse, timeout = 1)
- embed = discord.Embed(title="Entêtes de {0}".format(adresse), color=0xd75858)
- embed.add_field(name="Code Réponse", value=get.getcode(), inline = True)
- embed.set_thumbnail(url="https://http.cat/{}".format(str(get.getcode())))
- if get.getheader('location'):
- embed.add_field(name="Redirection vers", value=get.getheader('location'), inline=True)
- if get.getheader('server'):
- embed.add_field(name="Serveur", value=get.getheader('server'), inline=True)
- if get.getheader('content-type'):
- embed.add_field(name="Type de contenu", value = get.getheader('content-type'), inline = True)
- if get.getheader('x-content-type-options'):
- embed.add_field(name="x-content-type", value= get.getheader('x-content-type-options'), inline=True)
- if get.getheader('x-frame-options'):
- embed.add_field(name="x-frame-options", value= get.getheader('x-frame-options'), inline=True)
- if get.getheader('cache-control'):
- embed.add_field(name="Controle du cache", value = get.getheader('cache-control'), inline = True)
- await ctx.send(embed=embed)
- except urllib.error.HTTPError as e:
- embed = discord.Embed(title="Entêtes de {0}".format(adresse), color=0xd75858)
- embed.add_field(name="Code Réponse", value=e.getcode(), inline = True)
- embed.set_thumbnail(url="https://http.cat/{}".format(str(e.getcode())))
- await ctx.send(embed=embed)
- print('''An error occurred: {} The response code was {}'''.format(e, e.getcode()))
- except urllib.error.URLError as e:
- if "No address associated" in str(e):
- await ctx.send("Erreur, aucune adresse n'est associé à ce nom d'hôte.")
- return
- if "timed out" in str(e):
- await ctx.send("Erreur, l'adresse en question dépasse le délais d'attente :(")
- return
- if "SSL" in str(e):
- await ctx.send("Erreur avec le certificat SSL, essayez sans ``https://`` !")
- return
- return
- if "no host":
- await ctx.send("Erreur, aucun nom d'hôte n'a été donné.")
- return
- if "not known":
- await ctx.send("Erreur, nom de l'hôte inconnu.")
- return
- print("ERROR @ getheaders @ urlerror : {} - adress {}".format(e, adresse))
- await ctx.send('[CONTACTER ADMIN] URLError: {}'.format(e.reason))
- except Exception as e:
- print("ERROR @ getheaders @ Exception : {} - adress {}".format(e, adresse))
- await ctx.send("{0} Impossible d'accèder à {1}, es-tu sur que l'adresse {1} est correcte et que le serveur est allumé ?".format(ctx.author.mention, adresse))
- else:
- await ctx.send("{0} Merci de faire commencer {1} par ``https://``, ``http://`` ou ``ftp://``.".format(ctx.author.mention, adresse))
-
- """---------------------------------------------------------------------"""
-
- @commands.command(name='git', pass_context=True)
- async def _git(self, ctx):
- """Pour voir mon code"""
- text = "How tu veux voir mon repos Gitea pour me disséquer ? " \
- "Pas de soucis ! Je suis un Bot, je ne ressens pas la " \
- "douleur !\n https://git.gnous.eu/gnouseu/tuxbot-bot"
- em = discord.Embed(title='Repos TuxBot-Bot', description=text, colour=0xE9D460)
- em.set_author(name='Gnous', icon_url="https://cdn.discordapp.com/"
- "icons/280805240977227776/"
- "9ba1f756c9d9bfcf27989d0d0abb3862"
- ".png")
- await ctx.send(embed=em)
-
- """---------------------------------------------------------------------"""
-
- @commands.command(name='quote', pass_context=True)
- async def _quote(self, ctx, quote_id):
- global quoted_message
-
- async def get_message(message_id: int):
- for channel in ctx.message.guild.channels:
- if isinstance(channel, discord.TextChannel):
- test_chan = await self.bot.fetch_channel(channel.id)
- try:
- return await test_chan.fetch_message(message_id)
- except (discord.NotFound, discord.Forbidden):
- pass
- return None
-
- quoted_message = await get_message(int(quote_id))
-
- if quoted_message is not None:
- embed = discord.Embed(colour=quoted_message.author.colour,
- description=quoted_message.clean_content,
- timestamp=quoted_message.created_at)
- embed.set_author(name=quoted_message.author.display_name,
- icon_url=quoted_message.author.avatar_url_as(
- format="jpg"))
- if len(quoted_message.attachments) >= 1:
- embed.set_image(url=quoted_message.attachments[0].url)
- embed.add_field(name="**Original**",
- value=f"[Go!]({quoted_message.jump_url})")
- embed.set_footer(text="#" + quoted_message.channel.name)
-
- await ctx.send(embed=embed)
- else:
- await ctx.send("Impossible de trouver le message.")
-
-
-def setup(bot):
- bot.add_cog(Utility(bot))
diff --git a/cogs/vocal.py b/cogs/vocal.py
deleted file mode 100755
index fc21169..0000000
--- a/cogs/vocal.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import asyncio
-import os
-import re
-import subprocess
-import uuid
-
-import discord
-from discord.ext import commands
-from gtts import gTTS
-
-
-class Vocal(commands.Cog):
-
- def __init__(self, bot):
- self.bot = bot
- self.playing = False
- self.author = None
- self.voice = None
-
- """---------------------------------------------------------------------"""
-
- @staticmethod
- def get_duration(file):
- popen = subprocess.Popen(("ffprobe",
- "-show_entries",
- "format=duration",
- "-i", file),
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
- output, err = popen.communicate()
- match = re.search(r"[-+]?\d*\.\d+|\d+", str(output))
- return float(match.group())
-
- @commands.command(name="voc", no_pm=True, pass_context=True)
- async def _voc(self, ctx, *, message=""):
- if message == "":
- await ctx.send("Veuillez écrire un message...")
- return
- if message == "stop_playing" \
- and (
- ctx.author.id == self.author.id
- or ctx.message.channel.permissions_for(
- ctx.message.author
- ).administrator is True
- ) \
- and self.playing is True:
-
- await ctx.send('stop')
- await self.voice.disconnect()
- self.playing = False
- return
-
- if self.playing is True:
- await ctx.send("Je suis déja en train de parler,"
- " merci de réenvoyer ton message"
- " quand j'aurais fini.")
- return
-
- user = ctx.author
- self.author = user
-
- if user.voice:
- self.playing = True
- filename = f"data/tmp/voc/{uuid.uuid1()}.mp3"
- lang = [x for x in message.split(" ") if x.startswith("lang=")]
-
- loading = await ctx.send("*Chargement du message en cours...*")
-
- if lang:
- choice_lang = (lang[0])[5:]
- message = f"{user.display_name} à dit: {message.strip(lang[0])}" if len(ctx.author.voice.channel.members) >= 4 else message.strip(lang[0])
-
- try:
- tts = gTTS(
- text=message,
- lang=str(choice_lang))
- except ValueError:
- tts = gTTS(
- text=message,
- lang="fr")
- await ctx.send("La langue n'est pas supportée,"
- " le francais a donc été choisi")
- else:
- message = f"{user.display_name} à dit: {message}" if len(ctx.author.voice.channel.members) >= 4 else message
- tts = gTTS(text=message,
- lang="fr")
-
- tts.save(filename)
-
- self.voice = await user.voice.channel.connect()
- self.voice.play(discord.FFmpegPCMAudio(filename))
- counter = 0
- duration = self.get_duration(filename)
- while not counter >= duration:
- if self.playing:
- await loading.edit(
- content=f"Lecture du message de {self.author.display_name} en cours : {counter}sec/{duration}sec")
- await asyncio.sleep(1)
- counter += 1
- else:
- break
- await self.voice.disconnect()
-
- await loading.edit(content="Lecture terminée")
- self.voice = None
- os.remove(filename)
- self.playing = False
- else:
- await ctx.send('Veuillez aller dans un channel vocal.')
-
-
-def setup(bot):
- bot.add_cog(Vocal(bot))