Aller au contenu

Role

RoleCog

Bases: GroupCog

Commandes liées à la gestion des rôles

Source code in etuutt_bot/commands/role.py 
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
@app_commands.default_permissions(administrator=True)
class RoleCog(commands.GroupCog, group_name="role"):
    """Commandes liées à la gestion des rôles"""

    def __init__(self, bot: EtuUTTBot) -> None:
        self.bot = bot
        self.channel_service = ChannelService(bot)
        self.role_service = RoleService(bot)

    @app_commands.command(name="between")
    async def get_roles_with_framed_number_of_members(
        self, interaction: Interaction[EtuUTTBot], nb_min: int = 0, nb_max: int = 1
    ):
        """Affiche les rôles ayant plus de nb_min et moins de nb_max personnes dedans.

        Args:
            interaction:
            nb_min: Le nombre de personnes minimum ayant le rôle (par défaut : 0)
            nb_max: Le nombre de personnes maximum ayant le rôle (par défaut : 1)
        """
        await interaction.response.defer(thinking=True)
        if nb_min > nb_max:
            await interaction.followup.send("Erreur : nb_min doit être inférieur ou égal à nb_max")
            return
        roles = [r for r in interaction.guild.roles if nb_min <= len(r.members) <= nb_max]
        if len(roles) == 0:
            await interaction.followup.send(
                "\N{WHITE HEAVY CHECK MARK} Commande terminée, aucun rôle n'a été identifié."
            )
            return
        if len(roles) == 1:
            await interaction.followup.send(
                "\N{WHITE HEAVY CHECK MARK} Commande terminée, un rôle trouvé : "
                f"{roles[0].name} avec {len(roles[0].members)} membres"
            )
            return
        msg = f"\N{WHITE HEAVY CHECK MARK} Commande terminée, {len(roles)} rôles trouvés : "
        # group roles by ascending number of members
        # start by sorting the roles in order to make the operation
        # O(log(n) + n) instead of O(n²)
        grouped_roles = groupby(
            sorted(roles, key=lambda r: len(r.members)), key=lambda r: len(r.members)
        )
        for nb_members, roles_group in grouped_roles:
            msg += f"\n## Rôles avec {nb_members} membres :\n"
            msg += "\n".join(f"- {r.name}" for r in roles_group)
        chunks = list(split_msg(msg))
        for chunk in chunks[1:]:
            await interaction.channel.send(chunk)
        # send the last part of the message as a followup
        # to remove the "thinking" message
        await interaction.followup.send(chunks[0])

    # Remove all users from a role
    @app_commands.checks.bot_has_permissions(manage_roles=True)
    @app_commands.command(name="removeall")
    async def remove_all(self, interaction: Interaction[EtuUTTBot], role: discord.Role):
        """Prend toutes les personnes ayant le rôle et leur retire.

        Args:
            interaction:
            role: le rôle auquel qu'on veut retirer à tout le monde
        """
        await interaction.response.defer(thinking=True)
        for member in role.members:
            await member.remove_roles(role)
        await interaction.followup.send(
            f"\N{WHITE HEAVY CHECK MARK} Plus personne n'a le rôle {role.name}"
        )

    @app_commands.command(name="get_duplicates")
    async def get_duplicates(
        self, interaction: Interaction[EtuUTTBot], case_sensitive: bool = False
    ):
        """Affiche tous les rôles qui sont dupliqués.

        On considère que deux rôles sont dupliqués quand ils ont le même nom.

        Args:
            interaction:
            case_sensitive: La casse est-elle prise en compte dans la recherche des duplications ?
        """
        await interaction.response.defer(thinking=True)
        duplicates = self.role_service.get_duplicates(case_sensitive=case_sensitive)
        if not duplicates:
            await interaction.followup.send("Aucun rôle dupliqué \N{THUMBS UP SIGN}")
            return
        message = f"{len(duplicates)} rôles dupliqués :\n"
        message += "\n".join(
            f"- **{d[0].name}**. Nombre de duplications : {len(d)}" for d in duplicates
        )
        await interaction.followup.send(message)

    @app_commands.command(name="merge")
    @app_commands.choices()
    async def merge_roles(
        self,
        interaction: Interaction[EtuUTTBot],
        role: discord.Role,
        case_sensitive: bool = True,
        merge_strategy: MergeStrategy = MergeStrategy.Intersection,
    ):
        """Fusionne en un seul tous les rôles ayant le même nom que le rôle donné.

        Args:
            interaction:
            role: Le rôle qu'on veut fusionner avec tous ceux qui ont le même nom.
            case_sensitive: La casse est-elle prise en compte dans la recherche des duplications ?
            merge_strategy: La manière de fusionner les permissions associées aux rôles fusionnées.

                - Si `Union`, toutes les permissions sont gardées.
                - Si `Intersection`, seules les permissions communes à tous les rôles sont gardées.
                - Si `Clear`, aucune permission n'est gardée.
        """
        await interaction.response.defer(thinking=True)
        duplicates = self.role_service.get_duplicate(role, case_sensitive=case_sensitive)
        nb_duplicates = len(duplicates)
        if nb_duplicates < 2:
            await interaction.followup.send(
                "Ce rôle n'est pas dupliqué \N{THINKING FACE}\n"
                "Utilisez la commande `get_duplicates` pour voir quels rôles sont dupliqués"
            )
            return
        await self.role_service.merge(duplicates, merge_perms_strategy=merge_strategy)
        await interaction.followup.send(
            f"Commande finie. {nb_duplicates} rôles fusionnés. \N{THUMBS UP SIGN}"
        )

