adds to gh orgs pipeline + fix error when bot is already in server bu…

…t not registered in db + default welcome message

cogs/__init__.py

@@ -14,7 +14,7 @@ def create_slash_cmds(trema_bot, trema_db, start_time, github_token):
 	config = _create_config_cmds(trema_db)
 	webhook = _create_webhooks_cmds(trema_db)
 	request = _create_requests_cmds(trema_db, github_token)
-	member 	= _create_member_cmds(trema_db)
+	member 	= _create_member_cmds(trema_db, github_token)
 
 	trema_bot.add_application_command(config)
 	trema_bot.add_application_command(webhook)

cogs/events.py

@@ -9,6 +9,10 @@
 
 from logger import logger
 
+DEFAULT_WELCOME_MSG_TEMPLATE = "Hey {newMember}! Bienvenue au {server}.\n" + \
+    "Pour accéder au reste du serveur et interagir avec le bot, " + \
+    "utilise la commande `/request join` !"
+
 def _get_welcome_chan(guild, trema_db):
 	guild_id = guild.id
 	welcome_chan_id = trema_db.get_server_welcome_chan_id(guild_id)
@@ -24,21 +28,45 @@ async def on_guild_join(guild):
 	async def on_member_join(member):
 		guild = member.guild
 		guild_id = guild.id
-		welcome_chan = _get_welcome_chan(guild, trema_db)
-
-		welcome_msg = trema_db.get_server_welcome_msg(guild_id)
-		welcome_msg = make_mention(welcome_msg, generate_mention_dict(guild, member))
-		await welcome_chan.send(welcome_msg)
-
-		# A reminder if the new member does not select a role
-		reminder_msg = trema_db.get_server_reminder_msg(guild_id)
-		if not member.bot and reminder_msg is not None:
-			reminder_msg = make_mention(reminder_msg, generate_mention_dict(guild, member))
-			reminder_delay = trema_db.get_server_reminder_delay(guild_id)
-			msg_condition = lambda: member_roles_are_default(member)
-			reminder_task = asyncio.create_task(send_delayed_dm(
-				member, reminder_msg, reminder_delay, msg_condition))
-			await asyncio.wait([reminder_task])
+
+		try:
+			welcome_chan = _get_welcome_chan(guild, trema_db)
+			if welcome_chan is None:
+				raise Exception("Welcome channel not found.")
+		except Exception as e:
+			logger.error(f"Error fetching welcome channel: {e}")
+			welcome_chan = guild.system_channel
+
+		try:
+			welcome_msg = trema_db.get_server_welcome_msg(guild_id)
+			if welcome_msg is None:
+				welcome_msg = DEFAULT_WELCOME_MSG_TEMPLATE.format(
+					newMember=member.display_name,
+					server=guild.name
+				)
+			else:
+				welcome_msg = make_mention(welcome_msg, generate_mention_dict(guild, member))
+		except Exception as e:
+			logger.error(f"Error fetching welcome message: {e}")
+			welcome_msg = DEFAULT_WELCOME_MSG_TEMPLATE.format(
+				newMember=member.display_name,
+				server=guild.name
+			)
+
+		if welcome_chan:
+			await welcome_chan.send(welcome_msg)
+
+		try:
+			reminder_msg = trema_db.get_server_reminder_msg(guild_id)
+			if not member.bot and reminder_msg is not None:
+				reminder_msg = make_mention(reminder_msg, generate_mention_dict(guild, member))
+				reminder_delay = trema_db.get_server_reminder_delay(guild_id)
+				msg_condition = lambda: member_roles_are_default(member)
+				reminder_task = asyncio.create_task(send_delayed_dm(
+					member, reminder_msg, reminder_delay, msg_condition))
+				await asyncio.wait([reminder_task])
+		except Exception as e:
+			logger.error(f"Error fetching reminder message: {e}")
 
 	@trema_bot.event
 	async def on_member_remove(member):
@@ -53,4 +81,11 @@ async def on_member_remove(member):
 
 	@trema_bot.event
 	async def on_ready():
-		logger.info('{0.user} fonctionne.'.format(trema_bot))
+		logger.info('{0.user} fonctionne.'.format(trema_bot))
+
+		for guild in trema_bot.guilds:
+			if not trema_db._id_exists(guild.id, "server"):
+				logger.info(f"Server {guild.name} (ID: {guild.id}) not found in the database. Registering...")
+				trema_db.register_server(guild)
+			else:
+				logger.info(f"Server {guild.name} (ID: {guild.id}) is already registered.")

cogs/members/__init__.py

@@ -8,10 +8,12 @@
 	File,\
 	SelectOption
 from discord.ui import Select, View
-
 from cogs.admin import is_authorized
+from cogs.prompts import prompt_user_with_select, prompt_user_with_confirmation, prompt_user
+from logger import logger
+from cogs.utils.dispatch import dispatch_add_member_to_gh_org_gw
 
-def _create_member_cmds(trema_db):
+def _create_member_cmds(trema_db, github_token):
 	member = SlashCommandGroup(name="member", description="Gérer les membres du serveur.")
 
 	@member.command(name="list", description="Lister les membres du serveur.")
