Documentation Officielle de Néon 

Table des Matières

1. Introduction
2. Installation et configuration
3. Commandes générales
4. Configuration avancée
5. Modération
6. Logs
7. Messages personnalisés
8. Tickets
9. Économie
10. Rôles automatisés
11. Fonctionnalités sociales
12. Minis-Jeux
13. Musique
14. Système de rapport
15. NSL Core
16. F.A.Q

1.🆕 Introduction

Bienvenue dans la documentation officielle de Néon !

Néon est un bot Discord polyvalent conçu pour simplifier et dynamiser la gestion de votre serveur. Que vous soyez un administrateur chevronné ou un utilisateur débutant, Néon vous propose une gamme complète de fonctionnalités gratuite pour automatiser vos tâches, modérer efficacement et offrir une expérience personnalisée à votre communauté.

        • Pourquoi choisir Néon ?

1. 100% Français
   Néon a été conçu par et pour une communauté francophone. L'interface, les commandes, et les interactions sont intuitives et parfaitement adaptées à un public français.
2. Gratuit & Accessible
   Aucune souscription cachée : toutes les fonctionnalités de Néon sont disponibles gratuitement. Le bot est là pour vous accompagner sans vider votre portefeuille.
3. Des Fonctionnalités Complètes 🛠️
   • Modération pour maintenir l'ordre.
   • Personnalisation des messages (arrivées, départs, annonces).
   • Système de tickets pour une gestion efficace des demandes.
   • Économie, mini-jeux et musique pour divertir votre communauté.
   • Logs détaillés pour garder un œil sur l'activité.
4. Une Touche d'Humour 😄
   Chez Néon, on croit fermement qu’un bot trop sérieux, c’est comme du beurre sans sel : fade. Vous trouverez donc dans certaines commandes et interactions une petite touche d'humour. L'objectif : simplifier sans ennuyer.

        • Pour qui est fait Néon ?

• Les administrateurs qui souhaitent organiser et sécuriser leur serveur.
• Les communautés cherchant à se divertir grâce à des systèmes interactifs (musique, mini-jeux, etc.).
• Les curieux qui veulent explorer et personnaliser leur espace avec des commandes avancées.

        • À quoi s'attendre ?

Ce guide vous expliquera étape par étape :

1. L'installation et la configuration de Néon sur votre serveur.
2. L'utilisation des différentes catégories et modules : modération, tickets, logs, annonces, etc.
3. Des astuces pratiques pour personnaliser votre bot comme un pro.

        • Prêt à commencer ? 🚀

Découvrez comment installer Néon et profitez d’une gestion fluide et intuitive pour votre serveur Discord.

2.🛠️ Installation et Configuration  

Ajouter Néon à votre serveur

1. Cliquez sur ce lien d'invitation.
2. Autorisez les permissions nécessaires.
3. Configurez le bot avec !setup.

Paramètres rapides

Pour une configuration rapide, Néon :

• Identifie automatiquement des noms basiques de salons (bienvenue, annonces, sondages).
• Crée les salons manquants et configure les paramètres par défaut.

Tapez la commande !setup et sélectionnez "Salon & Rôles" puis choisissez la "Configuration Rapide" en cliquant sur les boutons correspondants.​

Paramètres avancés

Personnalisez chaque aspect, comme :

• Langue (fr, en)
• Préfixe (!setprefix)
• Salons et rôles associés (logs, tickets, etc.)

Exemple : !channelroleconfig

3.📜 Commandes générales

• !help : Affiche un menu interactif des commandes.
• !bi : Informations générales sur Néon.
• !nuke : Supprime tous les salons et rôles du serveur.
• !restore : Restore les salons et rôles du serveur à partir d'une sauvegarde.​
• !panel : Affiche la configuration actuelle du serveur.
• !save et !backups : Sauvegarde et gestion des configurations.

4.⚙️ Configuration avancée

        • Paramètres généraux