get_duplicates(interaction, case_sensitive=False) async

Affiche tous les rôles qui sont dupliqués.

On considère que deux rôles sont dupliqués quand ils ont le même nom.

Parameters:

Name Type Description Default
interaction Interaction[EtuUTTBot]
required
case_sensitive bool

La casse est-elle prise en compte dans la recherche des duplications ?

 False
Source code in etuutt_bot/commands/role.py 
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
@app_commands.command(name="get_duplicates")
async def get_duplicates(
    self, interaction: Interaction[EtuUTTBot], case_sensitive: bool = False
):
    """Affiche tous les rôles qui sont dupliqués.

    On considère que deux rôles sont dupliqués quand ils ont le même nom.

    Args:
        interaction:
        case_sensitive: La casse est-elle prise en compte dans la recherche des duplications ?
    """
    await interaction.response.defer(thinking=True)
    duplicates = self.role_service.get_duplicates(case_sensitive=case_sensitive)
    if not duplicates:
        await interaction.followup.send("Aucun rôle dupliqué \N{THUMBS UP SIGN}")
        return
    message = f"{len(duplicates)} rôles dupliqués :\n"
    message += "\n".join(
        f"- **{d[0].name}**. Nombre de duplications : {len(d)}" for d in duplicates
    )
    await interaction.followup.send(message)

get_roles_with_framed_number_of_members(interaction, nb_min=0, nb_max=1) async

Affiche les rôles ayant plus de nb_min et moins de nb_max personnes dedans.

Parameters:

Name Type Description Default
interaction Interaction[EtuUTTBot]
required
nb_min int

Le nombre de personnes minimum ayant le rôle (par défaut : 0)

 0
nb_max int

Le nombre de personnes maximum ayant le rôle (par défaut : 1)

 1
Source code in etuutt_bot/commands/role.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
@app_commands.command(name="between")
async def get_roles_with_framed_number_of_members(
    self, interaction: Interaction[EtuUTTBot], nb_min: int = 0, nb_max: int = 1
):
    """Affiche les rôles ayant plus de nb_min et moins de nb_max personnes dedans.

    Args:
        interaction:
        nb_min: Le nombre de personnes minimum ayant le rôle (par défaut : 0)
        nb_max: Le nombre de personnes maximum ayant le rôle (par défaut : 1)
    """
    await interaction.response.defer(thinking=True)
    if nb_min > nb_max:
        await interaction.followup.send("Erreur : nb_min doit être inférieur ou égal à nb_max")
        return
    roles = [r for r in interaction.guild.roles if nb_min <= len(r.members) <= nb_max]
    if len(roles) == 0:
        await interaction.followup.send(
            "\N{WHITE HEAVY CHECK MARK} Commande terminée, aucun rôle n'a été identifié."
        )
        return
    if len(roles) == 1:
        await interaction.followup.send(
            "\N{WHITE HEAVY CHECK MARK} Commande terminée, un rôle trouvé : "
            f"{roles[0].name} avec {len(roles[0].members)} membres"
        )
        return
    msg = f"\N{WHITE HEAVY CHECK MARK} Commande terminée, {len(roles)} rôles trouvés : "
    # group roles by ascending number of members
    # start by sorting the roles in order to make the operation
    # O(log(n) + n) instead of O(n²)
    grouped_roles = groupby(
        sorted(roles, key=lambda r: len(r.members)), key=lambda r: len(r.members)
    )
    for nb_members, roles_group in grouped_roles:
        msg += f"\n## Rôles avec {nb_members} membres :\n"
        msg += "\n".join(f"- {r.name}" for r in roles_group)
    chunks = list(split_msg(msg))
    for chunk in chunks[1:]:
        await interaction.channel.send(chunk)
    # send the last part of the message as a followup
    # to remove the "thinking" message
    await interaction.followup.send(chunks[0])

