clone everything

src/discord.rs

@@ -10,6 +10,18 @@ mod erreur {
     include!("erreur.rs");
 }
 
+mod mattermost {
+    include!("mattermost.rs");
+}
+
+/// Identifiants pour Mattermost, récupérer une fois dans `main.rs`
+pub struct IdentifiantsMattermost {
+    pub token: String,
+    pub user: String,
+    pub pass: String,
+    pub url: String,
+}
+
 /// Permet de stocker les informations nécessaire pour utiliser le bot discord
 pub struct ConnectionInfoDiscord {
     pub token: String,
@@ -20,8 +32,11 @@ pub struct ConnectionInfoDiscord {
 
 /// Structure qui stocke les informations dont le bot a besoin pour communiquer avec Mattermost
 struct InformationsBot {
+    token: String,
+    user: String,
+    pass: String,
+    url: String,
     prefix: Option<String>,
-    api: Option<mattermost_api::client::Mattermost>,
     salon: Option<String>,
 }
 
@@ -31,59 +46,54 @@ struct InformationsBot {
 ///
 /// On fait quand même le match pour être sûr.
 impl InformationsBot {
-    const err: String = String::from("Erreur lors de la récupération des informations\nTips: start_discord n'a peut-être pas été appelée...");
+    fn err() -> String {
-
+        String::from("Erreur lors de la récupération des informations\nTips: start_discord n'a peut-être pas été appelée...")
-    /// Créer une structure vide
-    pub fn nouveau_vide() -> Self {
-        Self {
-            prefix: None,
-            api: None,
-            salon: None,
-        }
     }
 
-    /// Créer une structure personnalisée.
+    /// Créer une structure
     pub fn nouveau(
+        identifiants: IdentifiantsMattermost,
         prefix: String,
-        api: mattermost_api::client::Mattermost,
         salon: String,
     ) -> Option<Self> {
         Some(Self {
+            token: identifiants.token,
+            user: identifiants.user,
+            pass: identifiants.pass,
+            url: identifiants.url,
             prefix: Some(prefix),
-            api: Some(api),
             salon: Some(salon),
         })
     }
 
     /// Récupère préfix, sinon panique
-    pub fn recuperation_prefix(self) -> String {
+    pub fn recuperation_prefix(&self) -> String {
-        match self.prefix {
+        match &self.prefix {
-            Some(prefix) => prefix,
+            Some(prefix) => prefix.clone(),
             None => panic!(
                 "{}",
-                erreur::message_erreur(&format!("[Recup-Prefix] {}", Self::err))
+                erreur::message_erreur(&format!("[Recup-Prefix] {}", Self::err()))
             ),
         }
     }
 
     /// Récupère API, sinon panique
-    pub fn recuperation_API(self) -> mattermost_api::client::Mattermost {
+    ///
-        match self.api {
+    /// Question importante, je créer l'API dans `main.rs`, alors pourquoi je
-            Some(api) => api,
+    /// n'ai pas utilisé cette api pour ce fichier ? Tout simplement parce que
-            None => panic!(
+    /// `mattermost_api::client::Mattermost` n'implémente pas le trait de Clone
-                "{}",
+    /// impossible donc (pas de succès avec Mutex)...
-                erreur::message_erreur(&format!("[Recup-API] {}", Self::err))
+    pub async fn recuperation_api(&self) -> mattermost_api::client::Mattermost {
-            ),
+        mattermost::connexion(&self.token, &self.user, &self.pass, &self.url).await
-        }
     }
 
     /// Récupère le salon, sinon panique
-    pub fn recuperation_salon(self) -> String {
+    pub fn recuperation_salon(&self) -> String {
-        match self.salon {
+        match &self.salon {
-            Some(salon) => salon,
+            Some(salon) => salon.clone(),
             None => panic!(
                 "{}",
-                erreur::message_erreur(&format!("[Recup-Salon] {}", Self::err))
+                erreur::message_erreur(&format!("[Recup-Salon] {}", Self::err()))
             ),
         }
     }
@@ -104,7 +114,7 @@ unsafe fn recuperation_info() -> &'static InformationsBot {
         Some(info) => info,
         None => panic!(
             "{}",
-            erreur::message_erreur(&format!("[Recup-InfosBot] {}", InformationsBot::err))
+            erreur::message_erreur(&format!("[Recup-InfosBot] {}", InformationsBot::err()))
         ),
     }
 }
@@ -115,8 +125,7 @@ struct Handler;
 impl EventHandler for Handler {
     //  Appellé quand un message est récupérer par le bot
     async fn message(&self, ctx: Context, msg: Message) {
-        #[allow(unused_assignments)]
+        let infos: &InformationsBot;
-        let mut infos = &InformationsBot::nouveau_vide();
         unsafe {
             infos = recuperation_info();
         }
@@ -146,10 +155,13 @@ impl EventHandler for Handler {
 }
 
 /// Lance le bot Discord
-pub async fn start_discord(informations: ConnectionInfoDiscord) {
+pub async fn start_discord(
+    informations: ConnectionInfoDiscord,
+    identifiants: IdentifiantsMattermost,
+) {
     unsafe {
         // On enregistre tout de suite nos informations
-        _INFO = InformationsBot::nouveau(informations.prefix, informations.api, informations.salon);
+        _INFO = InformationsBot::nouveau(identifiants, informations.prefix, informations.salon);
     }
 
     // Client Discord (https://docs.rs/serenity/latest/serenity/client/index.html)
@@ -172,18 +184,25 @@ pub async fn start_discord(informations: ConnectionInfoDiscord) {
 
 /// Ne peut pas être async (limitation de serde_json)
 fn recuperation_salon() -> String {
+    let infos: &InformationsBot;
+    unsafe {
+        infos = recuperation_info();
+    }
+
+    infos.recuperation_salon();
+
     String::from("temp")
 }
 
 /// Envoie un message sur Mattermost
 async fn envoie_msg_mattermost(msg: Message) {
-    #[allow(unused_assignments)]
+    let infos: &InformationsBot;
-    let mut infos = &InformationsBot::nouveau_vide();
     unsafe {
         infos = recuperation_info();
     }
     let res = infos
-        .recuperation_API()
+        .recuperation_api()
+        .await
         .query::<String>(
             "POST",
             "post",