Configurez les éléments principaux de votre serveur, comme :

• Automodération : Off, Basic, Avancé, Strict.
• Langue : fr ou en.
• Nombre de tickets : 0 pour désactiver (choix disponibles : 0, 5, 10, 20, 30, 50). 

Commandes associées :

• !setlang [fr/en]
• !setprefix [préfixe]
• !settickets [nombre]

        • Salons et rôles

Attribuez manuellement les salons et rôles :

• Bienvenue (welcomeChannelID)
• Logs généraux (commonLogsChannelID)
• Annonces (announcementChannelID)
• Tickets (ticketCategoryID, ticketRoleID)

Commande : !channelrolseconfig puis sélectionnez "Configuration Personnalisée"; vous procéderez étape par étape.

⚠️ Il est possible de mentionner les salons & rôles. Pour récupérer l'identifiant (ID) d'une catégorie, suivez notre guide ici.

        • Commandes personnalisées

5.🛡️ Modération

        • Bannissement

        • Mute & Avertissements

        • Automodération

Commandes disponibles :

• !ban : Bannit un utilisateur.
• !tempban : Bannit temporairement un utilisateur.
• !warn : Ajoute un avertissement à un utilisateur.
• !warns : Liste les avertissements d'un utilisateur.
• !mute et !tempmute : Désactive les permissions de parler d’un utilisateur.
• !unban et !unmute : Révoque un bannissement ou un mute.

⚠️ Refonte en cours pour les commandes liées aux warns.

6.📋 Logs

        •  Logs généraux

        • Logs de modération

        •  Logs de traffic

Commandes disponibles :

• !ban : Bannit un utilisateur.
• !tempban : Bannit temporairement un utilisateur.
• !warn : Ajoute un avertissement à un utilisateur.
• !warns : Liste les avertissements d'un utilisateur.
• !mute et !tempmute : Désactive les permissions de parler d’un utilisateur.
• !unban et !unmute : Révoque un bannissement ou un mute.

⚠️ Refonte en cours pour les commandes liées aux warns.

7.✍🏻 Messages personnalisés

        • Arrivée et Départ 👋

        • Annonces et Interactions 📢

        • Suggestions 💡

        • Sondages 📊

Messages personnalisables sous forme d'Embed :

• Bienvenue (!setwelcomemessage)
• Au revoir (!setgoodbyemessage)
• Annonces (!setannouncemessage)
• Sondages (!setpollmessage)
• Suggestions (!setsuggestmessage)
• Ticket (!setticketmessage)

Options disponibles dans un embed :

• Couleur
• Titre
• Description
• Miniature
• Pied de page (Footer)