merge_roles(interaction, role, case_sensitive=True, merge_strategy=MergeStrategy.Intersection) async

Fusionne en un seul tous les rôles ayant le même nom que le rôle donné.

Parameters:

Name Type Description Default
interaction Interaction[EtuUTTBot]
required
role Role

Le rôle qu'on veut fusionner avec tous ceux qui ont le même nom.

 required
case_sensitive bool

La casse est-elle prise en compte dans la recherche des duplications ?

 True
merge_strategy MergeStrategy

La manière de fusionner les permissions associées aux rôles fusionnées.

  • Si Union, toutes les permissions sont gardées.
  • Si Intersection, seules les permissions communes à tous les rôles sont gardées.
  • Si Clear, aucune permission n'est gardée.
 Intersection
Source code in etuutt_bot/commands/role.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
@app_commands.command(name="merge")
@app_commands.choices()
async def merge_roles(
    self,
    interaction: Interaction[EtuUTTBot],
    role: discord.Role,
    case_sensitive: bool = True,
    merge_strategy: MergeStrategy = MergeStrategy.Intersection,
):
    """Fusionne en un seul tous les rôles ayant le même nom que le rôle donné.

    Args:
        interaction:
        role: Le rôle qu'on veut fusionner avec tous ceux qui ont le même nom.
        case_sensitive: La casse est-elle prise en compte dans la recherche des duplications ?
        merge_strategy: La manière de fusionner les permissions associées aux rôles fusionnées.

            - Si `Union`, toutes les permissions sont gardées.
            - Si `Intersection`, seules les permissions communes à tous les rôles sont gardées.
            - Si `Clear`, aucune permission n'est gardée.
    """
    await interaction.response.defer(thinking=True)
    duplicates = self.role_service.get_duplicate(role, case_sensitive=case_sensitive)
    nb_duplicates = len(duplicates)
    if nb_duplicates < 2:
        await interaction.followup.send(
            "Ce rôle n'est pas dupliqué \N{THINKING FACE}\n"
            "Utilisez la commande `get_duplicates` pour voir quels rôles sont dupliqués"
        )
        return
    await self.role_service.merge(duplicates, merge_perms_strategy=merge_strategy)
    await interaction.followup.send(
        f"Commande finie. {nb_duplicates} rôles fusionnés. \N{THUMBS UP SIGN}"
    )

remove_all(interaction, role) async

Prend toutes les personnes ayant le rôle et leur retire.

Parameters:

Name Type Description Default
interaction Interaction[EtuUTTBot]
required
role Role

le rôle auquel qu'on veut retirer à tout le monde

 required
Source code in etuutt_bot/commands/role.py 
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
@app_commands.checks.bot_has_permissions(manage_roles=True)
@app_commands.command(name="removeall")
async def remove_all(self, interaction: Interaction[EtuUTTBot], role: discord.Role):
    """Prend toutes les personnes ayant le rôle et leur retire.

    Args:
        interaction:
        role: le rôle auquel qu'on veut retirer à tout le monde
    """
    await interaction.response.defer(thinking=True)
    for member in role.members:
        await member.remove_roles(role)
    await interaction.followup.send(
        f"\N{WHITE HEAVY CHECK MARK} Plus personne n'a le rôle {role.name}"
    )