Tu as toujours voulu créer un bot Discord mais tu n'as jamais su comment faire ? Alors ce tuto est

Mise en place d'un bot Discord en Python

Dans ce chapitre nous allons voir comment créer nos commandes modérations.

***

### 🚪 Commandes kick

Cette commande, tout le monde la connaît,

Créer les commandes ban, unban & kick sur un bot Discord en Python

Dans ce tuto, nous allons voir la suite de nos commandes modérations !

***

### 🪪 La commande nickname

La commande nickname est

Créer les commandes mute, unmute & nickname sur un bot Discord en Python

Python

Dans ce tuto, nous allons voir la suite de nos commandes modérations !

***

### 🪪 La commande nickname

La commande nickname est une commande qui permet de changer le pseudo d'un utilisateur sur notre discord. Cependant, cette dernière ne permet pas de changer le peudo d'un utilisateur de manière générale !

Attaquons le code de notre bot, créer un fichier `nickname.py` dans notre dossier `cogs`.

Voyons maintenant le code de notre bot:

```python
import discord
from discord.ext import commands

class Nick(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command()
    async def nick(self, ctx: commands.Context, target: discord.Member, *, nickname:str=None) -> discord.Message:
        has_permission = ctx.author.guild_permissions.manage_nicknames
        if not has_permission:
            return await ctx.send("Vous n'avez pas la permission d'effectuer cette commande sur ce membre !")
        is_in_private = ctx.guild is None and isinstance(ctx.author, discord.TextChannel)
        if is_in_private:
            return await ctx.send("Vous ne pouvez pas exécuter cette commande en privé !")
        is_nickable = ctx.author.top_role > target.top_role
        if not is_nickable:
            return await ctx.send("Vous ne pouvez pas nick ce membre !")
        
        await target.edit(nick=nickname)

        return await ctx.send(f"Le nickname de **{target.name}** a été définit sur **{nickname}** !")
    
    @nick.error
    async def nick_error(self, ctx: commands.Context, error):
        if isinstance(error, commands.MissingFlagArgument):
            return
    
async def setup(bot):
    await bot.add_cog(Nick(bot))
```

Nous avons, comme pour toutes nos commandes, la base de code qui permet à notre commande d'être envoyer dans notre handler présent dans le fichier `main.py` (e.i. Voir le chapitre de mise en place).

Nous avons ensuite notre bloc de conditions qui permet d'assurer le bon fonctionnement et la sécurité de notre commande.

Une fois que toutes nos conditions sont validées par notre bot, nous pouvons exécutés cette ligne de code:

```python
await target.edit(nick=nickname)

return await ctx.send(f"Le nickname de **{target.name}** a été définit sur **{nickname}** !")
```

Nous avons également une autre ligne importante qui permet d'éviter les erreurs en console en cas de mauvaise exécution de notre commande:

```python
@nick.error
async def nick_error(self, ctx: commands.Context, error):
      if isinstance(error, commands.MissingFlagArgument):
         return
```