⚠️ Dans le futur, des options comme l’ajout de contenu (hors de l'embed) ou d'auteurs (URL,icone et nom)  seront intégrées.

8.🎟️ Tickets

        • Gestion des Tickets

        • Paramètres Avancés

Les tickets permettent une gestion structurée des demandes utilisateurs :

• Limitation du nombre de tickets par utilisateur.
• Messages personnalisés à l'ouverture et pour l'ouverture.
• Suivi des tickets avec export possible des messages.
• Suppression différée (24h à 48h).

⚠️ Actuellement en développement.

9.💰 Économie

        • Boutique et Inventaire 🛍️

        • Système de Niveau 📈

Fonctionnalités prévues :

• Lecture depuis des plateformes comme SoundCloud.
• Création de playlists serveur ou utilisateur.

⚠️ Actuellement en développement.  Ce module sera classique mais évolutif pour intégrer des options avancées.

10.🎭 Rôles automatisés

        • Rôle Réaction 🔄

        •  Auto-Role 🚀

Fonctionnalités prévues :

• Lecture depuis des plateformes comme SoundCloud.
• Création de playlists serveur ou utilisateur.

⚠️ Actuellement en développement.  Ce module sera classique mais évolutif pour intégrer des options avancées.

11.🌐 Fonctionnalités Sociales

        •  Annonces Sociales 🎥

        • Inter-Chat 🛰️

En cours de développement :

• Notifications automatiques pour les publications sur YouTube ou Twitter (X).
• Paramètres personnalisables pour chaque réseau social.

⚠️ Actuellement en développement.

12.🎲 Minis-Jeux

        • Jeux Rapides

        • Jeux Interactifs

En cours de développement :

• Notifications automatiques pour les publications sur YouTube ou Twitter (X).
• Paramètres personnalisables pour chaque réseau social.

⚠️ Actuellement en développement.

13.🎷 Musique

        • Lecture et Playlists

En cours de développement :

• Notifications automatiques pour les publications sur YouTube ou Twitter (X).
• Paramètres personnalisables pour chaque réseau social.

⚠️ Actuellement en développement.

14.🚨 Système de Rapports

        • Rapports d’Utilisation du Bot

        • Suivi et Gestion des Bugs

En cours de développement :

• Notifications automatiques pour les publications sur YouTube ou Twitter (X).
• Paramètres personnalisables pour chaque réseau social.

⚠️ Actuellement en développement.

15.🌐 NSL Core

        • 📜 Politique de gestion NSL

Chers développeurs,

Le système NSL (Néon Spinellia LuckyScale) a pour objectif de faciliter la gestion collaborative des modules entre bots.

Afin de garantir la cohérence et la compatibilité, nous avons mis en place une liste de modules standardisés.

        • ✅ Modules standardisés

• Permettre un nommage uniforme pour les fonctions communes (ex : logs, tickets, annonces).
• Éviter les collisions et doublons.
• Garantir la compatibilité inter-bots.
• Documenter officiellement les modules disponibles.

        • 🛠️ Modules personnalisés

Vous êtes libres de développer des modules propres à votre bot, sans inscription NSL.                                                                Cependant, toute synchronisation NSL nécessite un mappage avec un module standard.

        • 🔒 Accès à la table modules

Par mesure de sécurité et pour garantir l'intégrité du système, la gestion de la table des modules standardisés est réservée aux mainteneurs NSL.

        •  ⚙️ Informations Générales

L'API applique une limite de requêtes (Rate Limit) basée sur l'authentification :

• 55 requêtes / seconde si les headers d'authentification sont valides.
• 1 requête / seconde pour le trafic non authentifié.
• En cas de dépassement (Erreur 429) :

{ "rep": { "message": "⛔ Trop de requêtes. Pour plus d'informations, nous vous invitons à lire la documentation : https://www.neon-inc.fr/documentation#table_of_content_heading_1_53.", "code": 429, "retryAfter": 60 } }

        • 📄 Les commandes liées

• /nsl-core module-list → Liste les modules standards.
• /nsl-core module-suggest → Proposition d'un module
• /nsl-core module-add → Ajout d'un module (restreint).
• /nsl-core module-remove → Suppression d’un module (restreint).

        • 🔐 Authentification

À l'exception de /ping, toutes les routes nécessitent obligatoirement ces deux headers :

• Authorization: Bearer <API_TOKEN>
• nsl-bot-id: L'ID Discord de votre bot.

Codes d'erreurs d'authentification possibles :

• 401 : ❌ Token du bot appelant manquant
• 400 : ❌ ID du bot appelant manquant
• 403 : ❌ Bot appelant non autorisé ou ❌ Action refusée

        •  📦 Structure de l'objet fields

L'objet JSON fields attendu pour les mises à jour peut contenir les clés suivantes :

• coexist : Booléen (Défaut : true).
• description : String (Maximum 500 caractères, sinon ignoré/null).
• color : String (Code Hexadécimal ex: #FF7700, sinon valeur par défaut).

        • 📡 Fonctionnement de l'API 

​

🛣️ Liste des Routes de l'API

        • 📝 Exemple d'utilisation

🔍 GET /modules/get

Récupère un ou plusieurs modules selon les query params.                                                                                                                  La réponse est un objet JSON contenant rep et data (tableau ou objet module)

const fetch = require('node-fetch'); // Si version de Node < 18
require('dotenv').config();

const token = process.env.NSL_TOKEN // Variable d'environnement dans le fichier .env: NSL_TOKEN="TOKEN_RECU_PAR_NEON"

/**
 * Récupère les modules existants sur l'API NSL en fonction des critères donnés.
 * ℹ️ Si aucun module ne correspond, le code de retour sera 404.
 * 
 * @param {Object} client - Instance du client Discord contenant l'ID du bot
 * @param {Object} queryParams - Critères de recherche
 * @param {?string} [queryParams.bot_id] - ID du bot concerné
 * @param {?string} [queryParams.server_id] - ID du serveur Discord
 * @param {?string} [queryParams.module_name] - Nom unique du module
 * @param {?boolean|string} [queryParams.coexist] - Coexistence attendue (true, false, any)
 * @param {?string} [queryParams.color] - Couleur hexadécimale
 * @param {?string} [queryParams.description] - Description exacte
 * @returns {Promise<{ data: any, code: number, message: string }>}
 */
 
async function fetchModules(client, queryParams = {}) {
  const url = new URL('http://node1.adky.net:1750/api/nsl/modules/get');
  Object.entries(queryParams).forEach(([key, value]) => {
    if (value !== undefined && value !== null) url.searchParams.append(key, value);
  });

  const response = await fetch(url.toString(), {
    method: 'GET',
    headers: {
      Authorization: `Bearer ${token}`,
      'nsl-bot-id': client.user.id
    }
  });

  const result = await response.json();
  return { data: result.data, code: result.rep.code, message: result.rep.message };
}

🆕 POST /modules/insert

Insère un nouveau module ou met à jour s’il existe (avec upsert côté API).                                                                                          La réponse confirme l’opération en JSON.

require('dotenv').config();

const token = process.env.NSL_TOKEN;

/**
 * Insère un nouveau module via l'API NSL.
 * ⚠️ Tous les champs obligatoires doivent être fournis sous peine de rejet.
 * 
 * @param {Object} client - Instance du client Discord contenant l'ID du bot
 * @param {Object} body - Données à insérer
 * @param {string} body.bot_id - ID du bot concerné - Obligatoire
 * @param {string} body.server_id - ID du serveur Discord - Obligatoire
 * @param {string} body.module_name - Nom unique du module - Obligatoire
 * @param {?boolean} [body.coexist] - Si le module peut coexister avec d'autres - TRUE par défaut
 * @param {?string} [body.description] - Description optionnelle - NULL par défaut
 * @param {?string} [body.color] - Couleur hexadécimale - '#FF7700' par défaut
 * @param {?string} [body.state] - État initial du module ('enabled' ou 'disabled')
 * @returns {Promise<{ data: any, code: number, message: string }>}
 */
 
async function insertModule(client, body) {
  const response = await fetch('http://node1.adky.net:1750/api/nsl/modules/insert', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${token}`,
      'nsl-bot-id': client.user.id,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(body)
  });

  if (!response.ok) return console.error('❌ Erreur POST : ', response.status);
  const result = await response.json();
  return { data: result.data, code: result.rep.code, message: result.rep.message };
}

✏️ PATCH /modules/update

Met à jour un module existant.                                                                                                                                                                  Réponse JSON confirmant la mise à jour.

require('dotenv').config();

const token = process.env.NSL_TOKEN;

/**
 * Met à jour un module existant via l'API NSL.
 * ⚠️ Le module doit exister au préalable.
 * 
 * @param {Object} client - Instance du client Discord contenant l'ID du bot
 * @param {Object} body - Données à mettre à jour
 * @param {string} body.bot_id - ID du bot concerné - Obligatoire
 * @param {string} body.server_id - ID du serveur Discord - Obligatoire
 * @param {string} body.module_name - Nom unique du module - Obligatoire
 * @param {Object} body.fields - Champs à mettre à jour (exemple : coexist, description, color, state)
 * @returns {Promise<{ data: any, code: number, message: string }>}
 */
 
async function updateModule(client, body) {
  const response = await fetch('http://node1.adky.net:1750/api/nsl/modules/update', {
    method: 'PATCH',
    headers: {
      Authorization: `Bearer ${token}`,
      'nsl-bot-id': client.user.id,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(body)
  });

  if (!response.ok) return console.error('❌ Erreur PATCH : ', response.status);
  const result = await response.json();
  return { data: result.data, code: result.rep.code, message: result.rep.message };
}

🔄 EXEMPLE - Changer l'état d'un module

require('dotenv').config();

const token = process.env.NSL_TOKEN;

/**
 * Vérifie si un module est standardisé côté NSL.
 * 
 * @param {Object} client - Instance du client Discord contenant l'ID du bot
 * @param {string} module_name - Nom unique du module à vérifier - Obligatoire
 * @returns {Promise} - TRUE si le module est standardisé, sinon FALSE
 */
 
 async function isStandardized(client, module_name) {
  const url = new URL('http://node1.adky.net:1750/api/nsl/modules/is-standardized');
  url.searchParams.set('module_name', module_name);

  const response = await fetch(url.toString(), {
    method: 'GET',
    headers: {
      Authorization: `Bearer ${token}`,
      'nsl-bot-id': client.user.id
    }
  });

  if (!response.ok) {
    console.error(`❌ Erreur vérification standardisation (${response.status})`);
    return false;
  }

  const result = await response.json();
  return result?.rep?.code === 200 && result?.data?.isStandard === true;
}
 
/**
 * Insère ou met à jour un module sur l'API NSL.
 * Si le module existe, il est mis à jour ; sinon, il est inséré.
 * ⚠️ Vérifie d'abord si le module est standardisé avant toute opération.
 * 
 * @param {Object} client - Instance du client Discord contenant l'ID du bot
 * @param {string} bot_id - ID du bot concerné - Obligatoire
 * @param {string} server_id - ID du serveur Discord - Obligatoire
 * @param {string} module_name - Nom unique du module - Obligatoire
 * @param {Object} updateFields - Champs à modifier/ajouter
 * @param {?string} [updateFields.state] - État du module ('enabled' ou 'disabled') - 'disabled' par défaut
 * @param {?string} [updateFields.description] - Description optionnelle du module - NULL par défaut
 * @param {?string} [updateFields.color] - Couleur hexadécimale - '#FF7700' par défaut
 * @param {?boolean} [updateFields.coexist] - Si le module peut coexister - TRUE par défaut
 * @returns {Promise}
 */
 
async function upsertModule(client, bot_id, server_id, module_name, updateFields) {
  try {
    // Vérif standardisation
    const isValid = await isStandardized(client, module_name);
    if (!isValid) {
      console.error(`⛔ Le module "${module_name}" n'est pas standardisé. Opération annulée.`);
      return;
    }

    // Recherche existant
    const { data, code, message } = await fetchModules(client, {
      bot_id,
      server_id,
      module_name
    });

    if (code === 200 && data && data.length > 0) {
      console.log(`Module trouvé : mise à jour avec`, updateFields);
      const updateResult = await updateModule(client, {
        bot_id,
        server_id,
        module_name,
        fields: updateFields
      });
      if (updateResult.code === 200) console.log(`[PATCH] OK : ${updateResult.message}`);
      else console.warn(`[PATCH] Échec : ${updateResult.message}`);
    } else if (code === 404 || !data || data.length === 0) {
      console.log(`Module non trouvé : insertion avec`, updateFields);
      const insertResult = await insertModule(client, {
        bot_id,
        server_id,
        module_name,
        coexist: updateFields.coexist ?? true,
        description: updateFields.description ?? null,
        color: updateFields.color ?? '#FF7700',
        state: updateFields.state ?? 'disabled'
      });
      if (insertResult.code === 200) console.log(`[POST] OK : ${insertResult.message}`);
      else console.warn(`[POST] Échec : ${insertResult.message}`);
    } else {
      console.error(`Erreur inattendue lors de la récupération : ${message}`);
    }
  } catch (err) {
    console.error(`❌ Erreur upsert : ${err.message}`);
  }
}

// --- Import de la fonction upsertModule ---
// (Assurez-vous qu'elles sont définies ici ou importées depuis un module)

const { upsertModule } = require('./nsl-helper'); // Importation du helper NSL

/**
 * Exemple d'appel à upsertModule pour changer l'état d'un module
 */
(async () => {
  const bot_id = '651668824197693451'; // ID du bot NSL
  const server_id = '1186029077749059704'; // ID du serveur Discord
  const module_name = 'logs'; // Nom du module concerné

  const updateFields = {
    state: 'enabled' // ⚙️ Changement d'état souhaité (enabled | disabled)
  };

  await upsertModule(client, bot_id, server_id, module_name, updateFields);
})();

        •  🔌 Connexion WebSocket

L'architecture NSL repose sur un système centralisé. Actuellement, une communication directe (P2P) entre deux bots n'est pas possible. L'API NSL agit comme un routeur central (Middleman) : elle reçoit les requêtes HTTP, les traite, puis utilise ce tunnel WebSocket pour distribuer les ordres aux bots concernés en temps réel.

⚠️ Règle de sécurité stricte : Une seule connexion WebSocket simultanée est autorisée par bot. Toute tentative de connexion multiple entraînera la fermeture du tunnel.

​ ​1. Authentification et Connexion

Pour ouvrir le tunnel d'écoute, votre bot doit se connecter à l'URL suivante en fournissant les en-têtes d'authentification requis.

• Endpoint : wss://api.neon-inc.fr/ws/nsl

​

​ ​2. Maintien de la connexion (Heartbeat)

Afin d'éviter les déconnexions silencieuses (timeouts réseau), le serveur NSL vous enverra automatiquement un signal ping toutes les 45 secondes.

Si vous utilisez une librairie standard (comme ws sous Node.js), vous n'avez rien à faire : votre client répondra automatiquement avec un pong pour maintenir le tunnel ouvert.

​ ​3. Structure des données entrantes

Lorsque le routeur NSL vous transmet un ordre, vous recevrez un message au format JSON. Voici sa structure standard :

{
  "action": "ACTION_NAME",
  "module_name": "nom_du_module",​
  "server_id": "123456789012345678",
  "reqId": "id_unique_de_la_requete"​
}

(Note : le reqId correspond à l'ID unique de la requête).

​ ​4. L'accusé de réception (ACK)

C'est l'étape la plus importante. Dès que votre bot a fini de traiter un message reçu via le WebSocket, il doit obligatoirement renvoyer un accusé de réception (ACK) au serveur NSL.

Cela permet à l'API de clôturer la requête en attente et de confirmer le succès de l'opération au bot émetteur.

{
  "action": "ACK",
  "reqId": "id_unique_de_la_requete",
  "success": true
}

• 🤝 Adhésion au projet NSL

Pour rejoindre le programme, utiliser la commande /register.

Si vous avez des questions ou suggestions, merci de nous contacter directement.

- L'équipe NSL 

❓ FAQ et Assistance

Questions fréquentes :

• Comment ajouter Néon à mon serveur ?
  Consultez la section Installation et Configuration.
• Pourquoi une commande ne fonctionne-t-elle pas ?
  Vérifiez les permissions ou utilisez !help.
• Comment obtenir de l’aide ?
  Rejoignez notre serveur Discord de support. Vous pouvez également consulter notre F.A.Q ou notre Forum