@@ -27,7 +29,7 @@ async def list_members(ctx, status: Option(str, "Statut des membres à afficher"
 			for idx, member in enumerate(members, start=1):
 				embed.add_field(
 					name=f"#{idx}: {member['username']}",
-					value=f"ID: {member['_id']}, Statut: {member['status']}, Requête: {member.get('request_time', 'N/A')}",
+					value=f"ID: {member['_id']}\nStatut: {member['status']}\nRequête: {member.get('request_time', 'N/A')}\nGitHub: {member.get('github_username', 'N/A')}",
 					inline=False
 				)
 			await ctx.respond(embed=embed, ephemeral=True)
@@ -95,9 +97,15 @@ async def status_select_callback(interaction):
 							else:
 								await interaction.response.send_message("Impossible de trouver le rôle des membres configuré.", ephemeral=True)
 						except Exception as e:
-							print(f"Exception: {e}")
+							logger.error(f"Exception: {e}")
 							await interaction.response.send_message("Impossible d'ajouter le rôle des membres.", ephemeral=True)
 
+						try:
+							await add_member_to_gh_org_gw(ctx, selected_member, github_token)
+						except Exception as e:
+							logger.error(f"Exception: {e}")
+							await interaction.response.send_message("Impossible d'ajouter le membre à l'organisation GitHub.", ephemeral=True)
+
 			status_select.callback = status_select_callback
 			status_view = View()
 			status_view.add_item(status_select)
@@ -185,7 +193,39 @@ async def add_member(ctx, user_id: Option(str, "ID de l'utilisateur à ajouter")
 				else:
 					await ctx.respond("Impossible de trouver le rôle des membres configuré.", ephemeral=True)
 			except Exception as e:
-				print(f"Exception: {e}")
+				logger.error(f"Exception: {e}")
 				await ctx.respond("Impossible d'ajouter le rôle des membres.", ephemeral=True)
 
-	return member
+			try:
+				selected_member = trema_db.get_member(server_id, user_id_int)
+				await add_member_to_gh_org_gw(ctx, selected_member, github_token)
+			except Exception as e:
+				logger.error(f"Exception: {e}")
+				await ctx.respond("Impossible d'ajouter le membre à l'organisation GitHub.", ephemeral=True)
+
+	return member
+
+
+async def add_member_to_gh_org_gw(ctx, member, github_token):
+	add_to_gh_org = await prompt_user_with_confirmation(ctx, f"Ajouter {member['username']} à l'organisation GitHub ?")
+
+	if add_to_gh_org:
+		github_username = member.get("github_username")
+		if not github_username:
+			github_username = await prompt_user(ctx, "Entrez le nom d'utilisateur GitHub du membre", "Nom d'utilisateur GitHub")
+			if not github_username:
+				return
+		github_email = member.get("github_email")
+		if not github_email:
+			github_email = await prompt_user(ctx, "Entrez l'adresse e-mail associée à GitHub du membre", "E-mail GitHub")
+			if not github_email:
+				return
+		team_sre = await prompt_user_with_select(ctx, "Ajouter dans l'équipe SRE ?", ["vrai", "faux"], True)
+		cluster_role = await prompt_user_with_select(ctx, "Choisir le rôle pour le cluster", ["None", "Reader", "Operator", "Admin"], True)
+
+		success, message = await dispatch_add_member_to_gh_org_gw(github_username, github_email, github_token, team_sre, cluster_role)
+
+		if success:
+			await ctx.author.send(f"Le membre {member['username']} a été ajouté à l'organisation GitHub avec succès.\n{message}")
+		else:
+			await ctx.author.send(f"Impossible d'ajouter le membre {member['username']} à l'organisation GitHub.\n{message}")

cogs/prompts.py

@@ -159,14 +159,14 @@ def interaction_check(interaction: Interaction):
             await ctx.author.send('Temps écoulé. Opération annulée.')
             return None, None
 
-async def prompt_user_with_select(ctx, description, role_options):
+async def prompt_user_with_select(ctx, description, options, use_dm=False):
     embed = Embed(
         title="Sélection de rôle",
         description=description,
         color=Color.blue()
     )
 
-    options = [SelectOption(label=role, value=role.lower()) for role in role_options]
+    options = [SelectOption(label=option, value=option) for option in options]
 
     select = Select(
         placeholder="Choisissez votre rôle",
@@ -184,11 +184,33 @@ async def select_callback(interaction):
     view = View()
     view.add_item(select)
 
-    await ctx.respond(embed=embed, view=view, ephemeral=True)
+    if use_dm:
+        dm_channel = ctx.author.dm_channel
+        if dm_channel is None:
+            dm_channel = await ctx.author.create_dm()
 
-    try:
-        interaction = await ctx.bot.wait_for("interaction", check=lambda i: i.user.id == ctx.author.id, timeout=120)
-        return select.values[0]
-    except asyncio.TimeoutError:
-        await ctx.author.send('Temps écoulé. Opération annulée.')
-        return None
+        await dm_channel.send(embed=embed, view=view)
+
+        try:
+            interaction = await ctx.bot.wait_for(
+                "interaction",
+                check=lambda i: i.user.id == ctx.author.id and i.channel.id == dm_channel.id,
+                timeout=120
+            )
+            return select.values[0]
+        except asyncio.TimeoutError:
+            await ctx.author.send('Temps écoulé. Opération annulée.')
+            return None
+    else:
+        await ctx.respond(embed=embed, view=view, ephemeral=True)
+
+        try:
+            interaction = await ctx.bot.wait_for(
+                "interaction",
+                check=lambda i: i.user.id == ctx.author.id,
+                timeout=120
+            )
+            return select.values[0]
+        except asyncio.TimeoutError:
+            await ctx.author.send('Temps écoulé. Opération annulée.')
+            return None

cogs/requests/__init__.py

@@ -1,6 +1,5 @@
 from discord import Embed, Color, SlashCommandGroup, Option
 from cogs.admin import is_authorized
-from cogs.utils.dispatch import dispatch_github_workflow, post_to_calidum
 from cogs.requests.join import _create_member_requests_cmds
 from cogs.requests.grav import _create_grav_requests_cmds
 

cogs/requests/grav.py

@@ -1,6 +1,6 @@
 from discord import Embed, Color, Option, SlashCommandGroup
 from cogs.admin import is_authorized
-from cogs.utils.dispatch import post_to_calidum, dispatch_github_workflow
+from cogs.utils.dispatch import post_to_calidum, dispatch_grav_gw
 def _create_grav_requests_cmds(trema_db, request, github_token):
     @request.command(name="grav",
         description="Créer une requête pour un site web GRAV")
@@ -12,7 +12,7 @@ async def request_grav_workflow(ctx,
 
         await ctx.defer(ephemeral=True)
 
-        success, message = dispatch_github_workflow(domaine, nom_club, contexte, github_token)
+        success, message = await dispatch_grav_gw(domaine, nom_club, contexte, github_token)
 
         if success:
             request_data = {
@@ -25,7 +25,7 @@ async def request_grav_workflow(ctx,
 
             calidum_enabled = trema_db.get_server_calidum_enabled(ctx.guild_id)
             if calidum_enabled:
-                post_to_calidum(ctx.author.name, "Requête création site web Grav", f"Domaine: {domaine}, Nom du club: {nom_club}, Contexte: {contexte}")
+                await post_to_calidum(ctx.author.name, "Requête création site web Grav", f"Domaine: {domaine}, Nom du club: {nom_club}, Contexte: {contexte}")
 
             embed = Embed(title="Requête de service", description=f"La requête pour '{nom_club}' a été initiée avec succès.\n{message}", color=Color.green())
         else:

cogs/requests/join.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from discord import Embed, Color
 from cogs.utils.dispatch import post_to_calidum
-from cogs.prompts import prompt_user_with_select
+from cogs.prompts import prompt_user_with_select, prompt_user
 from cogs.utils.discord import find_role_in_guild
 from logger import logger
 
@@ -35,25 +35,36 @@ async def request_server_access(ctx):
         member_role = trema_db.get_server_member_role(server_id)
 
         if role.id == member_role:
+
+            await ctx.respond("Pour devenir membre, veuillez fournir votre nom d'utilisateur GitHub et votre adresse e-mail. Vérifier vos messages privés pour plus d'informations.", ephemeral=True)
+            github_username = await prompt_user(ctx, "Veuillez entrer votre nom d'utilisateur GitHub", "Nom d'utilisateur GitHub pour devenir membre")
+            if not github_username:
+                return
+            github_email = await prompt_user(ctx, "Veillez entrer votre adresse e-mail associée à GitHub", "Adresse e-mail GitHub pour devenir membre")
+            if not github_email:
+                return
+
             member_data = {
                 "user_id": requester_id,
                 "username": username,
                 "status": "pending",
-                "request_time": str(datetime.now())
+                "request_time": str(datetime.now()),
+                "github_username": github_username,
+                "github_email": github_email
             }
             trema_db.add_member(server_id, member_data)
 
             calidum_enabled = trema_db.get_server_calidum_enabled(ctx.guild.id)
             if calidum_enabled:
-                post_to_calidum(username, "Membre du serveur", f"Demande d'ajout comme membre pour {username} avec statut 'pending'.")
+                await post_to_calidum(username, "Membre du serveur", f"Demande d'ajout comme membre pour {username} avec statut 'pending'.")
 
             # Send confirmation message to the user
             embed = Embed(
                 title="Demande de membre envoyée",
                 description=f"Votre demande pour devenir membre est en attente d'approbation.",
                 color=Color.green()
             )
-            await ctx.respond(embed=embed, ephemeral=True)
+            await ctx.author.send(embed=embed)
         elif role:
             await ctx.author.add_roles(role)
             await ctx.author.send(f"Vous avez été assigné au rôle de {role_name.capitalize()}.")