![Description](https://i.imgur.com/6FeX0Il.png)

Voilà pour notre commande nickname, passons maintenant à la commande mute !

***

### 🔇 La commande mute

La commande mute permet d'interdir à un joueur de parler dans n'importe quels salons présents sur votre serveur !

Attaquons le code de notre bot, créer un fichier `mute.py` dans notre dossier `cogs`.

Voyons notre code (à savoir que je n'expliquerai pas en détail l'ensemble du code car une grande partie est similaire aux autres commandes et ces dernières ont été expliquées en détails dans les chapitres précédents):

```python
import discord
from discord.ext import commands

class Mute(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command()
    async def mute(self, ctx: commands.Context, target: discord.Member, *, reason: str=""):
        is_in_private = ctx.guild is None and isinstance(ctx.author, discord.TextChannel)
        if is_in_private:
            return await ctx.send("Vous ne pouvez pas exécuter cette commande en privé !")
        has_permissions = ctx.author.guild_permissions.manage_roles
        if not has_permissions:
            return await ctx.send("Vous n'avez pas les permissions de mute ce membre !")
        is_mutable = ctx.author.top_role > target.top_role
        if not is_mutable:
            return await ctx.send("Vous ne pouvez pas mute ce membre !")
        
        role = discord.utils.get(ctx.guild.roles, name="Muted")
        guild = ctx.guild

        if role not in guild.roles:
            perms = discord.Permissions(send_messages=False, speak=False)
            await guild.create_role(name="Muted", permissions=perms)
            await target.add_roles(role)
            await ctx.send(f"{target} a été mute avec succès (raison: {reason}) ! ✅")
        else:
            await target.add_roles(role)
            await ctx.send(f"{target} a été mute avec succès (raison: {reason}) ! ✅")   


async def setup(bot):
    await bot.add_cog(Mute(bot))
``` 

Le code qui va nous intéresser ici se trouve à partir de ce niveau:

```python
        role = discord.utils.get(ctx.guild.roles, name="Muted")
        guild = ctx.guild

        if role not in guild.roles:
            perms = discord.Permissions(send_messages=False, speak=False)
            await guild.create_role(name="Muted", permissions=perms)
            await target.add_roles(role)
            await ctx.send(f"{target} a été mute avec succès (raison: {reason}) ! ✅")
        else:
            await target.add_roles(role)
            await ctx.send(f"{target} a été mute avec succès (raison: {reason}) ! ✅")   
```

* Dans un premier temps, nous récupérons le rôle qui nous sert à mute et nous stockons ce dernier dans notre variable `role`.

La ligne juste en dessous nous permet de raccourcir notre code tout simplement.

* Ensuite, nous rentrons dans une première boucle de condition qui permet de vérifier si le rôle existe et si ce dernier n'existe pas, de le créer avec les permissions nécessaires pour que la personne mute ne puisse parler dans aucun channel.

* Pour finir, si notre rôle est déjà présent au préalable sur notre serveur, nous allons juste nous occuper d'assigner le rôle que nous avons renseigner dans notre variable `role` à la personne que nous souhaitons mute.

Et voilà le résultat:

![Description](https://i.imgur.com/GJzdg0e.png)

***

### 🔉 Commande d'unmute

À l'inverse de notre commande mute, notre commande unmute nous serviras à unmute une personne qui a été mute (logique).

Attaquons le code de notre bot, créer un fichier `unmute.py` dans notre dossier `cogs`.

Voici notre code:

```python
import discord
from discord.ext import commands

class Unmute(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command()
    async def unmute(self, ctx: commands.Context, target: discord.Member):
        is_in_private = ctx.guild is None and isinstance(ctx.author, discord.TextChannel)
        if is_in_private:
            return await ctx.send("Vous ne pouvez pas exécuter cette commande en privé !")
        has_permissions = ctx.author.guild_permissions.manage_roles
        if not has_permissions:
            return await ctx.send("Vous n'avez pas les permissions d'unmute ce membre !")
        is_mutable = ctx.author.top_role > target.top_role
        if not is_mutable:
            return await ctx.send("Vous ne pouvez pas unmute ce membre !")
        
        role = discord.utils.get(ctx.guild.roles, name="Muted")
        guild = ctx.guild

        await target.remove_roles(role)
        await ctx.send(f"{target} a été unmute avec succès ! ✅")   


async def setup(bot):
    await bot.add_cog(Unmute(bot))
```

Ici, rien de différent par rapport à notre commande mute sauf au niveau de la fin de notre code, En effet:

```python
role = discord.utils.get(ctx.guild.roles, name="Muted")
guild = ctx.guild

await target.remove_roles(role)
await ctx.send(f"{target} a été unmute avec succès ! ✅")   
```

Ici, nous déclarons bien sûr notre variable rôle avec le même rôle que nous avons utilisé pour mute et pour finir nous indiquons à notre bot qu'il faut enlever le rôle à la personne souhaitée, ici la `target`.

Et voilà, vous pouvez maintenant unmute quelqu'un depuis votre bot !

![Description](https://i.imgur.com/WycXCb8.png)

***

### 📝 Tutos à suivre...

Dans un prochain tutoriel, nous verrons comment créer un système de `ticket` avec Discord.py !

<data>NE PAS SUPPRIMER CETTE LIGNE!</data>

Les premières étapes de la création d'un bot Discord en Python