Merge pull request #32 from adator85/dev

Update vote kick commands

.gitignore

@@ -3,5 +3,5 @@ db/
 logs/
 __pycache__/
 configuration.json
-*.log
+install.log
 test.py

README.md

@@ -1,9 +1,4 @@
 # IRC-DEFENDER
-![Static Badge](https://img.shields.io/badge/UnrealIRCd-6.2.2%20or%20later-green)
-![Static Badge](https://img.shields.io/badge/Python3-3.10%20or%20later-green)
-![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fadator85%2FIRC_DEFENDER_MODULES%2Fmain%2Fversion.json&query=version&label=Current%20Version)
-![Static Badge](https://img.shields.io/badge/Maintained-Yes-green)
-
 Defender est un service IRC basé sur la sécurité des réseaux IRC ( UnrealIRCD )
 Il permet d'ajouter une sécurité supplémentaire pour vérifier les users connectés au réseau
 en demandant aux user un code de validation.
@@ -14,9 +9,9 @@ Il permet aux opérateurs de gérer efficacement un canal, tout en offrant aux u
         Kick: Expulser un utilisateur du canal.
         Ban: Interdire définitivement l'accès au canal.
         Unban: Lever une interdiction.
-        Op/Deop/Opall/Deopall: Attribuer ou retirer les droits d'opérateur.
+        Op/Deop: Attribuer ou retirer les droits d'opérateur.
         Halfop/Dehalfop: Attribuer ou retirer les droits
-        Voice/Devoice/VoiceAll/DevoiceAll: Attribuer ou retirer les droits de voix.
+        Voice/Devoice: Attribuer ou retirer les droits de voix.
 
     Système de quarantaine:
         Mise en quarantaine: Isoler temporairement un utilisateur dans un canal privé.
@@ -30,207 +25,80 @@ Il permet aux opérateurs de gérer efficacement un canal, tout en offrant aux u
 
     Prérequis:
         - Système d'exploitation Linux (Windows non supporté)
-        - Un server UnrealIRCD corréctement configuré
         - Python version 3.10 ou supérieure
-```bash
-        # Bash
+
+    Bash:
         $ git clone https://github.com/adator85/IRC_DEFENDER_MODULES.git
-        # Renommer le fichier exemple_configuration.json en configuration.json
-        # Configurer le fichier configuration.json
+        - Renommer le fichier exemple_configuration.json en configuration.json
+        - Configurer le fichier configuration.json
         $ python3 main.py
-```
+
 Si votre configuration est bonne, votre service est censé etre connecté a votre réseau IRC
 Pour Les prochains lancement de defender vous devez utiliser la commande suivante:
 
-```bash
-    # Bash
+    Bash:
         $ systemctl --user [start | stop | restart | status] defender
-```
+
 # Installation manuelle:
-```bash
-    # Bash
+    Bash:
         $ git clone https://github.com/adator85/IRC_DEFENDER_MODULES.git
         $ cd IRC_DEFENDER_MODULES
         $ python3 -m venv .pyenv
         $ source .pyenv/bin/activate
-    (pyenv)$ pip install sqlalchemy, psutil, requests, faker, unrealircd_rpc_py
-
-    # Créer un service nommé "defender.service" 
-    # pour votre service et placer le dans "/PATH/TO/USER/.config/systemd/user/"
-    # Si le dossier n'existe pas il faut les créer
+        (pyenv)$ pip install sqlalchemy, psutil, requests, faker
+        - Créer un service nommé "defender.service" pour votre service et placer le dans "/PATH/TO/USER/.config/systemd/user/"
+        - Si le dossier n'existe pas il faut les créer
         $ sudo systemctl --user start defender
-```
+
 # Configuration
-```
+
     SERVEUR (Serveur)
-        * SERVEUR_IP: Adresse IP du serveur IRC à rejoindre. (default : 127.0.0.1)
-        * SERVEUR_HOSTNAME: Nom d'hôte du serveur IRC à rejoindre (optionnel).
-        * SERVEUR_LINK: Lien vers le serveur IRC (optionnel).
-        * SERVEUR_PORT: Port de connexion au serveur IRC.
-        * SERVEUR_PASSWORD: Mot de passe d'enregistrement du service sur le serveur IRC.
-        SERVEUR_ID: Identifiant unique du service. (default : 19Z)
-        SERVEUR_SSL: Active la connexion SSL sécurisée au serveur IRC (true/false) (default : false).
-
+        SERVEUR_IP: Adresse IP du serveur IRC à rejoindre.
+        SERVEUR_HOSTNAME: Nom d'hôte du serveur IRC à rejoindre (optionnel).
+        SERVEUR_LINK: Lien vers le serveur IRC (optionnel).
+        SERVEUR_PORT: Port de connexion au serveur IRC.
+        SERVEUR_PASSWORD: Mot de passe d'enregistrement du service sur le serveur IRC.
+        SERVEUR_ID: Identifiant unique du service.
+        SERVEUR_SSL: Active la connexion SSL sécurisée au serveur IRC (true/false).
     SERVICE (Service)
-        SERVICE_NAME: Nom du service IRC. (default : Defender)
-        SERVICE_NICKNAME: Surnom utilisé par le service sur le serveur IRC. (default : Defender)
-        SERVICE_REALNAME: Nom réel du service affiché sur le serveur IRC. (default : Defender Security)
-        SERVICE_USERNAME: Nom d'utilisateur utilisé par le service pour se connecter au serveur IRC. (default : IRCSecurity)
-        SERVICE_HOST: Nom d'hôte du service affiché sur le serveur IRC (optionnel). (default : defender.local.network)
-        SERVICE_INFO: Description du service. (default : Defender Network IRC Service)
-        SERVICE_CHANLOG: Canal utilisé pour la journalisation des actions du service. (default : #services)
-        SERVICE_SMODES: Modes serveur appliqués aux canaux rejoints par le service. (default : +ioqBS)
-        SERVICE_CMODES: Modes de canal appliqués aux canaux rejoints par le service. (default : ntsOP)
-        SERVICE_UMODES: Modes utilisateur appliqués au service. (default : o)
-        SERVICE_PREFIX: Caractère utilisé comme préfixe des commandes du service. (default : !)
-
+        SERVICE_NAME: Nom du service IRC.
+        SERVICE_NICKNAME: Surnom utilisé par le service sur le serveur IRC.
+        SERVICE_REALNAME: Nom réel du service affiché sur le serveur IRC.
+        SERVICE_USERNAME: Nom d'utilisateur utilisé par le service pour se connecter au serveur IRC.
+        SERVICE_HOST: Nom d'hôte du service affiché sur le serveur IRC (optionnel).
+        SERVICE_INFO: Description du service.
+        SERVICE_CHANLOG: Canal utilisé pour la journalisation des actions du service.
+        SERVICE_SMODES: Modes serveur appliqués aux canaux rejoints par le service.
+        SERVICE_CMODES: Modes de canal appliqués aux canaux rejoints par le service.
+        SERVICE_UMODES: Modes utilisateur appliqués au service.
+        SERVICE_PREFIX: Caractère utilisé comme préfixe des commandes du service.
     COMPTE (Compte)
-        OWNER: Nom d'utilisateur possédant les droits d'administration du service. (default : admin)
-        PASSWORD: Mot de passe de l'administrateur du service. (default : admin)
-
+        OWNER: Nom d'utilisateur possédant les droits d'administration du service.
+        PASSWORD: Mot de passe de l'administrateur du service.
     CANAUX (Canaux)
-        SALON_JAIL: Canal utilisé comme prison pour les utilisateurs sanctionnés. (default : #jail)
-        SALON_JAIL_MODES: Modes appliqués au canal de prison. (default : sS)
-        SALON_LIBERER: Canal utilisé pour la libération des utilisateurs sanctionnés. (default : #welcome)
-
+        SALON_JAIL: Canal utilisé comme prison pour les utilisateurs sanctionnés.
+        SALON_JAIL_MODES: Modes appliqués au canal de prison.
+        SALON_LIBERER: Canal utilisé pour la libération des utilisateurs sanctionnés.
     API (API)
-        API_TIMEOUT: Durée maximale d'attente d'une réponse de l'API en secondes. (default : 2)
-
+        API_TIMEOUT: Durée maximale d'attente d'une réponse de l'API en secondes.
     SCANNER (Scanner)
-        PORTS_TO_SCAN: Liste des ports à scanner pour détecter des serveurs potentiellement malveillants. (default : [])
-
+        PORTS_TO_SCAN: Liste des ports à scanner pour détecter des serveurs potentiellement malveillants.
     SÉCURITÉ (Sécurité)
-        WHITELISTED_IP: Liste d'adresses IP autorisées à contourner certaines restrictions. (default : ['127.0.0.1'])
-        GLINE_DURATION: Durée de bannissement temporaire d'un utilisateur en minutes. (default : "30")
-
+        WHITELISTED_IP: Liste d'adresses IP autorisées à contourner certaines restrictions.
+        GLINE_DURATION: Durée de bannissement temporaire d'un utilisateur en minutes.
     DEBUG (Debug)
-        DEBUG_LEVEL: Niveau de verbosité des messages de debug (plus grand est le nombre, plus il y a d'informations). (default : 20) Pour une production
+        DEBUG_LEVEL: Niveau de verbosité des messages de debug (plus grand est le nombre, plus il y a d'informations).
+    COULEURS (Couleurs)
+        CONFIG_COLOR: Dictionnaire contenant des codes de couleurs IRC pour un meilleur affichage des messages.
 
-```
     Modification de la configuration
 
-        Vous devez modifier le fichier configuration.json en remplaçant les valeurs par défaut avec vos propres informations. Assurez-vous de bien lire la description de chaque paramètre pour une configuration optimale du service.
+        Vous devez modifier le fichier config.json en remplaçant les valeurs par défaut avec vos propres informations. Assurez-vous de bien lire la description de chaque paramètre pour une configuration optimale du service.
 
-## Exemple de configuration de base
-```json
-{
-    "SERVEUR_IP": "IP.DE.TON.SERVER",
-    "SERVEUR_HOSTNAME": "HOST.DE.TON.SERVER",
-    "SERVEUR_LINK": "LINK.DE.TON.SERVER",
-    "SERVEUR_PORT": 6901,
-    "SERVEUR_PASSWORD": "MOT_DE_PASS_DE_TON_LINK",
-    "SERVEUR_ID": "10Z",
-    "SERVEUR_SSL": true,
+    Attention
 
-    "SERVICE_NAME": "defender",
-    "SERVICE_NICKNAME": "PyDefender",
-    "SERVICE_REALNAME": "Python Defender Security",
-    "SERVICE_USERNAME": "PyDefender",
-    "SERVICE_HOST": "HOST.DE.TON.DEFENDER",
-
-    "OWNER": "TON_NICK_NAME",
-    "PASSWORD": "TON_PASSWORD"
-
-}
-
-```
-
-## Exemple complet de configuration
-```json
-{
-    "SERVEUR_IP": "YOUR.SERVER.IP",
-    "SERVEUR_HOSTNAME": "YOUR.SERVER.HOST",
-    "SERVEUR_LINK": "LINK.DE.TON.SERVER",
-    "SERVEUR_PORT": 6901,
-    "SERVEUR_PASSWORD": "YOUR_LINK_PASSWORD",
-    "SERVEUR_ID": "10Z",
-    "SERVEUR_SSL": true,
-
-    "SERVICE_NAME": "defender",
-    "SERVICE_NICKNAME": "PyDefender",
-    "SERVICE_REALNAME": "Python Defender Security",
-    "SERVICE_USERNAME": "PyDefender",
-    "SERVICE_HOST": "HOST.DE.TON.DEFENDER",
-    "SERVICE_INFO": "Network IRC Service",
-    "SERVICE_CHANLOG": "#services",
-    "SERVICE_SMODES": "+ioqBS",
-    "SERVICE_CMODES": "ntsOP",
-    "SERVICE_UMODES": "o",
-    "SERVICE_PREFIX": "!",
-
-    "OWNER": "TON_NICK_NAME",
-    "PASSWORD": "TON_PASSWORD",
-
-    "JSONRPC_URL": "https://your.domaine.com:8600/api",
-    "JSONRPC_PATH_TO_SOCKET_FILE": "/PATH/TO/YOUR/IRCD/data/rpc.socket",
-    "JSONRPC_METHOD": "socket",
-    "JSONRPC_USER": "YOUR_RPC_USER",
-    "JSONRPC_PASSWORD": "YOUR_RPC_PASSWORD",
-
-    "SALON_JAIL": "#jail",
-    "SALON_JAIL_MODES": "sS",
-    "SALON_LIBERER": "#welcome",
-
-    "CLONE_CHANNEL": "#clones",
-    "CLONE_CMODES": "+nts",
-    "CLONE_LOG_HOST_EXEMPT": ["HOST.TO.SKIP"],
-    "CLONE_CHANNEL_PASSWORD": "YOUR_CHANNEL_PASSWORD",
-
-    "API_TIMEOUT": 2,
-
-    "PORTS_TO_SCAN": [3028, 8080, 1080, 1085, 4145, 9050],
-    "WHITELISTED_IP": ["127.0.0.1"],
-    "GLINE_DURATION": "30",
-
-    "DEBUG_LEVEL": 20
-
-}
-```
-
-# \\!/ Attention \\!/
         Le mot de passe de l'administrateur et le mot de passe du service doivent être modifiés pour des raisons de sécurité.
         Ne partagez pas vos informations de connexion au serveur IRC avec des tiers.
-a votre premiere connexion vous devez tapez 
-```
-    /msg [NomDuService] auth [nickname] [password]
-    -- Une fois identifié tapez la commande suivante
-    /msg [NomDuService] editaccess [nickname] [Nouveau-Password] 5
-```
-# Unrealircd configuration
-```
-listen {
-	ip *;
-	port 6901;
-	options { tls; serversonly; }
-}
-
-link LINK.DE.TON.SERVER
-{
-
-	incoming {
-                mask *;
-                bind-ip *;
-                port 6901;
-                //options { tls; };
-        }
-
-	outgoing {
-                bind-ip *; /* ou une IP précise */
-                hostname LINK.DE.TON.SERVER;
-                port 6901;
-                //options { tls; }
-        }
-
-	password "YOUR_LINK_PASSWORD";
-	
-        class servers;
-
-}
-
-ulines {
-	LINK.DE.TON.SERVER;
-}
-```
 
 #Extension:
     Le code est modulaire et conçu pour être facilement étendu. Vous pouvez ajouter de nouvelles commandes, de nouvelles fonctionnalités (mods/mod_test.py  est un exemple pour bien demarrer la création de son module).

core/Model.py

@@ -10,15 +10,12 @@ class User:
         uid: str
         nickname: str
         username: str
-        realname: str
         hostname: str
         umodes: str
         vhost: str
         isWebirc: bool
-        isWebsocket: bool
         remote_ip: str
         score_connexion: int
-        geoip: str = None
         connexion_datetime: datetime = field(default=datetime.now())
 
     UID_DB: list[UserModel] = []
@@ -413,11 +410,6 @@ class Clones:
         alive: bool
         nickname: str
         username: str
-        realname: str
-        channels: list
-        vhost: str = None
-        init: bool = True
-        connected: bool = False
 
     UID_CLONE_DB: list[CloneModel] = []
 

core/base.py

@@ -1,27 +1,18 @@
-import os
-import re
-import json
-import time
-import random
-import socket
-import hashlib
-import logging
-import threading
-import ipaddress
-
-import ast
-import requests
-
+import time, threading, os, random, socket, hashlib, ipaddress, logging, requests, json, re, ast
 from dataclasses import fields
 from typing import Union, Literal
-from base64 import b64decode, b64encode
-from datetime import datetime, timedelta, timezone
+from base64 import b64decode
+from datetime import datetime
 from sqlalchemy import create_engine, Engine, Connection, CursorResult
 from sqlalchemy.sql import text
 from core.loadConf import ConfigDataModel
 
 class Base:
 
+    # CORE_DB_PATH = 'core' + os.sep + 'db' + os.sep              # Le dossier bases de données core
+    # MODS_DB_PATH = 'mods' + os.sep + 'db' + os.sep              # Le dossier bases de données des modules
+    # PYTHON_MIN_VERSION = '3.10'                                 # Version min de python
+
     def __init__(self, Config: ConfigDataModel) -> None:
 
         self.Config = Config                                    # Assigner l'objet de configuration
@@ -39,6 +30,8 @@ class Base:
         self.engine, self.cursor = self.db_init()               # Initialisation de la connexion a la base de données
         self.__create_db()                                      # Initialisation de la base de données
 
+        self.db_create_first_admin()                            # Créer un nouvel admin si la base de données est vide
+
     def __set_current_defender_version(self) -> None:
         """This will put the current version of Defender
         located in version.json
@@ -48,6 +41,7 @@ class Base:
         with open(version_filename, 'r') as version_data:
             current_version:dict[str, str] = json.load(version_data)
 
+        # self.DEFENDER_VERSION = current_version["version"]
         self.Config.current_version = current_version['version']
 
         return None
@@ -80,14 +74,6 @@ class Base:
             self.logs.warning(f'Github not available to fetch latest version')
 
     def check_for_new_version(self, online:bool) -> bool:
-        """Check if there is a new version available
-
-        Args:
-            online (bool): True if you want to get the version from github (main branch)
-
-        Returns:
-            bool: True if there is a new version available
-        """
         try:
             self.logs.debug(f'Checking for a new service version')
 
@@ -126,11 +112,7 @@ class Base:
         Cette fonction retourne un UNIXTIME de type 12365456
         Return: Current time in seconds since the Epoch (int)
         """
-        cet_offset = timezone(timedelta(hours=2))
-        now_cet = datetime.now(cet_offset)
-        unixtime_cet = int(now_cet.timestamp())
         unixtime = int( time.time() )
-
         return unixtime
 
     def get_datetime(self) -> str:
@@ -236,24 +218,11 @@ class Base:
 
         return False
 
-    def db_update_module(self, user_cmd: str, module_name: str) -> None:
-        """Modifie la date et le user qui a rechargé le module
-
-        Args:
-            user_cmd (str): le user qui a rechargé le module
-            module_name (str): le module a rechargé
-        """
-        update_cmd_query = f"UPDATE {self.Config.table_module} SET datetime = :datetime, user = :user WHERE module_name = :module_name"
-        mes_donnees = {'datetime': self.get_datetime(), 'user': user_cmd, 'module_name': module_name}
-        self.db_execute_query(update_cmd_query, mes_donnees)
-
-        return False
-
     def db_delete_module(self, module_name:str) -> None:
         """Supprime les modules de la base de données
 
         Args:
-            cmd (str): le module a supprimer
+            cmd (str): le module a enregistrer
         """
         insert_cmd_query = f"DELETE FROM {self.Config.table_module} WHERE module_name = :module_name"
         mes_donnees = {'module_name': module_name}
@@ -342,7 +311,7 @@ class Base:
 
     def db_update_core_config(self, module_name:str, dataclassObj: object, param_key:str, param_value: str) -> bool:
 
-        core_table = self.Config.table_config
+        core_table = 'core_config'
         # Check if the param exist
         if not hasattr(dataclassObj, param_key):
             self.logs.error(f"Le parametre {param_key} n'existe pas dans la variable global")
@@ -365,10 +334,6 @@ class Base:
             if updated_rows > 0:
                 setattr(dataclassObj, param_key, self.int_if_possible(param_value))
                 self.logs.debug(f'Parameter updated : {param_key} - {param_value} | Module: {module_name}')
-            else:
-                self.logs.error(f'Parameter NOT updated : {param_key} - {param_value} | Module: {module_name}')
-        else:
-            self.logs.error(f'Parameter and Module do not exist: Param ({param_key}) - Value ({param_value}) | Module ({module_name})')
 
         self.logs.debug(dataclassObj)
 
@@ -464,7 +429,7 @@ class Base:
         except AssertionError as ae:
             self.logs.error(f'Assertion Error -> {ae}')
 
-    def create_thread(self, func:object, func_args: tuple = (), run_once:bool = False, daemon: bool = True) -> None:
+    def create_thread(self, func:object, func_args: tuple = (), run_once:bool = False) -> None:
         """Create a new thread and store it into running_threads variable
 
         Args:
@@ -480,7 +445,7 @@ class Base:
                     if thread.getName() == func_name:
                         return None
 
-            th = threading.Thread(target=func, args=func_args, name=str(func_name), daemon=daemon)
+            th = threading.Thread(target=func, args=func_args, name=str(func_name), daemon=True)
             th.start()
 
             self.running_threads.append(th)
@@ -611,7 +576,7 @@ class Base:
             )
         '''
         
-        table_core_channel = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_channel} (
+        table_core_channel = '''CREATE TABLE IF NOT EXISTS core_channel (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             datetime TEXT,
             module_name TEXT,
@@ -717,17 +682,6 @@ class Base:
             self.logs.critical(f'This remote ip is not valid : {ve}')
             return None
 
-    # def encode_ip(self, remote_ip_address: str) -> Union[str, None]:
-
-    #     binary_ip = b64encode()
-    #     try:
-    #         decoded_ip = ipaddress.ip_address(binary_ip)
-
-    #         return decoded_ip.exploded
-    #     except ValueError as ve:
-    #         self.logs.critical(f'This remote ip is not valid : {ve}')
-    #         return None
-
     def get_random(self, lenght:int) -> str:
         """
         Retourn une chaîne aléatoire en fonction de la longueur spécifiée.
@@ -795,4 +749,4 @@ class Base:
         except TypeError as te:
             self.logs.error(f'TypeError: [{channelToCheck}] - {te}')
         except Exception as err:
-            self.logs.error(f'Error Not defined: {err}')
+            self.logs.error(f'TypeError: {err}')

core/connection.py

@@ -1,24 +1,19 @@
-import socket
-import ssl
-import traceback
+import socket, ssl, time
 from ssl import SSLSocket
-from typing import Union
 from core.loadConf import Config
 from core.Model import Clones
 from core.base import Base
+from typing import Union
 
 class Connection:
 
-    def __init__(self, server_port: int, nickname: str, username: str, realname: str, channels:list[str], CloneObject: Clones, ssl:bool = False) -> None:
+    def __init__(self, server_port: int, nickname: str, username: str, channels:list[str], CloneObject: Clones, ssl:bool = False) -> None:
 
         self.Config = Config().ConfigObject
         self.Base = Base(self.Config)
         self.IrcSocket: Union[socket.socket, SSLSocket] = None
         self.nickname = nickname
         self.username = username
-        self.realname = realname
-        self.clone_chanlog = self.Config.CLONE_CHANNEL
-        self.clone_log_exempt = self.Config.CLONE_LOG_HOST_EXEMPT
         self.channels:list[str] = channels
         self.CHARSET = ['utf-8', 'iso-8859-1']
         self.Clones = CloneObject
@@ -65,7 +60,7 @@ class Connection:
             self.Base.logs.critical(f"AttributeError __create_socket: {ae} - {soc.fileno()}")
             return False
 
-    def send2socket(self, send_message:str, disconnect: bool = False) -> None:
+    def send2socket(self, send_message:str) -> None:
         """Envoit les commandes à envoyer au serveur.
 
         Args:
@@ -73,8 +68,9 @@ class Connection:
         """
         try:
             with self.Base.lock:
+                # print(f">{str(send_message)}")
                 self.IrcSocket.send(f"{send_message}\r\n".encode(self.CHARSET[0]))
-                self.Base.logs.debug(f'<<{self.currentCloneObject.nickname}>>: {send_message}')
+                self.Base.logs.debug(f'{send_message}')
 
         except UnicodeDecodeError:
             self.Base.logs.error(f'Decode Error try iso-8859-1 - message: {send_message}')
@@ -101,11 +97,10 @@ class Connection:
         try:
             nickname = self.nickname
             username = self.username
-            realname = self.realname
 
             # Envoyer un message d'identification
             writer.send(f"USER {nickname} {username} {username} {nickname} {username} :{username}\r\n".encode('utf-8'))
-            writer.send(f"USER {username} {username} {username} :{realname}\r\n".encode('utf-8'))
+            writer.send(f"USER {username} {username} {username} :{username}\r\n".encode('utf-8'))
             writer.send(f"NICK {nickname}\r\n".encode('utf-8'))
 
             self.Base.logs.debug('Link information sent to the server')
@@ -116,6 +111,7 @@ class Connection:
 
     def connect(self):
         try:
+
             while self.signal:
                 try:
                     # 4072 max what the socket can grab
@@ -133,7 +129,6 @@ class Connection:
                     data = data_in_bytes.splitlines(True)
 
                     if not data:
-                        # If no data then quit the loop
                         break
 
                     self.parser(data)
@@ -147,10 +142,9 @@ class Connection:
                     self.Base.logs.error(f"OSError __connect_to_irc: {oe} - {data}")
                     self.signal = False
 
-            self.IrcSocket.shutdown(socket.SHUT_WR)
-            self.IrcSocket.shutdown(socket.SHUT_RD)
-            self.currentCloneObject.init = False
-            self.Base.logs.info(f"<<{self.currentCloneObject.nickname}>> Clone Disconnected ...")
+            self.IrcSocket.shutdown(socket.SHUT_RDWR)
+            self.IrcSocket.close()
+            self.Base.logs.info("--> Clone Disconnected ...")
 
         except AssertionError as ae:
             self.Base.logs.error(f'Assertion error : {ae}')
@@ -160,16 +154,14 @@ class Connection:
             self.Base.logs.error(f"OS Error __connect_to_irc: {soe}")
         except AttributeError as atte:
             self.Base.logs.critical(f"{atte}")
-            self.Base.logs.critical(f"{traceback.format_exc()}")
         except Exception as e:
             self.Base.logs.error(f"Exception: {e}")
 
     def parser(self, cmd:list[bytes]):
         try:
-
             for data in cmd:
                 response = data.decode(self.CHARSET[0]).split()
-                current_clone_nickname = self.currentCloneObject.nickname
+                self.signal = self.currentCloneObject.alive
                 # print(response)
 
                 match response[0]:
@@ -180,74 +172,29 @@ class Connection:
                     case 'ERROR':
                         error_value = str(response[1]).replace(':','')
                         if error_value == 'Closing':
-                            self.Base.logs.info(f"<<{self.currentCloneObject.nickname}>> {response} ...")
-                            self.currentCloneObject.connected = False
-                        else:
-                            self.Base.logs.info(f"<<{self.currentCloneObject.nickname}>> {response} ...")
-                            # self.signal = False
+                            self.signal = False
 
                 match response[1]:
                     case '376':
-                        # End of MOTD
-                        self.currentCloneObject.connected = True
-                        self.currentCloneObject.init = False
                         for channel in self.channels:
                             self.send2socket(f"JOIN {channel}")
-
-                        self.send2socket(f"JOIN {self.clone_chanlog} {self.Config.CLONE_CHANNEL_PASSWORD}")
-
                         return None
-
-                    case '422':
-                        # Missing MOTD
-                        self.currentCloneObject.connected = True
-                        self.currentCloneObject.init = False
-                        for channel in self.channels:
-                            self.send2socket(f"JOIN {channel}")
-
-                        self.send2socket(f"JOIN {self.clone_chanlog} {self.Config.CLONE_CHANNEL_PASSWORD}")
-                        return None
-
-                    case '433':
-                        # Nickname already in use
-                        self.currentCloneObject.connected = False
-                        self.currentCloneObject.init = False
-                        self.send2socket(f'QUIT :Thanks and goodbye')
-                        self.Base.logs.warning(f"Nickname {self.currentCloneObject.nickname} already in use >> Clone should be disconnected")
-                        return None
-
                     case 'PRIVMSG':
-                        self.Base.logs.debug(f'<<{self.currentCloneObject.nickname}>> Response: {response}')
-                        self.Base.logs.debug(f'<<{self.currentCloneObject.nickname}>> Alive: {self.currentCloneObject.alive}')
+                        self.Base.logs.debug(response)
+                        self.Base.logs.debug(f'{self.currentCloneObject.nickname} - {self.currentCloneObject.alive}')
                         fullname = str(response[0]).replace(':', '')
                         nickname = fullname.split('!')[0].replace(':','')
-
-                        if response[2] == current_clone_nickname and nickname != self.Config.SERVICE_NICKNAME:
-                            message = []
-                            for i in range(3, len(response)):
-                                    message.append(response[i])
-                            final_message = ' '.join(message)
-
-                            exampt = False
-                            for log_exception in self.clone_log_exempt:
-                                if log_exception in fullname:
-                                    exampt = True
-
-                            if not exampt:
-                                self.send2socket(f"PRIVMSG {self.clone_chanlog} :{fullname} => {final_message[1:]}")
-
                         if nickname == self.Config.SERVICE_NICKNAME:
                             command = str(response[3]).replace(':','')
-
                             if command == 'KILL':
                                 self.send2socket(f'QUIT :Thanks and goodbye')
-
+                                self.signal = self.currentCloneObject.alive
                             if command == 'JOIN':
                                 channel_to_join = str(response[4])
                                 self.send2socket(f"JOIN {channel_to_join}")
-
                             if command == 'SAY':
                                 clone_channel = str(response[4])
+
                                 message = []
                                 for i in range(5, len(response)):
                                     message.append(response[i])
@@ -255,6 +202,7 @@ class Connection:
 
                                 self.send2socket(f"PRIVMSG {clone_channel} :{final_message}")
                                 
+
         except UnicodeEncodeError:
             for data in cmd:
                 response = data.decode(self.CHARSET[1],'replace').split()

core/exemple_configuration.json

@@ -1,48 +1,48 @@
 {
-    "SERVEUR_IP": "YOUR.SERVER.IP",
-    "SERVEUR_HOSTNAME": "YOUR.SERVER.HOST",
-    "SERVEUR_LINK": "LINK.DE.TON.SERVER",
+    "SERVEUR_IP": "0.0.0.0",
+    "SERVEUR_HOSTNAME": "your.host.name",
+    "SERVEUR_LINK": "your.link.to.server",
     "SERVEUR_PORT": 7002,
-    "SERVEUR_PASSWORD": "YOUR_LINK_PASSWORD",
+    "SERVEUR_PASSWORD": "link_password",
     "SERVEUR_ID": "006",
     "SERVEUR_SSL": true,
 
     "SERVICE_NAME": "defender",
-    "SERVICE_NICKNAME": "PyDefender",
-    "SERVICE_REALNAME": "Python Defender Security",
-    "SERVICE_USERNAME": "PyDefender",
-    "SERVICE_HOST": "HOST.DE.TON.DEFENDER",
+    "SERVICE_NICKNAME": "BotNickname",
+    "SERVICE_REALNAME": "BotRealname",
+    "SERVICE_USERNAME": "BotUsername",
+    "SERVICE_HOST": "your.service.hostname",
     "SERVICE_INFO": "Network IRC Service",
     "SERVICE_CHANLOG": "#services",
     "SERVICE_SMODES": "+ioqBS",
-    "SERVICE_CMODES": "ntsOP",
+    "SERVICE_CMODES": "ntsO",
     "SERVICE_UMODES": "o",
     "SERVICE_PREFIX": "!",
 
-    "OWNER": "TON_NICK_NAME",
-    "PASSWORD": "TON_PASSWORD",
-
-    "JSONRPC_URL": "https://your.domaine.com:8600/api",
-    "JSONRPC_PATH_TO_SOCKET_FILE": "/PATH/TO/YOUR/IRCD/data/rpc.socket",
-    "JSONRPC_METHOD": "socket",
-    "JSONRPC_USER": "YOUR_RPC_USER",
-    "JSONRPC_PASSWORD": "YOUR_RPC_PASSWORD",
+    "OWNER": "admin",
+    "PASSWORD": "password",
 
     "SALON_JAIL": "#jail",
     "SALON_JAIL_MODES": "sS",
     "SALON_LIBERER": "#welcome",
 
-    "CLONE_CHANNEL": "#clones",
-    "CLONE_CMODES": "+nts",
-    "CLONE_LOG_HOST_EXEMPT": ["HOST.TO.SKIP"],
-    "CLONE_CHANNEL_PASSWORD": "YOUR_CHANNEL_PASSWORD",
-
     "API_TIMEOUT": 2,
 
     "PORTS_TO_SCAN": [3028, 8080, 1080, 1085, 4145, 9050],
     "WHITELISTED_IP": ["127.0.0.1"],
     "GLINE_DURATION": "30",
 
-    "DEBUG_LEVEL": 20
+    "DEBUG_LEVEL": 20,
+
+    "CONFIG_COLOR": {
+                        "blanche": "\\u0003\\u0030",
+                        "noire": "\\u0003\\u0031",
+                        "bleue": "\\u0003\\u0020",
+                        "verte": "\\u0003\\u0033",
+                        "rouge": "\\u0003\\u0034",
+                        "jaune": "\\u0003\\u0036",
+                        "gras": "\\u0002",
+                        "nogc": "\\u0002\\u0003"
+                    }
 
 }

core/installation.py

@@ -1,9 +1,8 @@
-import os
-import json
-from sys import exit, prefix
 from dataclasses import dataclass
-from subprocess import check_call, run, CalledProcessError, PIPE, check_output
+from subprocess import check_call, run, CalledProcessError, PIPE
 from platform import python_version, python_version_tuple
+from sys import exit
+import os
 
 class Install:
 
@@ -25,22 +24,19 @@ class Install:
         venv_pip_executable: str
         venv_python_executable: str
 
-    @dataclass
-    class Package:
-        name: str = None
-        version: str = None
-
-    DB_PACKAGES: list[Package] = []
-
     def __init__(self) -> None:
 
         self.set_configuration()
 
+        if not self.check_python_version():
+            # Tester si c'est la bonne version de python
+            exit("Python Version Error")
+        else:
+
             if self.skip_install:
-            self.check_packages_version()
                 return None
 
-        self.check_packages_version()
+            print(f'Configuration loaded : {self.config}')
 
             # Sinon tester les dependances python et les installer avec pip
             if self.do_install():
@@ -75,36 +71,23 @@ class Install:
                 defender_install_folder=defender_install_folder,
                 venv_folder=venv_folder,
                 venv_cmd_installation=['python3', '-m', 'venv', venv_folder],
-                venv_cmd_requirements=['sqlalchemy','psutil','requests','faker','unrealircd_rpc_py'],
+                venv_cmd_requirements=['sqlalchemy','psutil','requests','faker'],
                 venv_pip_executable=f'{os.path.join(defender_install_folder, venv_folder, "bin")}{os.sep}pip',
                 venv_python_executable=f'{os.path.join(defender_install_folder, venv_folder, "bin")}{os.sep}python'
             )
 
-        if not self.check_python_version():
-            # If the Python version is not good then Exit
-            exit("/!\\ Python version error /!\\")
-
-        if not os.path.exists(os.path.join(self.config.defender_install_folder, 'core', 'configuration.json')):
-            # If configuration file do not exist
-            exit("/!\\ Configuration file (core/configuration.json) doesn't exist! please create it /!\\")
-
-        # Exclude Windows OS from the installation
+        # Exclude Windows OS
         if os.name == 'nt':
-            # If windows, modify pip and python virtual environment executable
-            self.config.venv_pip_executable = f'{os.path.join(defender_install_folder, venv_folder, "Scripts")}{os.sep}pip.exe'
-            self.config.venv_python_executable = f'{os.path.join(defender_install_folder, venv_folder, "Scripts")}{os.sep}python.exe'
+            #print('/!\\ Skip installation /!\\')
             self.skip_install = True
-            return False
-
+        else:
             if self.is_root():
-            exit(f'/!\\ I highly not recommend running Defender as root /!\\')
                 self.skip_install = True
-            return False
 
     def is_root(self) -> bool:
 
         if os.geteuid() != 0:
-            print('> User without privileges ==> OK')
+            print('User without privileges ==> PASS')
             return False
         elif os.geteuid() == 0:
             print('/!\\ Do not use root to install Defender /!\\')
@@ -136,75 +119,6 @@ class Install:
             print(f"Try to install dependencies ...")
             exit(5)
 
-    def get_packages_version_from_json(self) -> None:
-        """This will create Package model with package names and required version
-        """
-        try:
-            
-            version_filename = f'.{os.sep}version.json'
-            with open(version_filename, 'r') as version_data:
-                package_info:dict[str, str] = json.load(version_data)
-
-            for name, version in package_info.items():
-                if name == 'version':
-                    continue
-
-                self.DB_PACKAGES.append(
-                    self.Package(name=name, version=version)
-                    )
-
-            return None
-        except FileNotFoundError as fe:
-            print(f"File not found: {fe}")
-        except Exception as err:
-            print(f"General Error: {err}")
-
-    def check_packages_version(self) -> bool:
-
-        try:
-            newVersion = False
-            self.get_packages_version_from_json()
-            
-            if not self.config.venv_folder in prefix:
-                print(f"You are probably running a new installation or you are not using your virtual env {self.config.venv_folder}")
-                return newVersion
-
-            print(f"> Checking for dependencies versions ==> WAIT")
-            for package in self.DB_PACKAGES:
-                newVersion = False
-                required_version = package.version
-                installed_version = None
-
-                output = check_output([self.config.venv_pip_executable, 'show', package.name])
-                for line in output.decode().splitlines():
-                    if line.startswith('Version:'):
-                        installed_version = line.split(':')[1].strip()
-                        break
-
-                required_major, required_minor, required_patch = required_version.split('.')
-                installed_major, installed_minor, installed_patch = installed_version.split('.')
-
-                if required_major > installed_major:
-                    print(f'> New version of {package.name} is available {installed_version} ==> {required_version}')
-                    newVersion = True
-                elif required_major == installed_major and required_minor > installed_minor:
-                    print(f'> New version of {package.name} is available {installed_version} ==> {required_version}')
-                    newVersion = True
-                elif required_major == installed_major and required_minor == installed_minor and required_patch > installed_patch:
-                    print(f'> New version of {package.name} is available {installed_version} ==> {required_version}')
-                    newVersion = True
-
-                if newVersion:
-                    self.run_subprocess([self.config.venv_pip_executable, 'install', '--upgrade', package.name])
-
-            print(f"> Dependencies versions ==> OK")
-            return newVersion
-
-        except CalledProcessError:
-            print(f"/!\\ Package {package.name} not installed /!\\")
-        except Exception as err:
-            print(f"General Error: {err}")
-
     def check_python_version(self) -> bool:
         """Test si la version de python est autorisée ou non
 
@@ -219,11 +133,11 @@ class Install:
         min_major, min_minor = tuple((python_required_version[0], python_required_version[1]))
 
         if int(sys_major) < int(min_major):
-            print(f"## Your python version must be greather than or equal to {self.config.python_min_version} ##")
+            print(f"## Your python version must be greather than or equal to {self.config.python_current_version} ##")
             return False
 
         elif (int(sys_major) <= int(min_major)) and (int(sys_minor) < int(min_minor)):
-            print(f"## Your python version must be greather than or equal to {self.config.python_min_version} ##")
+            print(f"## Your python version must be greather than or equal to {self.config.python_current_version} ##")
             return False
 
         print(f"> Version of python : {self.config.python_current_version} ==> OK")

core/irc.py

@@ -1,17 +1,10 @@
-import sys
-import socket
-import threading
-import ssl
-import re
-import importlib
-import time
-import traceback
+import ssl, re, importlib, sys, time, threading, socket
 from ssl import SSLSocket
 from datetime import datetime, timedelta
-from typing import Union
+from typing import Union, Literal
 from core.loadConf import Config
-from core.base import Base
 from core.Model import User, Admin, Channel, Clones
+from core.base import Base
 
 class Irc:
 
@@ -36,7 +29,7 @@ class Irc:
 
         # Liste des commandes internes du bot
         self.commands_level = {
-            0: ['help', 'auth', 'copyright', 'uptime', 'firstauth'],
+            0: ['help', 'auth', 'copyright', 'uptime'],
             1: ['load','reload','unload', 'deauth', 'checkversion'],
             2: ['show_modules', 'show_timers', 'show_threads', 'show_channels', 'show_users', 'show_admins'],
             3: ['quit', 'restart','addaccess','editaccess', 'delaccess']
@@ -95,15 +88,13 @@ class Irc:
             return None
 
         except ssl.SSLEOFError as soe:
-            self.Base.logs.critical(f"SSLEOFError: {soe} - {soc.fileno()}")
+            self.Base.logs.critical(f"SSLEOFError __create_socket: {soe} - {soc.fileno()}")
         except ssl.SSLError as se:
-            self.Base.logs.critical(f"SSLError: {se} - {soc.fileno()}")
+            self.Base.logs.critical(f"SSLError __create_socket: {se} - {soc.fileno()}")
         except OSError as oe:
-            self.Base.logs.critical(f"OSError: {oe} - {soc.fileno()}")
-            if 'connection refused' in str(oe).lower():
-                sys.exit(oe)
+            self.Base.logs.critical(f"OSError __create_socket: {oe} - {soc.fileno()}")
         except AttributeError as ae:
-            self.Base.logs.critical(f"AttributeError: {ae} - {soc.fileno()}")
+            self.Base.logs.critical(f"AttributeError __create_socket: {ae} - {soc.fileno()}")
 
     def __ssl_context(self) -> ssl.SSLContext:
         ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
@@ -119,8 +110,8 @@ class Irc:
             self.ircObject = ircInstance                        # créer une copie de l'instance Irc
             self.__link(self.IrcSocket)                         # établir la connexion au serveur IRC
             self.signal = True                                  # Une variable pour initier la boucle infinie
-            self.__join_saved_channels()                        # Join existing channels
             self.load_existing_modules()                        # Charger les modules existant dans la base de données
+            self.__join_saved_channels()                        # Join existing channels
 
             while self.signal:
                 try:
@@ -140,7 +131,6 @@ class Irc:
 
                         self.__create_socket()
                         self.__link(self.IrcSocket)
-                        self.__join_saved_channels()
                         self.load_existing_modules()
                         self.RESTART = 0
 
@@ -184,8 +174,7 @@ class Irc:
         except AttributeError as atte:
             self.Base.logs.critical(f"AttributeError: {atte}")
         except Exception as e:
-            self.Base.logs.critical(f"General Error: {e}")
-            self.Base.logs.critical(traceback.format_exc())
+            self.Base.logs.critical(f"Exception: {e}")
 
     def __link(self, writer:Union[socket.socket, SSLSocket]) -> None:
         """Créer le link et envoyer les informations nécessaires pour la 
@@ -223,15 +212,14 @@ class Irc:
             writer.send(f":{sid} PROTOCTL SID={sid}\r\n".encode(charset))
             writer.send(f":{sid} SERVER {link} 1 :{info}\r\n".encode(charset))
             writer.send(f":{sid} {nickname} :Reserved for services\r\n".encode(charset))
-            #writer.send(f":{sid} UID {nickname} 1 {unixtime} {username} {host} {service_id} * {smodes} * * * :{realname}\r\n".encode(charset))
-            writer.send(f":{sid} UID {nickname} 1 {unixtime} {username} {host} {service_id} * {smodes} * * fwAAAQ== :{realname}\r\n".encode(charset))
+            writer.send(f":{sid} UID {nickname} 1 {unixtime} {username} {host} {service_id} * {smodes} * * * :{realname}\r\n".encode(charset))
             writer.send(f":{sid} SJOIN {unixtime} {chan} + :{service_id}\r\n".encode(charset))
             writer.send(f":{sid} TKL + Q * {nickname} {host} 0 {unixtime} :Reserved for services\r\n".encode(charset))
 
             writer.send(f":{service_id} MODE {chan} +{cmodes}\r\n".encode(charset))
             writer.send(f":{service_id} MODE {chan} +{umodes} {service_id}\r\n".encode(charset))
 
-            self.Base.logs.debug('>> Link information sent to the server')
+            self.Base.logs.debug('Link information sent to the server')
 
             return None
         except AttributeError as ae:
@@ -258,6 +246,7 @@ class Irc:
         """
         try:
             with self.Base.lock:
+                # print(f">{str(send_message)}")
                 self.IrcSocket.send(f"{send_message}\r\n".encode(self.CHARSET[0]))
                 self.Base.logs.debug(f'{send_message}')
 
@@ -276,62 +265,21 @@ class Irc:
         except OSError as oe:
             self.Base.logs.error(f"OSError: {oe} - {send_message}")
 
-    def sendNotice(self, msg:str, nickname: str) -> None:
-        """Sending NOTICE by batches
-
-        Args:
-            msg (str): The message to send to the server
-            nickname (str): The reciever Nickname
-        """
-        batch_size = self.Config.BATCH_SIZE
-        service_nickname = self.Config.SERVICE_NICKNAME
-
-        for i in range(0, len(str(msg)), batch_size):
-            batch = str(msg)[i:i+batch_size]
-            self.send2socket(f":{service_nickname} NOTICE {nickname} :{batch}")
-
-    def sendPrivMsg(self, msg: str, channel: str = None, nickname: str = None):
-        """Sending PRIVMSG to a channel or to a nickname by batches
-        could be either channel or nickname not both together
-        Args:
-            msg (str): The message to send
-            channel (str, optional): The receiver channel. Defaults to None.
-            nickname (str, optional): The reciever nickname. Defaults to None.
-        """
-        batch_size = self.Config.BATCH_SIZE
-        service_nickname = self.Config.SERVICE_NICKNAME
-
-        if not channel is None:
-            for i in range(0, len(str(msg)), batch_size):
-                batch = str(msg)[i:i+batch_size]
-                self.send2socket(f":{service_nickname} PRIVMSG {channel} :{batch}")
-
-        if not nickname is None:
-            for i in range(0, len(str(msg)), batch_size):
-                batch = str(msg)[i:i+batch_size]
-                self.send2socket(f":{service_nickname} PRIVMSG {nickname} :{batch}")
-
     def send_response(self, responses:list[bytes]) -> None:
         try:
-            # print(responses)
+            # print(data)
             for data in responses:
                 response = data.decode(self.CHARSET[0]).split()
                 self.cmd(response)
 
-        except UnicodeEncodeError as ue:
+        except UnicodeEncodeError:
             for data in responses:
                 response = data.decode(self.CHARSET[1],'replace').split()
                 self.cmd(response)
-            self.Base.logs.error(f'UnicodeEncodeError: {ue}')
-            self.Base.logs.error(response)
-
-        except UnicodeDecodeError as ud:
+        except UnicodeDecodeError:
             for data in responses:
                 response = data.decode(self.CHARSET[1],'replace').split()
                 self.cmd(response)
-            self.Base.logs.error(f'UnicodeDecodeError: {ud}')
-            self.Base.logs.error(response)
-
         except AssertionError as ae:
             self.Base.logs.error(f"Assertion error : {ae}")
 
@@ -490,100 +438,15 @@ class Irc:
                 self.Base.db_record_module(fromuser, module_name)
             self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} chargé")
 
-            # self.Base.logs.info(self.loaded_classes)
-            self.Base.logs.info(f"Module {class_name} has been loaded")
+            self.Base.logs.info(self.loaded_classes)
             return True
 
         except ModuleNotFoundError as moduleNotFound:
             self.Base.logs.error(f"MODULE_NOT_FOUND: {moduleNotFound}")
-            self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.COLORS.red}MODULE_NOT_FOUND{self.Config.COLORS.black} ]: {moduleNotFound}")
-            self.Base.db_delete_module(module_name)
+            self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.CONFIG_COLOR['rouge']}MODULE_NOT_FOUND{self.Config.CONFIG_COLOR['noire']} ]: {moduleNotFound}")
         except Exception as e:
             self.Base.logs.error(f"Something went wrong with a module you want to load : {e}")
-            self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.COLORS.red}ERROR{self.Config.COLORS.black} ]: {e}")
-
-    def unload_module(self, mod_name: str) -> bool:
-        """Unload a module
-
-        Args:
-            mod_name (str): Module name ex mod_defender
-
-        Returns:
-            bool: True if success
-        """
-        try:
-            module_name = mod_name.lower()                              # Le nom du module. exemple: mod_defender
-            class_name = module_name.split('_')[1].capitalize()            # Nom de la class. exemple: Defender
-
-            if class_name in self.loaded_classes:
-                self.loaded_classes[class_name].unload()
-                for level, command in self.loaded_classes[class_name].commands_level.items():
-                    # Supprimer la commande de la variable commands
-                    for c in self.loaded_classes[class_name].commands_level[level]:
-                        self.commands.remove(c)
-                        self.commands_level[level].remove(c)
-
-                del self.loaded_classes[class_name]
-
-                # Supprimer le module de la base de données
-                self.Base.db_delete_module(module_name)
-
-                self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} supprimé")
-                return True
-
-        except Exception as err:
-            self.Base.logs.error(f"General Error: {err}")
-            return False
-
-    def reload_module(self, from_user: str, mod_name: str) -> bool:
-        try:
-            module_name = mod_name.lower()                       # ==> mod_defender
-            class_name = module_name.split('_')[1].capitalize()  # ==> Defender
-
-            if 'mods.' + module_name in sys.modules:
-                self.Base.logs.info('Unload the module ...')
-                self.loaded_classes[class_name].unload()
-                self.Base.logs.info('Module Already Loaded ... reloading the module ...')
-                the_module = sys.modules['mods.' + module_name]
-                importlib.reload(the_module)
-
-                # Supprimer la class déja instancier
-                if class_name in self.loaded_classes:
-                # Supprimer les commandes déclarer dans la classe
-                    for level, command in self.loaded_classes[class_name].commands_level.items():
-                        # Supprimer la commande de la variable commands
-                        for c in self.loaded_classes[class_name].commands_level[level]:
-                            self.commands.remove(c)
-                            self.commands_level[level].remove(c)
-
-                    del self.loaded_classes[class_name]
-
-                my_class = getattr(the_module, class_name, None)
-                new_instance = my_class(self.ircObject)
-                self.loaded_classes[class_name] = new_instance
-
-                self.Base.db_update_module(from_user, mod_name)
-                self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} rechargé")
-                return False
-            else:
-                self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} n'est pas chargé !")
-
-        except TypeError as te:
-            self.Base.logs.error(f"A TypeError raised: {te}")
-            self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :A TypeError raised: {te}")
-            self.Base.db_delete_module(module_name)
-        except AttributeError as ae:
-            self.Base.logs.error(f"Missing Attribute: {ae}")
-            self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Missing Attribute: {ae}")
-            self.Base.db_delete_module(module_name)
-        except KeyError as ke:
-            self.Base.logs.error(f"Key Error: {ke}")
-            self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Key Error: {ke}")
-            self.Base.db_delete_module(module_name)
-        except Exception as e:
-            self.Base.logs.error(f"Something went wrong with a module you want to reload: {e}")
-            self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Something went wrong with the module: {e}")
-            self.Base.db_delete_module(module_name)
+            self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.CONFIG_COLOR['rouge']}ERROR{self.Config.CONFIG_COLOR['noire']} ]: {e}")
 
     def insert_db_admin(self, uid:str, level:int) -> None:
 
@@ -711,6 +574,7 @@ class Irc:
         return None
 
     def thread_check_for_new_version(self, fromuser: str) -> None:
+
         dnickname = self.Config.SERVICE_NICKNAME
 
         if self.Base.check_for_new_version(True):
@@ -721,39 +585,35 @@ class Irc:
         
         return None
 
-    def cmd(self, data: list[str]) -> None:
-        """Parse server response
-
-        Args:
-            data (list[str]): Server response splitted in a list
-        """
+    def cmd(self, data:list) -> None:
         try:
-            original_response: list[str] = data.copy()
 
-            interm_response: list[str] = data.copy()
-            """This the original without first value"""
+            cmd_to_send:list[str] = data.copy()
+            cmd = data.copy()
 
-            interm_response.pop(0)
+            cmd_to_debug = data.copy()
+            cmd_to_debug.pop(0)
 
-            if len(original_response) == 0 or len(original_response) == 1:
-                self.Base.logs.warning(f'Size ({str(len(original_response))}) - {original_response}')
+            if len(cmd) == 0 or len(cmd) == 1:
+                self.Base.logs.warning(f'Size ({str(len(cmd))}) - {cmd}')
                 return False
 
-            if len(original_response) == 7:
-                if original_response[2] == 'PRIVMSG' and original_response[4] == ':auth':
-                    data_copy = original_response.copy()
+            # self.debug(cmd_to_debug)
+            if len(data) == 7:
+                if data[2] == 'PRIVMSG' and data[4] == ':auth':
+                    data_copy = data.copy()
                     data_copy[6] = '**********'
                     self.Base.logs.debug(data_copy)
                 else:
-                    self.Base.logs.debug(original_response)
+                    self.Base.logs.debug(data)
             else:
-                self.Base.logs.debug(original_response)
+                self.Base.logs.debug(data)
 
-            match original_response[0]:
+            match cmd[0]:
 
                 case 'PING':
                     # Sending PONG response to the serveur
-                    pong = str(original_response[1]).replace(':','')
+                    pong = str(cmd[1]).replace(':','')
                     self.send2socket(f"PONG :{pong}")
                     return None
 
@@ -762,19 +622,19 @@ class Irc:
                     # 'PREFIX=(qaohv)~&@%+', 'SID=001', 'MLOCK', 'TS=1703793941', 'EXTSWHOIS']
 
                     # GET SERVER ID HOST
-                    if len(original_response) > 5:
-                        if '=' in original_response[5]:
-                            serveur_hosting_id = str(original_response[5]).split('=')
+                    if len(cmd) > 5:
+                        if '=' in cmd[5]:
+                            serveur_hosting_id = str(cmd[5]).split('=')
                             self.HSID = serveur_hosting_id[1]
                             return False
 
                 case _:
                     pass
 
-            if len(original_response) < 2:
+            if len(cmd) < 2:
                 return False
 
-            match original_response[1]:
+            match cmd[1]:
 
                 case 'SLOG':
                     # self.Base.scan_ports(cmd[7])
@@ -782,45 +642,23 @@ class Irc:
                     #     self.Base.create_thread(self.abuseipdb_scan, (cmd[7], ))
                     pass
 
-                case 'SQUIT':
-                    # ['@msgid=QOEolbRxdhpVW5c8qLkbAU;time=2024-09-21T17:33:16.547Z', 'SQUIT', 'defender.deb.biz.st', ':Connection', 'closed']
-                    server_hostname = interm_response[1]
-                    uid_to_delete = ''
-                    for s_user in self.User.UID_DB:
-                        if s_user.hostname == server_hostname and 'S' in s_user.umodes:
-                            uid_to_delete = s_user.uid
-
-                    self.User.delete(uid_to_delete)
-                    self.Channel.delete_user_from_all_channel(uid_to_delete)
-
-                case 'SJOIN':
-                    # If Server Join channels
-                    # [':11Z', 'SJOIN', '1726940687', '#welcome', '+', ':11ZAAAAAB']
-                    channel_joined = original_response[3]
-                    server_uid = self.Base.clean_uid(original_response[5])
-
-                    self.Channel.insert(
-                        self.Channel.ChannelModel(
-                            name=channel_joined,
-                            uids=[server_uid]
-                        )
-                    )
-
                 case 'REPUTATION':
                     # :001 REPUTATION 91.168.141.239 118
                     try:
-                        self.first_connexion_ip = original_response[2]
+                        # if self.Config.ABUSEIPDB == 1:
+                        #     self.Base.create_thread(self.abuseipdb_scan, (cmd[2], ))
+                        self.first_connexion_ip = cmd[2]
 
                         self.first_score = 0
-                        if str(original_response[3]).find('*') != -1:
+                        if str(cmd[3]).find('*') != -1:
                             # If * available, it means that an ircop changed the repurtation score
                             # means also that the user exist will try to update all users with same IP
-                            self.first_score = int(str(original_response[3]).replace('*',''))
+                            self.first_score = int(str(cmd[3]).replace('*',''))
                             for user in self.User.UID_DB:
                                 if user.remote_ip == self.first_connexion_ip:
                                     user.score_connexion = self.first_score
                         else:
-                            self.first_score = int(original_response[3])
+                            self.first_score = int(cmd[3])
 
                         # Possibilité de déclancher les bans a ce niveau.
                     except IndexError as ie:
@@ -843,7 +681,7 @@ class Irc:
 
                 case 'EOS':
 
-                    hsid = str(original_response[0]).replace(':','')
+                    hsid = str(cmd[0]).replace(':','')
                     if hsid == self.HSID:
                         if self.INIT == 1:
                             current_version = self.Config.current_version
@@ -853,6 +691,10 @@ class Irc:
                             else:
                                 version = f'{current_version}'
 
+                            # self.send2socket(f":{self.Config.SERVICE_NICKNAME} SVSJOIN {self.Config.SERVICE_NICKNAME} {self.Config.SERVICE_CHANLOG}")
+                            # self.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.SERVICE_CHANLOG} +o {self.Config.SERVICE_NICKNAME}")
+                            # self.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.SERVICE_CHANLOG} +{self.Config.SERVICE_CMODES}")
+
                             print(f"################### DEFENDER ###################")
                             print(f"#               SERVICE CONNECTE                ")
                             print(f"# SERVEUR  :    {self.Config.SERVEUR_IP}        ")
@@ -879,28 +721,20 @@ class Irc:
                                 self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} : New Version available {version}")
 
                         # Initialisation terminé aprés le premier PING
-                        self.sendPrivMsg(msg=f'[{self.Config.COLORS.green}INFORMATION{self.Config.COLORS.nogc}] >> Defender is ready', channel=self.Config.SERVICE_CHANLOG)
                         self.INIT = 0
 
-                        # Send EOF to other modules
-                        for classe_name, classe_object in self.loaded_classes.items():
-                            classe_object.cmd(original_response)
-
-                        # Stop here When EOS
-                        return None
-
                 case _:
                     pass
 
-            if len(original_response) < 3:
+            if len(cmd) < 3:
                 return False
 
-            match original_response[2]:
+            match cmd[2]:
 
                 case 'QUIT':
                     # :001N1WD7L QUIT :Quit: free_znc_1
-
-                    uid_who_quit = str(interm_response[0]).replace(':', '')
+                    cmd.pop(0)
+                    uid_who_quit = str(cmd[0]).replace(':', '')
                     self.User.delete(uid_who_quit)
                     self.Channel.delete_user_from_all_channel(uid_who_quit)
 
@@ -912,8 +746,10 @@ class Irc:
                     # ['@unrealircd.org/geoip=FR;unrealircd.org/', ':001OOU2H3', 'NICK', 'WebIrc', '1703795844']
                     # Changement de nickname
 
-                    uid = str(interm_response[0]).replace(':','')
-                    newnickname = interm_response[2]
+                    # Supprimer la premiere valeur de la liste
+                    cmd.pop(0)
+                    uid = str(cmd[0]).replace(':','')
+                    newnickname = cmd[2]
                     self.User.update(uid, newnickname)
 
                 case 'MODE':
@@ -928,24 +764,24 @@ class Irc:
                     # ':001T6VU3F', '001JGWB2K', '@11ZAAAAAB', 
                     # '001F16WGR', '001X9YMGQ', '*+001DYPFGP', '@00BAAAAAJ', '001AAGOG9', '001FMFVG8', '001DAEEG7', 
                     # '&~G:unknown-users', '"~G:websocket-users', '"~G:known-users', '"~G:webirc-users']
-
-                    channel = str(interm_response[3]).lower()
-                    len_cmd = len(interm_response)
+                    cmd.pop(0)
+                    channel = str(cmd[3]).lower()
+                    len_cmd = len(cmd)
                     list_users:list = []
                     occurence = 0
                     start_boucle = 0
 
                     # Trouver le premier user
                     for i in range(len_cmd):
-                        s: list = re.findall(fr':', interm_response[i])
+                        s: list = re.findall(fr':', cmd[i])
                         if s:
                             occurence += 1
                             if occurence == 2:
                                 start_boucle = i
 
                     # Boucle qui va ajouter l'ensemble des users (UID)
-                    for i in range(start_boucle, len(interm_response)):
-                        parsed_UID = str(interm_response[i])
+                    for i in range(start_boucle, len(cmd)):
+                        parsed_UID = str(cmd[i])
                         # pattern = fr'[:|@|%|\+|~|\*]*'
                         # pattern = fr':'
                         # parsed_UID = re.sub(pattern, '', parsed_UID)
@@ -963,51 +799,32 @@ class Irc:
                 case 'PART':
                     # ['@unrealircd.org/geoip=FR;unrealircd.org/userhost=50d6492c@80.214.73.44;unrealircd.org/userip=50d6492c@80.214.73.44;msgid=YSIPB9q4PcRu0EVfC9ci7y-/mZT0+Gj5FLiDSZshH5NCw;time=2024-08-15T15:35:53.772Z', 
                     # ':001EPFBRD', 'PART', '#welcome', ':WEB', 'IRC', 'Paris']
-                    try:
-                        uid = str(interm_response[0]).replace(':','')
-                        channel = str(interm_response[2]).lower()
+                    uid = str(cmd[1]).replace(':','')
+                    channel = str(cmd[3]).lower()
                     self.Channel.delete_user_from_channel(channel, uid)
 
-                    except IndexError as ie:
-                        self.Base.logs.error(f'Index Error: {ie}')
+                    pass
 
                 case 'UID':
-                    try:
                     # ['@s2s-md/geoip=cc=GB|cd=United\\sKingdom|asn=16276|asname=OVH\\sSAS;s2s-md/tls_cipher=TLSv1.3-TLS_CHACHA20_POLY1305_SHA256;s2s-md/creationtime=1721564601', 
                     # ':001', 'UID', 'albatros', '0', '1721564597', 'albatros', 'vps-91b2f28b.vps.ovh.net', 
                     # '001HB8G04', '0', '+iwxz', 'Clk-A62F1D18.vps.ovh.net', 'Clk-A62F1D18.vps.ovh.net', 'MyZBwg==', ':...']
+                    if 'webirc' in cmd[0]:
+                        isWebirc = True
+                    else:
+                        isWebirc = False
 
-                        isWebirc = True if 'webirc' in original_response[0] else False
-                        isWebsocket = True if 'websocket' in original_response[0] else False
-
-                        uid = str(original_response[8])
-                        nickname = str(original_response[3])
-                        username = str(original_response[6])
-                        hostname = str(original_response[7])
-                        umodes = str(original_response[10])
-                        vhost = str(original_response[11])
-
+                    uid = str(cmd[8])
+                    nickname = str(cmd[3])
+                    username = str(cmd[6])
+                    hostname = str(cmd[7])
+                    umodes = str(cmd[10])
+                    vhost = str(cmd[11])
                     if not 'S' in umodes:
-                            remote_ip = self.Base.decode_ip(str(original_response[13]))
+                        remote_ip = self.Base.decode_ip(str(cmd[13]))
                     else:
                         remote_ip = '127.0.0.1'
 
-                        # extract realname
-                        realname_list = []
-                        for i in range(14, len(original_response)):
-                            realname_list.append(original_response[i])
-
-                        realname = ' '.join(realname_list)[1:]
-
-                        # Extract Geoip information
-                        pattern = r'^.*geoip=cc=(\S{2}).*$'
-                        geoip_match = re.match(pattern, original_response[0])
-
-                        if geoip_match:
-                            geoip = geoip_match.group(1)
-                        else:
-                            geoip = None
-
                     score_connexion = self.first_score
 
                     self.User.insert(
@@ -1015,36 +832,29 @@ class Irc:
                             uid=uid,
                             nickname=nickname,
                             username=username,
-                                realname=realname,
                             hostname=hostname,
                             umodes=umodes,
                             vhost=vhost,
                             isWebirc=isWebirc,
-                                isWebsocket=isWebsocket,
                             remote_ip=remote_ip,
-                                geoip=geoip,
                             score_connexion=score_connexion,
                             connexion_datetime=datetime.now()
                         )
                     )
 
                     for classe_name, classe_object in self.loaded_classes.items():
-                            classe_object.cmd(original_response)
-
-                    except Exception as err:
-                        self.Base.logs.error(f'General Error: {err}')
+                        classe_object.cmd(cmd_to_send)
 
                 case 'PRIVMSG':
                     try:
                         # Supprimer la premiere valeur
-                        cmd = interm_response.copy()
-
+                        cmd.pop(0)
                         get_uid_or_nickname = str(cmd[0].replace(':',''))
                         user_trigger = self.User.get_nickname(get_uid_or_nickname)
                         dnickname = self.Config.SERVICE_NICKNAME
 
                         if len(cmd) == 6:
-                            if cmd[1] == 'PRIVMSG' and str(cmd[3]).replace(self.Config.SERVICE_PREFIX,'') == ':auth':
+                            if cmd[1] == 'PRIVMSG' and str(cmd[3]).replace('.','') == ':auth':
                                 cmd_copy = cmd.copy()
                                 cmd_copy[5] = '**********'
                                 self.Base.logs.info(cmd_copy)
@@ -1063,8 +873,7 @@ class Irc:
                             arg.remove(f':{self.Config.SERVICE_PREFIX}')
                             if not arg[0].lower() in self.commands:
                                 self.Base.logs.debug(f"This command {arg[0]} is not available")
-                                self.sendNotice(f"This command [{self.Config.COLORS.bold}{arg[0]}{self.Config.COLORS.bold}] is not available", user_trigger)
-                                return None
+                                return False
 
                             cmd_to_send = convert_to_string.replace(':','')
                             self.Base.log_cmd(user_trigger, cmd_to_send)
@@ -1098,17 +907,15 @@ class Irc:
                                     recieved_unixtime = int(arg[1].replace('\x01',''))
                                     current_unixtime = self.Base.get_unixtime()
                                     ping_response = current_unixtime - recieved_unixtime
-
-                                    self.send2socket(f'PONG :{recieved_unixtime}')
-                                    self.send2socket(f':{dnickname} NOTICE {user_trigger} :\x01PING {ping_response} secs\x01')
+                                    self.send2socket(f':{dnickname} NOTICE {user_trigger} :\x01PING {str(ping_response)} secs\x01')
                                     return False
 
                                 if not arg[0].lower() in self.commands:
-                                    self.Base.logs.debug(f"This command {arg[0]} sent by {user_trigger} is not available")
+                                    self.debug(f"This command {arg[0]} is not available")
                                     return False
 
                                 cmd_to_send = convert_to_string.replace(':','')
-                                self.Base.log_cmd(user_trigger, cmd_to_send)
+                                self.Base.log_cmd(self.User.get_nickname(user_trigger), cmd_to_send)
 
                                 fromchannel = None
                                 if len(arg) >= 2:
@@ -1122,29 +929,15 @@ class Irc:
                 case _:
                     pass
 
-            if original_response[2] != 'UID':
+            if cmd[2] != 'UID':
                 # Envoyer la commande aux classes dynamiquement chargées
                 for classe_name, classe_object in self.loaded_classes.items():
-                    classe_object.cmd(original_response)
+                    classe_object.cmd(cmd_to_send)
 
         except IndexError as ie:
-            self.Base.logs.error(f"{ie} / {original_response} / length {str(len(original_response))}")
-        except Exception as err:
-            self.Base.logs.error(f"General Error: {err}")
-            self.Base.logs.error(f"General Error: {traceback.format_exc()}")
+            self.Base.logs.error(f"{ie} / {cmd} / length {str(len(cmd))}")
 
     def _hcmds(self, user: str, channel: Union[str, None], cmd:list, fullcmd: list = []) -> None:
-        """_summary_
-
-        Args:
-            user (str): The user who sent the query
-            channel (Union[str, None]): If the command contain the channel
-            cmd (list): The defender cmd
-            fullcmd (list, optional): The full list of the cmd coming from PRIVMS. Defaults to [].
-
-        Returns:
-            None: Nothing to return
-        """
 
         fromuser = self.User.get_nickname(user)                                   # Nickname qui a lancé la commande
         uid = self.User.get_uid(fromuser)                                         # Récuperer le uid de l'utilisateur
@@ -1172,7 +965,7 @@ class Irc:
             case 'notallowed':
                 try:
                     current_command = cmd[0]
-                    self.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.red}{current_command}{self.Config.COLORS.black} ] - Accès Refusé à {self.User.get_nickname(fromuser)}')
+                    self.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR["rouge"]}{current_command}{self.Config.CONFIG_COLOR["noire"]} ] - Accès Refusé à {self.User.get_nickname(fromuser)}')
                     self.send2socket(f':{dnickname} NOTICE {fromuser} : Accès Refusé')
                 except IndexError as ie:
                     self.Base.logs.error(f'{ie}')
@@ -1182,57 +975,7 @@ class Irc:
                 current_command = cmd[0]
                 uid_to_deauth = self.User.get_uid(fromuser)
                 self.delete_db_admin(uid_to_deauth)
-                self.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.red}{str(current_command).upper()} ]{self.Config.COLORS.black} - {self.User.get_nickname(fromuser)} est désormais déconnecter de {dnickname}")
-
-            case 'firstauth':
-                # firstauth OWNER_NICKNAME OWNER_PASSWORD
-                current_nickname = self.User.get_nickname(fromuser)
-                current_uid = self.User.get_uid(fromuser)
-                current_command = str(cmd[0])
-
-                query = f"SELECT count(id) as c FROM {self.Config.table_admin}"
-                result = self.Base.db_execute_query(query)
-                result_db = result.fetchone()
-
-                if result_db[0] > 0:
-                    self.send2socket(f":{dnickname} NOTICE {fromuser} :You can't use this command anymore ! Please use [{self.Config.SERVICE_PREFIX}auth] instead")
-                    return False
-
-                if current_nickname is None:
-                    self.Base.logs.critical(f"This nickname [{fromuser}] don't exist")
-                    return False
-
-                # Credentials sent from the user
-                cmd_owner = str(cmd[1])
-                cmd_password = str(cmd[2])
-
-                # Credentials coming from the Configuration
-                config_owner    = self.Config.OWNER
-                config_password = self.Config.PASSWORD
-
-                if current_nickname != cmd_owner:
-                    self.Base.logs.critical(f"The current nickname [{fromuser}] is different than the nickname sent [{cmd_owner}] !")
-                    self.send2socket(f":{dnickname} NOTICE {fromuser} :The current nickname [{fromuser}] is different than the nickname sent [{cmd_owner}] !")
-                    return False
-
-                if current_nickname != config_owner:
-                    self.Base.logs.critical(f"The current nickname [{current_nickname}] is different than the configuration owner [{config_owner}] !")
-                    self.send2socket(f":{dnickname} NOTICE {fromuser} :The current nickname [{current_nickname}] is different than the configuration owner [{config_owner}] !")
-                    return False
-
-                if cmd_owner != config_owner:
-                    self.Base.logs.critical(f"The nickname sent [{cmd_owner}] is different than the configuration owner [{config_owner}] !")
-                    self.send2socket(f":{dnickname} NOTICE {fromuser} :The nickname sent [{cmd_owner}] is different than the configuration owner [{config_owner}] !")
-                    return False
-
-                if cmd_owner == config_owner and cmd_password == config_password:
-                    self.Base.db_create_first_admin()
-                    self.insert_db_admin(current_uid, 5)
-                    self.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}{str(current_command).upper()} ]{self.Config.COLORS.black} - {self.User.get_nickname(fromuser)} est désormais connecté a {dnickname}")
-                    self.send2socket(f":{self.Config.SERVICE_NICKNAME} NOTICE {fromuser} :Connexion a {dnickname} réussie!")
-                else:
-                    self.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.red}{str(current_command).upper()} ]{self.Config.COLORS.black} - {self.User.get_nickname(fromuser)} a tapé un mauvais mot de pass")
-                    self.send2socket(f":{self.Config.SERVICE_NICKNAME} NOTICE {fromuser} :Mot de passe incorrecte")
+                self.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['rouge']}{current_command}{self.Config.CONFIG_COLOR['noire']} ] - {self.User.get_nickname(fromuser)} est désormais déconnecter de {dnickname}")
 
             case 'auth':
                 # ['auth', 'adator', 'password']
@@ -1254,10 +997,10 @@ class Irc:
                     if not user_from_db is None:
                         uid_user = self.User.get_uid(user_to_log)
                         self.insert_db_admin(uid_user, user_from_db[1])
-                        self.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}{str(current_command).upper()} ]{self.Config.COLORS.black} - {self.User.get_nickname(fromuser)} est désormais connecté a {dnickname}")
+                        self.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}{current_command}{self.Config.CONFIG_COLOR['noire']} ] - {self.User.get_nickname(fromuser)} est désormais connecté a {dnickname}")
                         self.send2socket(f":{self.Config.SERVICE_NICKNAME} NOTICE {fromuser} :Connexion a {dnickname} réussie!")
                     else:
-                        self.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.red}{str(current_command).upper()} ]{self.Config.COLORS.black} - {self.User.get_nickname(fromuser)} a tapé un mauvais mot de pass")
+                        self.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['rouge']}{current_command}{self.Config.CONFIG_COLOR['noire']} ] - {self.User.get_nickname(fromuser)} a tapé un mauvais mot de pass")
                         self.send2socket(f":{self.Config.SERVICE_NICKNAME} NOTICE {fromuser} :Mot de passe incorrecte")
 
                 else:
@@ -1266,10 +1009,6 @@ class Irc:
             case 'addaccess':
                 try:
                     # .addaccess adator 5 password
-                    if len(cmd) < 4:
-                        self.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} addaccess [nickname] [level] [password]')
-                        self.send2socket(f':{dnickname} NOTICE {fromuser} : level: from 1 to 4')
-
                     newnickname = cmd[1]
                     newlevel = self.Base.int_if_possible(cmd[2])
                     password = cmd[3]
@@ -1388,6 +1127,7 @@ class Irc:
 
             case 'help':
 
+                help = ''
                 count_level_definition = 0
                 get_admin = self.Admin.get_Admin(uid)
                 if not get_admin is None:
@@ -1395,49 +1135,100 @@ class Irc:
                 else:
                     user_level = 0
 
-                self.send2socket(f':{dnickname} NOTICE {fromuser} : ***************** LISTE DES COMMANDES *****************')
+                self.send2socket(f':{dnickname} NOTICE {fromuser} : **************** LIST DES COMMANDES *****************')
                 self.send2socket(f':{dnickname} NOTICE {fromuser} : ')
                 for levDef in self.commands_level:
                     
                     if int(user_level) >= int(count_level_definition):
 
-                        self.send2socket(f':{dnickname} NOTICE {fromuser} : ***************** {self.Config.COLORS.nogc}[ {self.Config.COLORS.green}LEVEL {str(levDef)} {self.Config.COLORS.nogc}] *****************')
+                        self.send2socket(f':{dnickname} NOTICE {fromuser} : **************** {self.Config.CONFIG_COLOR["noire"]}[ {self.Config.CONFIG_COLOR["verte"]}LEVEL {str(levDef)} {self.Config.CONFIG_COLOR["noire"]}] ****************')
+                        count_commands = 0
+                        help = ''
+                        for comm in self.commands_level[count_level_definition]:
 
-                        batch = 7
-                        for i in range(0, len(self.commands_level[count_level_definition]), batch):
-                            groupe = self.commands_level[count_level_definition][i:i + batch]  # Extraire le groupe
-                            batch_commands = ' | '.join(groupe)
-                            self.send2socket(f':{dnickname} NOTICE {fromuser} : {batch_commands}')
+                            help += f"{comm.upper()}"
+                            if int(count_commands) < len(self.commands_level[count_level_definition])-1:
+                                help += ' | '
+                            count_commands += 1
 
-                        self.send2socket(f':{dnickname} NOTICE {fromuser} : ')
+                        self.send2socket(f':{dnickname} NOTICE {fromuser} : {help}')
 
                     count_level_definition += 1
 
-                self.send2socket(f':{dnickname} NOTICE {fromuser} : ***************** FIN DES COMMANDES *****************')
+                self.send2socket(f':{dnickname} NOTICE {fromuser} : **************** FIN DES COMMANDES *****************')
 
             case 'load':
-                try:
-                    # Load a module ex: .load mod_defender
-                    mod_name = str(cmd[1])
-                    self.load_module(fromuser, mod_name)
-                except KeyError as ke:
-                    self.Base.logs.error(f"Key Error: {ke} - list recieved: {cmd}")
-                except Exception as err:
-                    self.Base.logs.error(f"General Error: {ke} - list recieved: {cmd}")
+
+                self.load_module(fromuser, str(cmd[1]))
 
             case 'unload':
-                # unload mod_defender
+                # unload mod_dktmb
                 try:
                     module_name = str(cmd[1]).lower()                              # Le nom du module. exemple: mod_defender
-                    self.unload_module(module_name)
-                except Exception as err:
-                    self.Base.logs.error(f"General Error: {err}")
+                    class_name = module_name.split('_')[1].capitalize()            # Nom de la class. exemple: Defender
+
+                    if class_name in self.loaded_classes:
+                        self.loaded_classes[class_name].unload()
+                        for level, command in self.loaded_classes[class_name].commands_level.items():
+                            # Supprimer la commande de la variable commands
+                            for c in self.loaded_classes[class_name].commands_level[level]:
+                                self.commands.remove(c)
+                                self.commands_level[level].remove(c)
+
+                        del self.loaded_classes[class_name]
+
+                        # Supprimer le module de la base de données
+                        self.Base.db_delete_module(module_name)
+
+                        self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} supprimé")
+                except:
+                    self.Base.logs.error(f"Something went wrong with a module you want to load")
 
             case 'reload':
-                # reload mod_defender
+                # reload mod_dktmb
                 try:
                     module_name = str(cmd[1]).lower()                                          # ==> mod_defender
-                    self.reload_module(from_user=fromuser, mod_name=module_name)
+                    class_name = module_name.split('_')[1].capitalize()                        # ==> Defender
+
+                    if 'mods.' + module_name in sys.modules:
+                        self.Base.logs.info('Unload the module ...')
+                        self.loaded_classes[class_name].unload()
+                        self.Base.logs.info('Module Already Loaded ... reloading the module ...')
+                        the_module = sys.modules['mods.' + module_name]
+                        importlib.reload(the_module)
+
+                        # Supprimer la class déja instancier
+                        if class_name in self.loaded_classes:
+                        # Supprimer les commandes déclarer dans la classe
+                            for level, command in self.loaded_classes[class_name].commands_level.items():
+                                # Supprimer la commande de la variable commands
+                                for c in self.loaded_classes[class_name].commands_level[level]:
+                                    self.commands.remove(c)
+                                    self.commands_level[level].remove(c)
+
+                            del self.loaded_classes[class_name]
+
+                        my_class = getattr(the_module, class_name, None)
+                        new_instance = my_class(self.ircObject)
+                        self.loaded_classes[class_name] = new_instance
+
+                        self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} rechargé")
+                        return False
+                    else:
+                        self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} n'est pas chargé !")
+
+                except TypeError as te:
+                    self.Base.logs.error(f"A TypeError raised: {te}")
+                    self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :A TypeError raised: {te}")
+                    self.Base.db_delete_module(module_name)
+                except AttributeError as ae:
+                    self.Base.logs.error(f"Missing Attribute: {ae}")
+                    self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Missing Attribute: {ae}")
+                    self.Base.db_delete_module(module_name)
+                except KeyError as ke:
+                    self.Base.logs.error(f"Key Error: {ke}")
+                    self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Key Error: {ke}")
+                    self.Base.db_delete_module(module_name)
                 except Exception as e:
                     self.Base.logs.error(f"Something went wrong with a module you want to reload: {e}")
                     self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Something went wrong with the module: {e}")
@@ -1488,23 +1279,30 @@ class Irc:
 
                 self.Base.logs.debug(self.loaded_classes)
                 all_modules  = self.Base.get_all_modules()
-                loaded = False
 
-                results = self.Base.db_execute_query(f'SELECT datetime, user, module_name FROM {self.Config.table_module}')
+                results = self.Base.db_execute_query(f'SELECT module_name FROM {self.Config.table_module}')
                 results = results.fetchall()
 
+                # if len(results) == 0:
+                #     self.send2socket(f":{dnickname} NOTICE {fromuser} :There is no module loaded")
+                #     return False
+
+                found = False
+
                 for module in all_modules:
                     for loaded_mod in results:
-                        if module == loaded_mod[2]:
-                            loaded_datetime = loaded_mod[0]
-                            loaded_user = loaded_mod[1]
-                            loaded = True
+                        if module == loaded_mod[0]:
+                            found = True
 
-                    if loaded:
-                        self.send2socket(f":{dnickname} NOTICE {fromuser} :{module} - {self.Config.COLORS.green}Loaded{self.Config.COLORS.nogc} by {loaded_user} on {loaded_datetime}")
-                        loaded = False
+                    if found:
+                        self.send2socket(f":{dnickname} NOTICE {fromuser} :{module} - {self.Config.CONFIG_COLOR['verte']}Loaded{self.Config.CONFIG_COLOR['nogc']}")
                     else:
-                        self.send2socket(f":{dnickname} NOTICE {fromuser} :{module} - {self.Config.COLORS.red}Not Loaded{self.Config.COLORS.nogc}")
+                        self.send2socket(f":{dnickname} NOTICE {fromuser} :{module} - {self.Config.CONFIG_COLOR['rouge']}Not Loaded{self.Config.CONFIG_COLOR['nogc']}")
+
+                    found = False
+
+                # for r in results:
+                #     self.send2socket(f":{dnickname} NOTICE {fromuser} :{r[0]} - {self.Config.CONFIG_COLOR['verte']}Loaded{self.Config.CONFIG_COLOR['nogc']}")
 
             case 'show_timers':
 
@@ -1532,7 +1330,7 @@ class Irc:
 
             case 'show_users':
                 for db_user in self.User.UID_DB:
-                    self.send2socket(f":{dnickname} NOTICE {fromuser} :UID : {db_user.uid} - isWebirc: {db_user.isWebirc} - isWebSocket: {db_user.isWebsocket} - Nickname: {db_user.nickname} - Connection: {db_user.connexion_datetime}")
+                    self.send2socket(f":{dnickname} NOTICE {fromuser} :UID : {db_user.uid} - isWebirc: {db_user.isWebirc} - Nickname: {db_user.nickname} - Connection: {db_user.connexion_datetime}")
 
             case 'show_admins':
                 for db_admin in self.Admin.UID_ADMIN_DB:
@@ -1543,7 +1341,7 @@ class Irc:
                 self.send2socket(f':{dnickname} NOTICE {fromuser} : {uptime}')
 
             case 'copyright':
-                self.send2socket(f':{dnickname} NOTICE {fromuser} : # Defender V.{self.Config.current_version} Developped by adator® #')
+                self.send2socket(f':{dnickname} NOTICE {fromuser} : # Defender V.{self.Config.current_version} Developped by adator® and dktmb® #')
 
             case 'checkversion':
 

core/loadConf.py

@@ -1,5 +1,4 @@
-import sys
-import json
+import json, sys
 from os import sep
 from typing import Union, Literal
 from dataclasses import dataclass, field
@@ -8,17 +7,6 @@ from dataclasses import dataclass, field
 #   CONFIGURATION FILE                   #
 ##########################################
 
-@dataclass
-class ColorModel:
-    white: str  = "\x0300"
-    black: str  = "\x0301"
-    blue: str   = "\x0302"
-    green: str  = "\x0303"
-    red: str    = "\x0304"
-    yellow: str = "\x0306"
-    bold: str   = "\x02"
-    nogc: str   = "\x03"
-
 @dataclass
 class ConfigDataModel:
 
@@ -85,21 +73,6 @@ class ConfigDataModel:
     PASSWORD: str
     """The password of the admin of the service"""
 
-    JSONRPC_URL: str
-    """The RPC url, if local https://127.0.0.1:PORT/api should be fine"""
-
-    JSONRPC_PATH_TO_SOCKET_FILE: str
-    """The full path of the socket file (/PATH/TO/YOUR/UNREALIRCD/SOCKET/FILE.socket)"""
-
-    JSONRPC_METHOD: str
-    """3 methods are available; requests/socket/unixsocket"""
-
-    JSONRPC_USER: str
-    """The RPC User defined in your unrealircd.conf"""
-
-    JSONRPC_PASSWORD: str
-    """The RPC Password defined in your unrealircd.conf"""
-
     SALON_JAIL: str
     """The JAIL channel (ex. #jail)"""
 
@@ -109,18 +82,6 @@ class ConfigDataModel:
     SALON_LIBERER: str
     """Channel where the nickname will be released"""
 
-    CLONE_CHANNEL: str
-    """Channel where clones are hosted and will log PRIVMSG"""
-
-    CLONE_CMODES: str
-    """Clone channel modes"""
-
-    CLONE_LOG_HOST_EXEMPT: list[str]
-    """Hosts that clones will not log"""
-
-    CLONE_CHANNEL_PASSWORD: str
-    """Clone password channel"""
-
     API_TIMEOUT: int
     """Default api timeout in second"""
 
@@ -133,9 +94,11 @@ class ConfigDataModel:
     GLINE_DURATION: str
     """Gline duration"""
 
-    DEBUG_LEVEL:Literal[10, 20, 30, 40, 50]
+    DEBUG_LEVEL:Literal[10, 20, 30, 40, 50]                                         # Le niveau des logs DEBUG 10 | INFO 20 | WARNING 30 | ERROR 40 | CRITICAL 50
     """Logs level: DEBUG 10 | INFO 20 | WARNING 30 | ERROR 40 | CRITICAL 50"""
 
+    CONFIG_COLOR: dict[str, str]
+
     table_admin: str
     """Admin table"""
 
@@ -166,12 +129,6 @@ class ConfigDataModel:
     db_path: str
     """The database path"""
 
-    COLORS: ColorModel = field(default_factory=ColorModel)
-    """Available colors in Defender"""
-
-    BATCH_SIZE: int = 400
-    """The batch size used for privmsg and notice"""
-
     def __post_init__(self):
         # Initialiser SERVICE_ID après la création de l'objet
         self.SERVICE_ID:str = f"{self.SERVEUR_ID}AAAAAB"
@@ -190,61 +147,49 @@ class Config:
             with open(conf_filename, 'r') as configuration_data:
                 configuration:dict[str, Union[str, int, list, dict]] = json.load(configuration_data)
 
+            for key, value in configuration['CONFIG_COLOR'].items():
+                configuration['CONFIG_COLOR'][key] = str(value).encode('utf-8').decode('unicode_escape')
+
             return configuration
 
         except FileNotFoundError as fe:
             print(f'FileNotFound: {fe}')
             print('Configuration file not found please create core/configuration.json')
             sys.exit(0)
-        except KeyError as ke:
-            print(f'Key Error: {ke}')
-            print('The key must be defined in core/configuration.json')
 
     def __load_service_configuration(self) -> ConfigDataModel:
         import_config = self.__load_json_service_configuration()
 
         ConfigObject: ConfigDataModel = ConfigDataModel(
-            SERVEUR_IP=import_config["SERVEUR_IP"] if "SERVEUR_IP" in import_config else '127.0.0.1',
-            SERVEUR_HOSTNAME=import_config["SERVEUR_HOSTNAME"] if "SERVEUR_HOSTNAME" in import_config else None,
-            SERVEUR_LINK=import_config["SERVEUR_LINK"] if "SERVEUR_LINK" in import_config else None,
-            SERVEUR_PORT=import_config["SERVEUR_PORT"] if "SERVEUR_PORT" in import_config else 6667,
-            SERVEUR_PASSWORD=import_config["SERVEUR_PASSWORD"] if "SERVEUR_PASSWORD" in import_config else None,
-            SERVEUR_ID=import_config["SERVEUR_ID"] if "SERVEUR_ID" in import_config else '19Z',
-            SERVEUR_SSL=import_config["SERVEUR_SSL"] if "SERVEUR_SSL" in import_config else False,
-            SERVICE_NAME=import_config["SERVICE_NAME"] if "SERVICE_NAME" in import_config else 'Defender',
-            SERVICE_NICKNAME=import_config["SERVICE_NICKNAME"] if "SERVICE_NICKNAME" in import_config else 'Defender',
-            SERVICE_REALNAME=import_config["SERVICE_REALNAME"] if "SERVICE_REALNAME" in import_config else 'Defender Security',
-            SERVICE_USERNAME=import_config["SERVICE_USERNAME"] if "SERVICE_USERNAME" in import_config else 'IRCSecurity',
-            SERVICE_HOST=import_config["SERVICE_HOST"] if "SERVICE_HOST" in import_config else 'defender.local.network',
-            SERVICE_INFO=import_config["SERVICE_INFO"] if "SERVICE_INFO" in import_config else 'Defender Network IRC Service',
-            SERVICE_CHANLOG=import_config["SERVICE_CHANLOG"] if "SERVICE_CHANLOG" in import_config else '#services',
-            SERVICE_SMODES=import_config["SERVICE_SMODES"] if "SERVICE_SMODES" in import_config else '+ioqBS',
-            SERVICE_CMODES=import_config["SERVICE_CMODES"] if "SERVICE_CMODES" in import_config else 'ntsOP',
-            SERVICE_UMODES=import_config["SERVICE_UMODES"] if "SERVICE_UMODES" in import_config else 'o',
-            SERVICE_PREFIX=import_config["SERVICE_PREFIX"] if "SERVICE_PREFIX" in import_config else '!',
-            OWNER=import_config["OWNER"] if "OWNER" in import_config else 'admin',
-            PASSWORD=import_config["PASSWORD"] if "PASSWORD" in import_config else 'admin',
-
-            JSONRPC_METHOD=import_config["JSONRPC_METHOD"] if "JSONRPC_METHOD" in import_config else 'socket',
-            JSONRPC_URL=import_config["JSONRPC_URL"] if "JSONRPC_URL" in import_config else None,
-            JSONRPC_PATH_TO_SOCKET_FILE=import_config["JSONRPC_PATH_TO_SOCKET_FILE"] if "JSONRPC_PATH_TO_SOCKET_FILE" in import_config else None,
-            JSONRPC_USER=import_config["JSONRPC_USER"] if "JSONRPC_USER" in import_config else None,
-            JSONRPC_PASSWORD=import_config["JSONRPC_PASSWORD"] if "JSONRPC_PASSWORD" in import_config else None,
-
-            SALON_JAIL=import_config["SALON_JAIL"] if "SALON_JAIL" in import_config else '#jail',
-            SALON_JAIL_MODES=import_config["SALON_JAIL_MODES"] if "SALON_JAIL_MODES" in import_config else 'sS',
-            SALON_LIBERER=import_config["SALON_LIBERER"] if "SALON_LIBERER" in import_config else '#welcome',
-
-            CLONE_CHANNEL=import_config["CLONE_CHANNEL"] if "CLONE_CHANNEL" in import_config else '#clones',
-            CLONE_CMODES=import_config["CLONE_CMODES"] if "CLONE_CMODES" in import_config else '+nts',
-            CLONE_LOG_HOST_EXEMPT=import_config["CLONE_LOG_HOST_EXEMPT"] if "CLONE_LOG_HOST_EXEMPT" in import_config else [],
-            CLONE_CHANNEL_PASSWORD=import_config["CLONE_CHANNEL_PASSWORD"] if "CLONE_CHANNEL_PASSWORD" in import_config else "clone_Password_1234",
-
-            API_TIMEOUT=import_config["API_TIMEOUT"] if "API_TIMEOUT" in import_config else 2,
-            PORTS_TO_SCAN=import_config["PORTS_TO_SCAN"] if "PORTS_TO_SCAN" in import_config else [],
-            WHITELISTED_IP=import_config["WHITELISTED_IP"] if "WHITELISTED_IP" in import_config else ['127.0.0.1'],
-            GLINE_DURATION=import_config["GLINE_DURATION"] if "GLINE_DURATION" in import_config else '30',
-            DEBUG_LEVEL=import_config["DEBUG_LEVEL"] if "DEBUG_LEVEL" in import_config else 20,
+            SERVEUR_IP=import_config["SERVEUR_IP"],
+            SERVEUR_HOSTNAME=import_config["SERVEUR_HOSTNAME"],
+            SERVEUR_LINK=import_config["SERVEUR_LINK"],
+            SERVEUR_PORT=import_config["SERVEUR_PORT"],
+            SERVEUR_PASSWORD=import_config["SERVEUR_PASSWORD"],
+            SERVEUR_ID=import_config["SERVEUR_ID"],
+            SERVEUR_SSL=import_config["SERVEUR_SSL"],
+            SERVICE_NAME=import_config["SERVICE_NAME"],
+            SERVICE_NICKNAME=import_config["SERVICE_NICKNAME"],
+            SERVICE_REALNAME=import_config["SERVICE_REALNAME"],
+            SERVICE_USERNAME=import_config["SERVICE_USERNAME"],
+            SERVICE_HOST=import_config["SERVICE_HOST"],
+            SERVICE_INFO=import_config["SERVICE_INFO"],
+            SERVICE_CHANLOG=import_config["SERVICE_CHANLOG"],
+            SERVICE_SMODES=import_config["SERVICE_SMODES"],
+            SERVICE_CMODES=import_config["SERVICE_CMODES"],
+            SERVICE_UMODES=import_config["SERVICE_UMODES"],
+            SERVICE_PREFIX=import_config["SERVICE_PREFIX"],
+            OWNER=import_config["OWNER"],
+            PASSWORD=import_config["PASSWORD"],
+            SALON_JAIL=import_config["SALON_JAIL"],
+            SALON_JAIL_MODES=import_config["SALON_JAIL_MODES"],
+            SALON_LIBERER=import_config["SALON_LIBERER"],
+            API_TIMEOUT=import_config["API_TIMEOUT"],
+            PORTS_TO_SCAN=import_config["PORTS_TO_SCAN"],
+            WHITELISTED_IP=import_config["WHITELISTED_IP"],
+            GLINE_DURATION=import_config["GLINE_DURATION"],
+            DEBUG_LEVEL=import_config["DEBUG_LEVEL"],
+            CONFIG_COLOR=import_config["CONFIG_COLOR"],
             table_admin='core_admin',
             table_commande='core_command',
             table_log='core_log',

mods/mod_clone.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, fields, field
-import random, faker, time, logging
+import random, faker, time
 from datetime import datetime
 from typing import Union
 from core.irc import Irc
@@ -58,12 +58,6 @@ class Clone():
         # Load module configuration (Mandatory)
         self.__load_module_configuration()
 
-        self.Base.db_query_channel(action='add', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL)
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} JOIN {self.Config.CLONE_CHANNEL}")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} SAMODE {self.Config.CLONE_CHANNEL} +o {self.Config.SERVICE_NICKNAME}")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} +nts")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} +k {self.Config.CLONE_CHANNEL_PASSWORD}")
-
     def __set_commands(self, commands:dict[int, list[str]]) -> None:
         """### Rajoute les commandes du module au programme principal
 
@@ -126,141 +120,53 @@ class Clone():
         for clone in self.ModConfig.clone_nicknames:
             self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone} :KILL')
 
-        self.Base.db_query_channel(action='del', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL)
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -nts")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -k {self.Config.CLONE_CHANNEL_PASSWORD}")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} PART {self.Config.CLONE_CHANNEL}")
         return None
 
-    def thread_clone_clean_up(self, wait: float):
+    def thread_create_clones(self, nickname: str, username: str, channels: list, server_port: int, ssl: bool) -> None:
 
-        activated = True
-
-        while activated:
-            clone_to_kill: list[str] = []
-
-            for clone in self.Clone.UID_CLONE_DB:
-                if not clone.connected and clone.alive and not clone.init:
-                    clone_to_kill.append(clone.nickname)
-                    clone.alive = False
-
-            for clone_nickname in clone_to_kill:
-                if self.Clone.delete(clone_nickname):
-                    self.Logs.debug(f'<<{clone_nickname}>> object has been deleted')
-
-            del clone_to_kill
-
-            # If no more clones then stop this thread
-            if not self.Clone.UID_CLONE_DB:
-                break
-
-            time.sleep(wait)
-
-    def thread_change_hostname(self):
-
-        fake = faker.Faker('en_GB')
-        for clone in self.Clone.UID_CLONE_DB:
-            if not clone.vhost is None:
-                continue
-
-            rand_1 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
-            rand_2 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
-            rand_3 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
-
-            rand_ip = ''.join(rand_1) + '.' + ''.join(rand_2) + '.' + ''.join(rand_3) + '.IP'
-            found = False
-
-            while not found:
-                if clone.connected:
-                    self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} CHGHOST {clone.nickname} {rand_ip}')
-                    found = True
-                    clone.vhost = rand_ip
-                    break
-                if not clone in self.Clone.UID_CLONE_DB:
-                    found = True
-                    break
-
-    def thread_create_clones_with_interval(self, number_of_clones:int, channels: list, connection_interval: float):
-
-        for i in range(number_of_clones):
-            nickname, username, realname = self.generate_names()
-            self.Base.create_thread(
-                self.thread_create_clones,
-                (nickname, username, realname, channels, 6697, True)
-                )
-            time.sleep(connection_interval)
-
-        self.Base.create_thread(
-            self.thread_change_hostname
-        )
-
-        # self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :{str(number_of_clones)} clones joined the network')
-
-        self.Base.create_thread(self.thread_clone_clean_up, (5, ), run_once=True)
-
-    def thread_create_clones(self, nickname: str, username: str, realname: str, channels: list, server_port: int, ssl: bool) -> None:
-
-        Connection(server_port=server_port, nickname=nickname, username=username, realname=realname, channels=channels, CloneObject=self.Clone, ssl=ssl)
+        Connection(server_port=server_port, nickname=nickname, username=username, channels=channels, CloneObject=self.Clone, ssl=ssl)
 
         return None
 
     def thread_join_channels(self, channel_name: str, wait: float, clone_name:str = None):
-        self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Clones start to join {channel_name} with {wait} secondes frequency')
+
         if clone_name is None:
             for clone in self.Clone.UID_CLONE_DB:
-                if not channel_name in clone.channels:
-                    time.sleep(wait)
                 self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
-                    clone.channels.append(channel_name)
+                time.sleep(wait)
         else:
             for clone in self.Clone.UID_CLONE_DB:
                 if clone_name == clone.nickname:
-                    if not channel_name in clone.channels:
-                        time.sleep(wait)
                     self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
-                        clone.channels.append(channel_name)
+                    time.sleep(wait)
 
-    def generate_names(self) -> tuple[str, str, str]:
+    def generate_names(self) -> tuple[str, str]:
         try:
-            logging.getLogger('faker').setLevel(logging.CRITICAL)
             fake = faker.Faker('en_GB')
-            # nickname = fake.first_name()
-            # username = fake.last_name()
-
-            # Generate Username
-            chaine = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
-            new_username = fake.random_sample(chaine, 9)
-            username = ''.join(new_username)
-
-            # Create realname XX F|M Department
-            gender = fake.random_choices(['F','M'], 1)
-            gender = ''.join(gender)
-            
-            if gender == 'F':
-                nickname = fake.first_name_female()
-            elif gender == 'M':
-                nickname = fake.first_name_male()
-            else:
             nickname = fake.first_name()
-
-            age = random.randint(20, 60)
-            fake_fr = faker.Faker(['fr_FR', 'en_GB'])
-            department = fake_fr.department_name()
-            realname = f'{age} {gender} {department}'
+            username = fake.last_name()
 
             if self.Clone.exists(nickname=nickname):
                 caracteres = '0123456789'
                 randomize = ''.join(random.choice(caracteres) for _ in range(2))
                 nickname = nickname + str(randomize)
                 self.Clone.insert(
-                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username, realname=realname, channels=[])
+                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username)
                     )
             else:
                 self.Clone.insert(
-                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username, realname=realname, channels=[])
+                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username)
                     )
 
-            return (nickname, username, realname)
+            # if not nickname in self.ModConfig.clone_nicknames:
+            #     self.ModConfig.clone_nicknames.append(nickname)
+            # else:
+            #     caracteres = '0123456789'
+            #     randomize = ''.join(random.choice(caracteres) for _ in range(2))
+            #     nickname = nickname + str(randomize)
+            #     self.ModConfig.clone_nicknames.append(nickname)
+
+            return (nickname, username)
 
         except AttributeError as ae:
             self.Logs.error(f'Attribute Error : {ae}')
@@ -282,7 +188,6 @@ class Clone():
 
     def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
 
-        try:
         command = str(cmd[0]).lower()
         fromuser = user
 
@@ -291,31 +196,31 @@ class Clone():
         match command:
 
             case 'clone':
+                option = str(cmd[1]).lower()
 
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect 6 2.5')
+                if len(command) == 1:
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect 6')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill [all | nickname]')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join [all | nickname] #channel')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone list')
 
-                    option = str(cmd[1]).lower()
-
                 match option:
 
                     case 'connect':
                         try:
-                                # clone connect 5
                             number_of_clones = int(cmd[2])
-                                connection_interval = int(cmd[3]) if len(cmd) == 4 else 0.5
+                            for i in range(number_of_clones):
+                                nickname, username = self.generate_names()
                                 self.Base.create_thread(
-                                    self.thread_create_clones_with_interval,
-                                    (number_of_clones, [], connection_interval)
+                                    self.thread_create_clones,
+                                    (nickname, username, [], 6697, True)
                                     )
 
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :{str(number_of_clones)} clones joined the network')
                         except Exception as err:
                             self.Logs.error(f'{err}')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect [number of clone you want to connect] [Connection Interval]')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} clone connect 6 2.5')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect [number of clone you want to connect]')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} clone connect 6')
 
                     case 'kill':
                         try:
@@ -363,10 +268,9 @@ class Clone():
 
                     case 'list':
                         try:
-                                clone_count = len(self.Clone.UID_CLONE_DB)
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :>> Number of connected clones: {clone_count}')
                             for clone_name in self.Clone.UID_CLONE_DB:
-                                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :>> Nickname: {clone_name.nickname} | Username: {clone_name.username} | Realname: {clone_name.realname} | Vhost: {clone_name.vhost} | Init: {clone_name.init} | Live: {clone_name.alive} | Connected: {clone_name.connected}')
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :>> {clone_name.nickname} | {clone_name.username}')
+                            pass
                         except Exception as err:
                             self.Logs.error(f'{err}')
 
@@ -398,7 +302,3 @@ class Clone():
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join [all | nickname] #channel')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel [message]')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone list')
-        except IndexError as ie:
-            self.Logs.error(f'Index Error: {ie}')
-        except Exception as err:
-            self.Logs.error(f'Index Error: {err}')

mods/mod_command.py

@@ -35,14 +35,7 @@ class Command():
         # Create module commands (Mandatory)
         self.commands_level = {
             1: ['join', 'part'],
-            2: ['owner', 'deowner', 'protect', 'deprotect', 'op', 'deop', 'halfop', 'dehalfop', 'voice', 
-                'devoice', 'opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 
-                'unban','kick', 'kickban', 'umode', 'mode', 'svsjoin', 'svspart', 'svsnick', 'topic',
-                'wallops', 'globops','gnotice','whois', 'names', 'invite', 'inviteme',
-                'sajoin', 'sapart', 
-                'kill', 'gline', 'ungline', 'kline', 'unkline', 'shun', 'unshun', 
-                'glinelist', 'shunlist', 'klinelist'],
-            3: ['map']
+            2: ['owner', 'deowner', 'op', 'deop', 'halfop', 'dehalfop', 'voice', 'devoice', 'opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 'unban','kick', 'kickban', 'umode']
         }
 
         # Init the module
@@ -63,9 +56,6 @@ class Command():
         self.__load_module_configuration()
         # End of mandatory methods you can start your customization #
 
-        self.user_to_notice: str = ''
-        self.show_219: bool = True
-
         return None
 
     def __set_commands(self, commands:dict[int, list[str]]) -> None:
@@ -99,7 +89,7 @@ class Command():
             )
         '''
 
-        # self.Base.db_execute_query(table_logs)
+        self.Base.db_execute_query(table_logs)
         return None
 
     def __load_module_configuration(self) -> None:
@@ -130,81 +120,45 @@ class Command():
 
         return None
 
+    def add_defender_channel(self, channel:str) -> bool:
+        """Cette fonction ajoute les salons de join de Defender
+
+        Args:
+            channel (str): le salon à enregistrer.
+        """
+        mes_donnees = {'channel': channel}
+        response = self.Base.db_execute_query("SELECT id FROM def_channels WHERE channel = :channel", mes_donnees)
+        
+        isChannelExist = response.fetchone()
+
+        if isChannelExist is None:
+            mes_donnees = {'datetime': self.Base.get_datetime(), 'channel': channel}
+            insert = self.Base.db_execute_query(f"INSERT INTO def_channels (datetime, channel) VALUES (:datetime, :channel)", mes_donnees)
+            if insert.rowcount >=0:
+                return True
+            else:
+                return False
+        else:
+            return False
+
+    def delete_defender_channel(self, channel:str) -> bool:
+        """Cette fonction supprime les salons de join de Defender
+
+        Args:
+            channel (str): le salon à enregistrer.
+        """
+        mes_donnes = {'channel': channel}
+        response = self.Base.db_execute_query("DELETE FROM def_channels WHERE channel = :channel", mes_donnes)
+        
+        affected_row = response.rowcount
+
+        if affected_row > 0:
+            return True
+        else:
+            return False
+
     def cmd(self, data:list) -> None:
 
-        service_id = self.Config.SERVICE_ID
-        dnickname = self.Config.SERVICE_NICKNAME
-        dchanlog = self.Config.SERVICE_CHANLOG
-        red = self.Config.COLORS.red
-        green = self.Config.COLORS.green
-        bold = self.Config.COLORS.bold
-        nogc = self.Config.COLORS.nogc
-        cmd = list(data).copy()
-
-        if len(cmd) < 2:
-            return None
-
-        match cmd[1]:
-            # [':irc.deb.biz.st', '403', 'Dev-PyDefender', '#Z', ':No', 'such', 'channel']
-            case '403' | '401':
-                try:
-                    message = ' '.join(cmd[3:])
-                    self.Irc.send2socket(f":{dnickname} NOTICE {self.user_to_notice} :[{red}ERROR MSG{nogc}] {message}")
-                    self.Base.logs.error(f"{cmd[1]} - {message}")
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case '006' | '018':
-                try:
-                    # [':irc.deb.biz.st', '006', 'Dev-PyDefender', ':`-services.deb.biz.st', '------', '|', 'Users:', '9', '(47.37%)', '[00B]']
-                    # [':irc.deb.biz.st', '018', 'Dev-PyDefender', ':4', 'servers', 'and', '19', 'users,', 'average', '4.75', 'users', 'per', 'server']
-                    message = ' '.join(cmd[3:])
-                    self.Irc.send2socket(f":{dnickname} NOTICE {self.user_to_notice} : [{green}SERVER MSG{nogc}] {message}")
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case '219':
-                try:
-                    # [':irc.deb.biz.st', '219', 'Dev-PyDefender', 's', ':End', 'of', '/STATS', 'report']
-                    if not self.show_219:
-                        # If there is a result in 223 then stop here
-                        self.show_219 = True
-                        return None
-
-                    type_of_stats = str(cmd[3])
-
-                    match type_of_stats:
-                        case 's':
-                            self.Irc.send2socket(f":{dnickname} NOTICE {self.user_to_notice} : No shun")
-                        case 'G':
-                            self.Irc.send2socket(f":{dnickname} NOTICE {self.user_to_notice} : No gline")
-                        case 'k':
-                            self.Irc.send2socket(f":{dnickname} NOTICE {self.user_to_notice} : No kline")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case '223':
-                try:
-                    # [':irc.deb.biz.st', '223', 'Dev-PyDefender', 'G', '*@162.142.125.217', '67624', '18776', 'irc.deb.biz.st', ':Proxy/Drone', 'detected.', 'Check', 'https://dronebl.org/lookup?ip=162.142.125.217', 'for', 'details.']
-                    self.show_219 = False
-                    host = str(cmd[4])
-                    author = str(cmd[7])
-                    reason = ' '.join(cmd[8:])
-
-                    self.Irc.send2socket(f":{dnickname} NOTICE {self.user_to_notice} : {bold}Author{nogc}: {author} - {bold}Host{nogc}: {host} - {bold}Reason{nogc}: {reason}")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
         return None
 
     def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
@@ -213,7 +167,6 @@ class Command():
         dnickname = self.Config.SERVICE_NICKNAME
         service_id = self.Config.SERVICE_ID
         dchanlog = self.Config.SERVICE_CHANLOG
-        self.user_to_notice = user
         fromuser = user
         fromchannel = channel
 
@@ -225,8 +178,6 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OP: {str(e)}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'devoiceall':
                 try:
@@ -234,11 +185,8 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OP: {str(e)}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'voiceall':
-                try:
                 chan_info = self.Channel.get_Channel(fromchannel)
                 set_mode = 'v'
                 mode:str = ''
@@ -254,13 +202,8 @@ class Command():
                             self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{mode} {users}")
                             mode = ''
                             users = ''
-                except IndexError as e:
-                    self.Logs.warning(f'_hcmd OP: {str(e)}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'opall':
-                try:
                 chan_info = self.Channel.get_Channel(fromchannel)
                 set_mode = 'o'
                 mode:str = ''
@@ -276,10 +219,6 @@ class Command():
                             self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{mode} {users}")
                             mode = ''
                             users = ''
-                except IndexError as e:
-                    self.Logs.warning(f'_hcmd OP: {str(e)}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'op':
                 # /mode #channel +o user
@@ -307,8 +246,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OP: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} op [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'deop':
                 # /mode #channel -o user
@@ -334,8 +271,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEOP: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} deop [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'owner':
                 # /mode #channel +q user
@@ -361,8 +296,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OWNER: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} owner [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'deowner':
                 # /mode #channel -q user
@@ -388,62 +321,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEOWNER: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} deowner [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'protect':
-                # /mode #channel +a user
-                # .protect #channel user
-                try:
-                    if fromchannel is None:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]')
-                        return False
-
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} +a {fromuser}")
-                        return True
-
-                    # deowner nickname
-                    if len(cmd) == 2:
-                        nickname = cmd[1]
-                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} +a {nickname}")
-                        return True
-
-                    nickname = cmd[2]
-                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} +a {nickname}")
-
-                except IndexError as e:
-                    self.Logs.warning(f'_hcmd DEOWNER: {str(e)}')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'deprotect':
-                # /mode #channel -a user
-                # .deprotect #channel user
-                try:
-                    if fromchannel is None:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]')
-                        return False
-
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -a {fromuser}")
-                        return True
-
-                    # deowner nickname
-                    if len(cmd) == 2:
-                        nickname = cmd[1]
-                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -a {nickname}")
-                        return True
-
-                    nickname = cmd[2]
-                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} -a {nickname}")
-
-                except IndexError as e:
-                    self.Logs.warning(f'_hcmd DEOWNER: {str(e)}')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'halfop':
                 # /mode #channel +h user
@@ -469,8 +346,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd halfop: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} halfop [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'dehalfop':
                 # /mode #channel -h user
@@ -496,8 +371,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEHALFOP: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} dehalfop [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'voice':
                 # /mode #channel +v user
@@ -523,8 +396,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd VOICE: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} voice [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'devoice':
                 # /mode #channel -v user
@@ -550,15 +421,13 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEVOICE: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} devoice [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'ban':
                 # .ban #channel nickname
                 try:
                     sentchannel = str(cmd[1]) if self.Base.Is_Channel(cmd[1]) else None
                     if sentchannel is None:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]')
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} ban [#SALON] [NICKNAME]')
                         return False
 
                     nickname = cmd[2]
@@ -567,9 +436,7 @@ class Command():
                     self.Logs.debug(f'{fromuser} has banned {nickname} from {sentchannel}')
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd BAN: {str(e)}')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} ban [#SALON] [NICKNAME]')
 
             case 'unban':
                 # .unban #channel nickname
@@ -582,12 +449,9 @@ class Command():
 
                     self.Irc.send2socket(f":{service_id} MODE {sentchannel} -b {nickname}!*@*")
                     self.Logs.debug(f'{fromuser} has unbanned {nickname} from {sentchannel}')
-
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd UNBAN: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} unban [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'kick':
                 # .kick #channel nickname reason
@@ -606,12 +470,9 @@ class Command():
 
                     self.Irc.send2socket(f":{service_id} KICK {sentchannel} {nickname} {final_reason}")
                     self.Logs.debug(f'{fromuser} has kicked {nickname} from {sentchannel} : {final_reason}')
-
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd KICK: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} kick [#SALON] [NICKNAME] [REASON]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'kickban':
                 # .kickban #channel nickname reason
@@ -631,12 +492,9 @@ class Command():
                     self.Irc.send2socket(f":{service_id} KICK {sentchannel} {nickname} {final_reason}")
                     self.Irc.send2socket(f":{service_id} MODE {sentchannel} +b {nickname}!*@*")
                     self.Logs.debug(f'{fromuser} has kicked and banned {nickname} from {sentchannel} : {final_reason}')
-
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd KICKBAN: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} kickban [#SALON] [NICKNAME] [REASON]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'join':
 
@@ -652,8 +510,6 @@ class Command():
 
                 except IndexError as ie:
                     self.Logs.error(f'{ie}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'part':
 
@@ -673,176 +529,6 @@ class Command():
 
                 except IndexError as ie:
                     self.Logs.error(f'{ie}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'topic':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
-                        return None
-
-                    chan = str(cmd[1])
-                    if not self.Base.Is_Channel(chan):
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The channel must start with #")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
-                        return None
-
-                    topic_msg = ' '.join(cmd[2:]).strip()
-
-                    if topic_msg:
-                        self.Irc.send2socket(f':{dnickname} TOPIC {chan} :{topic_msg}')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the topic")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'wallops':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} WALLOPS THE_WALLOPS_MESSAGE")
-                        return None
-
-                    wallops_msg = ' '.join(cmd[1:]).strip()
-
-                    if wallops_msg:
-                        self.Irc.send2socket(f':{dnickname} WALLOPS {wallops_msg} ({dnickname})')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the wallops message")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'globops':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} GLOBOPS THE_GLOBOPS_MESSAGE")
-                        return None
-
-                    globops_msg = ' '.join(cmd[1:]).strip()
-
-                    if globops_msg:
-                        self.Irc.send2socket(f':{dnickname} GLOBOPS {globops_msg} ({dnickname})')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the globops message")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'gnotice':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} THE_GLOBAL_NOTICE_MESSAGE")
-                        return None
-
-                    gnotice_msg = ' '.join(cmd[1:]).strip()
-
-                    if gnotice_msg:
-                        self.Irc.send2socket(f':{dnickname} NOTICE $*.* :[{self.Config.COLORS.red}GLOBAL NOTICE{self.Config.COLORS.nogc}] {gnotice_msg}')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the global notice message")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'whois':
-                try:
-                    self.user_to_notice = fromuser
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
-                        return None
-
-                    nickname = str(cmd[1])
-
-                    if self.User.get_nickname(nickname) is None:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :Nickname not found !")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} WHOIS {nickname}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'names':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #CHANNEL")
-                        return None
-
-                    chan = str(cmd[1])
-
-                    if not self.Base.Is_Channel(chan):
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The channel must start with #")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #channel")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} NAMES {chan}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'invite':
-                try:
-                    if len(cmd) < 3:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #CHANNEL NICKNAME")
-                        return None
-
-                    chan = str(cmd[1])
-                    nickname = str(cmd[2])
-
-                    if not self.Base.Is_Channel(chan):
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The channel must start with #")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #channel nickname")
-                        return None
-
-                    if self.User.get_nickname(nickname) is None:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :Nickname not found !")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #channel NICKNAME")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} INVITE {nickname} {chan}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'inviteme':
-                try:
-                    if len(cmd) == 0:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()}")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} INVITE {fromuser} {self.Config.SERVICE_CHANLOG}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'map':
-                try:
-                    self.user_to_notice = fromuser
-                    self.Irc.send2socket(f':{dnickname} MAP')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'umode':
                 try:
@@ -850,318 +536,6 @@ class Command():
                     nickname = str(cmd[1])
                     umode = str(cmd[2])
 
-                    self.Irc.send2socket(f':{dnickname} SVSMODE {nickname} {umode}')
+                    self.send2socket(f':{dnickname} SVSMODE {nickname} {umode}')
                 except KeyError as ke:
                     self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'mode':
-                # .mode #channel +/-mode
-                # .mode +/-mode
-                try:
-
-                    if len(cmd) < 2:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} {command.upper()} [#CHANNEL] [+/-]mode')
-                        return None
-
-                    if fromchannel is None:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} {command.upper()} [#CHANNEL] [+/-]mode')
-                        return None
-
-                    if len(cmd) == 2:
-                        channel_mode = cmd[1]
-                        if self.Base.Is_Channel(fromchannel):
-                            self.Irc.send2socket(f":{dnickname} MODE {fromchannel} {channel_mode}")
-                        else:
-                            self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} : Right command : Channel [{fromchannel}] is not correct should start with #")
-                        return None
-
-                    if len(cmd) == 3:
-                        provided_channel = cmd[1]
-                        channel_mode = cmd[2]
-                        self.Irc.send2socket(f":{service_id} MODE {provided_channel} {channel_mode}")
-                        return None
-
-                except IndexError as e:
-                    self.Logs.warning(f'_hcmd OP: {str(e)}')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} {command.upper()} [#CHANNEL] [+/-]mode')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'svsjoin':
-                try:
-                    # .svsjoin nickname #channel
-                    nickname = str(cmd[1])
-                    channel = str(cmd[2])
-                    if len(cmd) != 3:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSJOIN nickname #channel')
-                        return None
-
-                    self.Irc.send2socket(f':{self.Config.SERVEUR_ID} SVSJOIN {nickname} {channel}')
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSJOIN nickname #channel')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'svspart':
-                try:
-                    # .svspart nickname #channel
-                    nickname = str(cmd[1])
-                    channel = str(cmd[2])
-                    if len(cmd) != 3:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSPART nickname #channel')
-                        return None
-
-                    self.Irc.send2socket(f':{self.Config.SERVEUR_ID} SVSPART {nickname} {channel}')
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSPART nickname #channel')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'sajoin':
-                try:
-                    # .sajoin nickname #channel
-                    nickname = str(cmd[1])
-                    channel = str(cmd[2])
-                    if len(cmd) < 3:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname #channel')
-                        return None
-
-                    self.Irc.send2socket(f':{self.Config.SERVEUR_ID} SAJOIN {nickname} {channel}')
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname #channel')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'sapart':
-                try:
-                    # .sapart nickname #channel
-                    nickname = str(cmd[1])
-                    channel = str(cmd[2])
-                    if len(cmd) < 3:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname #channel')
-                        return None
-
-                    self.Irc.send2socket(f':{self.Config.SERVEUR_ID} SAPART {nickname} {channel}')
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname #channel')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'svsnick':
-                try:
-                    # .svsnick nickname newnickname
-                    nickname = str(cmd[1])
-                    newnickname = str(cmd[2])
-                    unixtime = self.Base.get_unixtime()
-
-                    if self.User.get_nickname(nickname) is None:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : This nickname do not exist')
-                        return None
-
-                    if len(cmd) != 3:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname newnickname')
-                        return None
-
-                    self.Irc.send2socket(f':{self.Config.SERVEUR_ID} SVSNICK {nickname} {newnickname} {unixtime}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname newnickname')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'kill':
-                try:
-                    # 'kill', 'gline', 'ungline', 'shun', 'unshun'
-                    # .kill nickname reason
-                    if len(cmd) < 3:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname reason')
-                        return None
-
-                    nickname = str(cmd[1])
-                    kill_reason = ' '.join(cmd[2:])
-
-                    self.Irc.send2socket(f":{service_id} KILL {nickname} {kill_reason} ({self.Config.COLORS.red}{dnickname}{self.Config.COLORS.nogc})")
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSNICK nickname newnickname')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'gline':
-                try:
-                    # TKL + G user host set_by expire_timestamp set_at_timestamp :reason
-                    # .gline [nickname] [host] [reason]
-                    if len(cmd) < 4:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname host reason')
-                        return None
-
-                    nickname = str(cmd[1])
-                    hostname = str(cmd[2])
-                    set_at_timestamp = self.Base.get_unixtime()
-                    expire_time = (60 * 60 * 24) + set_at_timestamp
-                    gline_reason = ' '.join(cmd[3:])
-
-                    if nickname == '*' and hostname == '*':
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : You want to close the server ? i would recommand ./unrealircd stop :)')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname host reason')
-                        return None
-
-                    self.Irc.send2socket(f":{self.Config.SERVEUR_ID} TKL + G {nickname} {hostname} {dnickname} {expire_time} {set_at_timestamp} :{gline_reason}")
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname host reason')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'ungline':
-                try:
-                    # 'shun', 'unshun'
-                    # TKL + G user host set_by expire_timestamp set_at_timestamp :reason
-                    # .ungline nickname host
-                    if len(cmd) < 2:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname hostname')
-                        return None
-
-                    nickname = str(cmd[1])
-                    hostname = str(cmd[2])
-
-                    self.Irc.send2socket(f":{self.Config.SERVEUR_ID} TKL - G {nickname} {hostname} {dnickname}")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname hostname')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'kline':
-                try:
-                    # TKL + k user host set_by expire_timestamp set_at_timestamp :reason
-                    # .gline [nickname] [host] [reason]
-                    if len(cmd) < 4:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname host reason')
-                        return None
-
-                    nickname = str(cmd[1])
-                    hostname = str(cmd[2])
-                    set_at_timestamp = self.Base.get_unixtime()
-                    expire_time = (60 * 60 * 24) + set_at_timestamp
-                    gline_reason = ' '.join(cmd[3:])
-
-                    if nickname == '*' and hostname == '*':
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : You want to close the server ? i would recommand ./unrealircd stop :)')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname host reason')
-                        return None
-
-                    self.Irc.send2socket(f":{self.Config.SERVEUR_ID} TKL + k {nickname} {hostname} {dnickname} {expire_time} {set_at_timestamp} :{gline_reason}")
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname host reason')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'unkline':
-                try:
-                    # 'shun', 'unshun'
-                    # TKL + G user host set_by expire_timestamp set_at_timestamp :reason
-                    # .ungline nickname host
-                    if len(cmd) < 2:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname hostname')
-                        return None
-
-                    nickname = str(cmd[1])
-                    hostname = str(cmd[2])
-
-                    self.Irc.send2socket(f":{self.Config.SERVEUR_ID} TKL - k {nickname} {hostname} {dnickname}")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname hostname')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'shun':
-                try:
-                    # TKL + G user host set_by expire_timestamp set_at_timestamp :reason
-                    # .shun [nickname] [host] [reason]
-
-                    if len(cmd) < 4:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname host reason')
-                        return None
-
-                    nickname = str(cmd[1])
-                    hostname = str(cmd[2])
-                    set_at_timestamp = self.Base.get_unixtime()
-                    expire_time = (60 * 60 * 24) + set_at_timestamp
-                    shun_reason = ' '.join(cmd[3:])
-
-                    if nickname == '*' and hostname == '*':
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : You want to close the server ? i would recommand ./unrealircd stop :)')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname host reason')
-                        return None
-
-                    self.Irc.send2socket(f":{self.Config.SERVEUR_ID} TKL + s {nickname} {hostname} {dnickname} {expire_time} {set_at_timestamp} :{shun_reason}")
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname host reason')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'unshun':
-                try:
-                    # 'shun', 'unshun'
-                    # TKL + G user host set_by expire_timestamp set_at_timestamp :reason
-                    # .unshun nickname host
-                    if len(cmd) < 2:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname hostname')
-                        return None
-
-                    nickname = str(cmd[1])
-                    hostname = str(cmd[2])
-
-                    self.Irc.send2socket(f":{self.Config.SERVEUR_ID} TKL - s {nickname} {hostname} {dnickname}")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()} nickname hostname')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'glinelist':
-                try:
-                    self.user_to_notice = fromuser
-                    self.Irc.send2socket(f":{self.Config.SERVICE_ID} STATS G")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()}')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'shunlist':
-                try:
-                    self.user_to_notice = fromuser
-                    self.Irc.send2socket(f":{self.Config.SERVICE_ID} STATS s")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()}')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'klinelist':
-                try:
-                    self.user_to_notice = fromuser
-                    self.Irc.send2socket(f":{self.Config.SERVICE_ID} STATS k")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} {command.upper()}')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')

mods/mod_defender.py

@@ -1,15 +1,9 @@
-import socket
-import json
-import time
-import re
-import psutil
-import requests
 from dataclasses import dataclass, fields, field
 from datetime import datetime
 from typing import Union
+import re, socket, psutil, requests, json, time
 from sys import exit
 from core.irc import Irc
-from core.Model import User
 
 #   Le module crée devra réspecter quelques conditions
 #       1. Le nom de la classe devra toujours s'appeler comme le module. Exemple => nom de class Defender | nom du module mod_defender
@@ -49,13 +43,11 @@ class Defender():
         nickname: str
         username: str
         hostname: str
-        realname: str
         umodes: str
         vhost: str
         ip: str
         score: int
         isWebirc: bool
-        isWebsocket: bool
         secret_code: str
         connected_datetime: str
         updated_datetime: str
@@ -111,14 +103,16 @@ class Defender():
         self.__load_module_configuration()
         # End of mandatory methods you can start your customization #
 
-        self.timeout = self.Config.API_TIMEOUT
+        # # Rejoindre les salons
+        # self.join_saved_channels()
 
+        self.timeout = self.Config.API_TIMEOUT
         # Listes qui vont contenir les ip a scanner avec les différentes API
-        self.abuseipdb_UserModel: list[User.UserModel] = []
-        self.freeipapi_UserModel: list[User.UserModel] = []
-        self.cloudfilt_UserModel: list[User.UserModel] = []
-        self.psutil_UserModel: list[User.UserModel]    = []
-        self.localscan_UserModel: list[User.UserModel] = []
+        self.freeipapi_remote_ip:list = []
+        self.cloudfilt_remote_ip:list = []
+        self.abuseipdb_remote_ip:list = []
+        self.psutil_remote_ip:list    = []
+        self.localscan_remote_ip:list = []
 
         # Variables qui indique que les threads sont en cours d'éxecutions
         self.abuseipdb_isRunning:bool       = True
@@ -146,10 +140,6 @@ class Defender():
         self.Base.create_thread(func=self.thread_psutil_scan)
         self.Base.create_thread(func=self.thread_reputation_timer)
 
-        if self.ModConfig.reputation == 1:
-            self.Irc.send2socket(f":{self.Config.SERVEUR_ID} SJOIN {self.Base.get_unixtime()} {self.Config.SALON_JAIL} + :{self.Config.SERVICE_NICKNAME}")
-            self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} SAMODE {self.Config.SALON_JAIL} +o {self.Config.SERVICE_NICKNAME}")
-
         return None
 
     def __set_commands(self, commands:dict[int, list[str]]) -> None:
@@ -233,11 +223,11 @@ class Defender():
         """Cette methode sera executée a chaque désactivation ou 
         rechargement de module
         """
-        self.abuseipdb_UserModel: list[User.UserModel] = []
-        self.freeipapi_UserModel: list[User.UserModel] = []
-        self.cloudfilt_UserModel: list[User.UserModel] = []
-        self.psutil_UserModel: list[User.UserModel]    = []
-        self.localscan_UserModel: list[User.UserModel] = []
+        self.abuseipdb_remote_ip:list = []                                  # Liste qui va contenir les adresses ip a scanner avec abuseipdb
+        self.freeipapi_remote_ip:list = []                                  # Liste qui va contenir les adresses ip a scanner avec freeipapi
+        self.cloudfilt_remote_ip:list = []                                  # Liste qui va contenir les adresses ip a scanner avec cloudfilt
+        self.psutil_remote_ip:list    = []                                  # Liste qui va contenir les adresses ip a scanner avec psutil_scan
+        self.localscan_remote_ip:list = []                                  # Liste qui va contenir les adresses ip a scanner avec local_scan
 
         self.abuseipdb_isRunning:bool = False
         self.freeipapi_isRunning:bool = False
@@ -247,6 +237,40 @@ class Defender():
         self.reputationTimer_isRunning:bool = False
         return None
 
+    def add_defender_channel(self, channel:str) -> bool:
+        """Cette fonction ajoute les salons de join de Defender
+
+        Args:
+            channel (str): le salon à enregistrer.
+        """
+        mes_donnees = {'channel': channel}
+        response = self.Base.db_execute_query("SELECT id FROM def_channels WHERE channel = :channel", mes_donnees)
+        
+        isChannelExist = response.fetchone()
+
+        if isChannelExist is None:
+            mes_donnees = {'datetime': self.Base.get_datetime(), 'channel': channel}
+            insert = self.Base.db_execute_query(f"INSERT INTO def_channels (datetime, channel) VALUES (:datetime, :channel)", mes_donnees)
+            return True
+        else:
+            return False
+
+    def delete_defender_channel(self, channel:str) -> bool:
+        """Cette fonction supprime les salons de join de Defender
+
+        Args:
+            channel (str): le salon à enregistrer.
+        """
+        mes_donnes = {'channel': channel}
+        response = self.Base.db_execute_query("DELETE FROM def_channels WHERE channel = :channel", mes_donnes)
+        
+        affected_row = response.rowcount
+
+        if affected_row > 0:
+            return True
+        else:
+            return False
+
     def reputation_insert(self, reputationModel: ReputationModel) -> bool:
 
         response = False
@@ -336,7 +360,7 @@ class Defender():
 
     def join_saved_channels(self) -> None:
 
-        result = self.Base.db_execute_query(f"SELECT distinct channel_name FROM {self.Config.table_channel}")
+        result = self.Base.db_execute_query("SELECT id, channel FROM def_channels")
         channels = result.fetchall()
         jail_chan = self.Config.SALON_JAIL
         jail_chan_mode = self.Config.SALON_JAIL_MODES
@@ -347,7 +371,7 @@ class Defender():
         unixtime = self.Base.get_unixtime()
 
         for channel in channels:
-            chan = channel[0]
+            id, chan = channel
             self.Irc.send2socket(f":{self.Config.SERVEUR_ID} SJOIN {unixtime} {chan} + :{self.Config.SERVICE_ID}")
             if chan == jail_chan:
                 self.Irc.send2socket(f":{service_id} SAMODE {jail_chan} +{dumodes} {dnickname}")
@@ -410,9 +434,9 @@ class Defender():
             jailed_nickname = get_reputation.nickname
             jailed_score = get_reputation.score
 
-            color_red = self.Config.COLORS.red
-            color_black = self.Config.COLORS.black
-            color_bold = self.Config.COLORS.bold
+            color_red = self.Config.CONFIG_COLOR['rouge']
+            color_black = self.Config.CONFIG_COLOR['noire']
+            color_bold = self.Config.CONFIG_COLOR['gras']
             service_id = self.Config.SERVICE_ID
             service_prefix = self.Config.SERVICE_PREFIX
             reputation_ban_all_chan = self.ModConfig.reputation_ban_all_chan
@@ -447,8 +471,8 @@ class Defender():
             ban_all_chan = self.ModConfig.reputation_ban_all_chan
             service_id = self.Config.SERVICE_ID
             dchanlog = self.Config.SERVICE_CHANLOG
-            color_red = self.Config.COLORS.red
-            color_black = self.Config.COLORS.black
+            color_red = self.Config.CONFIG_COLOR['rouge']
+            color_black = self.Config.CONFIG_COLOR['noire']
             salon_jail = self.Config.SALON_JAIL
 
             if reputation_flag == 0:
@@ -463,7 +487,6 @@ class Defender():
                     if self.get_user_uptime_in_minutes(user.uid) >= reputation_timer and int(user.score) <= int(reputation_seuil):
                         self.Irc.send2socket(f":{service_id} PRIVMSG {dchanlog} :[{color_red} REPUTATION {color_black}] : Action sur {user.nickname} aprés {str(reputation_timer)} minutes d'inactivité")
                         self.Irc.send2socket(f":{service_id} KILL {user.nickname} After {str(reputation_timer)} minutes of inactivity you should reconnect and type the password code ")
-                        self.Irc.send2socket(f":{self.Config.SERVEUR_LINK} REPUTATION {user.ip} 0")
 
                         self.Logs.info(f"Nickname: {user.nickname} KILLED after {str(reputation_timer)} minutes of inactivity")
                         uid_to_clean.append(user.uid)
@@ -528,8 +551,8 @@ class Defender():
         flood_timer = self.ModConfig.flood_timer
         service_id = self.Config.SERVICE_ID
         dnickname = self.Config.SERVICE_NICKNAME
-        color_red = self.Config.COLORS.red
-        color_bold = self.Config.COLORS.bold
+        color_red = self.Config.CONFIG_COLOR['rouge']
+        color_bold = self.Config.CONFIG_COLOR['gras']
         
         get_detected_uid = self.User.get_uid(detected_user)
         get_detected_nickname = self.User.get_nickname(detected_user)
@@ -578,38 +601,28 @@ class Defender():
 
         return None
 
-    def scan_ports(self, userModel: User.UserModel) -> None:
+    def scan_ports(self, remote_ip: str) -> None:
         """local_scan
 
         Args:
-            userModel (UserModel): _description_
+            remote_ip (str): _description_
         """
-        User = userModel
-        remote_ip = User.remote_ip
-        username = User.username
-        hostname = User.hostname
-        nickname = User.nickname
-        fullname = f'{nickname}!{username}@{hostname}'
-
         if remote_ip in self.Config.WHITELISTED_IP:
             return None
 
         for port in self.Config.PORTS_TO_SCAN:
-            try:
             newSocket = ''
             newSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM or socket.SOCK_NONBLOCK)
             newSocket.settimeout(0.5)
-
+            try:
                 connection = (remote_ip, self.Base.int_if_possible(port))
                 newSocket.connect(connection)
-
-                self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.COLORS.red}PROXY_SCAN{self.Config.COLORS.black} ] {fullname} ({remote_ip}) :     Port [{str(port)}] ouvert sur l'adresse ip [{remote_ip}]")
+                self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.CONFIG_COLOR['rouge']}PROXY_SCAN{self.Config.CONFIG_COLOR['noire']} ] :     Port [{str(port)}] ouvert sur l'adresse ip [{remote_ip}]")
                 # print(f"=======> Le port {str(port)} est ouvert !!")
                 self.Base.running_sockets.append(newSocket)
                 # print(newSocket)
                 newSocket.shutdown(socket.SHUT_RDWR)
                 newSocket.close()
-
             except (socket.timeout, ConnectionRefusedError):
                 self.Logs.info(f"Le port {remote_ip}:{str(port)} est fermé")
             except AttributeError as ae:
@@ -621,18 +634,20 @@ class Defender():
                 newSocket.close()
                 self.Logs.info('=======> Fermeture de la socket')
         
+        pass
+
     def thread_local_scan(self) -> None:
         try:
             while self.localscan_isRunning:
 
                 list_to_remove:list = []
-                for user in self.localscan_UserModel:
-                    self.scan_ports(user)
-                    list_to_remove.append(user)
+                for ip in self.localscan_remote_ip:
+                    self.scan_ports(ip)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
-                    self.localscan_UserModel.remove(user_model)
+                for ip_to_remove in list_to_remove:
+                    self.localscan_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -640,33 +655,23 @@ class Defender():
         except ValueError as ve:
             self.Logs.warning(f"thread_local_scan Error : {ve}")
 
-    def get_ports_connexion(self, userModel: User.UserModel) -> list[int]:
-        """psutil_scan for Linux (should be run on the same location as the unrealircd server)
+    def get_ports_connexion(self, remote_ip: str) -> list[int]:
+        """psutil_scan for Linux
 
         Args:
-            userModel (UserModel): The User Model Object
+            remote_ip (str): The remote ip address
 
         Returns:
             list[int]: list of ports
         """
         try:
-            User = userModel
-            remote_ip = User.remote_ip
-            username = User.username
-            hostname = User.hostname
-            nickname = User.nickname
-
             if remote_ip in self.Config.WHITELISTED_IP:
                 return None
 
             connections = psutil.net_connections(kind='inet')
-            fullname = f'{nickname}!{username}@{hostname}'
 
             matching_ports = [conn.raddr.port for conn in connections if conn.raddr and conn.raddr.ip == remote_ip]
-            self.Logs.info(f"Connexion of {fullname} ({remote_ip}) using ports : {str(matching_ports)}")
-
-            if matching_ports:
-                self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.COLORS.red}PSUTIL_SCAN{self.Config.COLORS.black} ] {fullname} ({remote_ip}) : is using ports {matching_ports}")
+            self.Logs.info(f"Connexion of {remote_ip} using ports : {str(matching_ports)}")
 
             return matching_ports
 
@@ -679,13 +684,13 @@ class Defender():
             while self.psutil_isRunning:
 
                 list_to_remove:list = []
-                for user in self.psutil_UserModel:
-                    self.get_ports_connexion(user)
-                    list_to_remove.append(user)
+                for ip in self.psutil_remote_ip:
+                    self.get_ports_connexion(ip)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
-                    self.psutil_UserModel.remove(user_model)
+                for ip_to_remove in list_to_remove:
+                    self.psutil_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -693,22 +698,16 @@ class Defender():
         except ValueError as ve:
             self.Logs.warning(f"thread_psutil_scan Error : {ve}")
 
-    def abuseipdb_scan(self, userModel: User.UserModel) -> Union[dict[str, any], None]:
+    def abuseipdb_scan(self, remote_ip:str) -> Union[dict[str, any], None]:
         """Analyse l'ip avec AbuseIpDB
            Cette methode devra etre lancer toujours via un thread ou un timer.
         Args:
-            userModel (UserModel): l'objet User qui contient l'ip
+            remote_ip (_type_): l'ip a analyser
 
         Returns:
             dict[str, any] | None: les informations du provider
             keys : 'score', 'country', 'isTor', 'totalReports'
         """
-        User = userModel
-        remote_ip = User.remote_ip
-        username = User.username
-        hostname = User.hostname
-        nickname = User.nickname
-
         if remote_ip in self.Config.WHITELISTED_IP:
             return None
         if self.ModConfig.abuseipdb_scan == 0:
@@ -728,12 +727,11 @@ class Defender():
             'Key': self.abuseipdb_key
         }
 
-        try:
         response = requests.request(method='GET', url=url, headers=headers, params=querystring, timeout=self.timeout)
 
         # Formatted output
         decodedResponse = json.loads(response.text)
-
+        try:
             if not 'data' in decodedResponse:
                 return None
 
@@ -746,13 +744,10 @@ class Defender():
 
             service_id = self.Config.SERVICE_ID
             service_chanlog = self.Config.SERVICE_CHANLOG
-            color_red = self.Config.COLORS.red
-            color_black = self.Config.COLORS.black
+            color_red = self.Config.CONFIG_COLOR['rouge']
+            color_black = self.Config.CONFIG_COLOR['noire']
 
-            # pseudo!ident@host
-            fullname = f'{nickname}!{username}@{hostname}'
-
-            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}ABUSEIPDB_SCAN{color_black} ] : Connexion de {fullname} ({remote_ip}) ==> Score: {str(result['score'])} | Country : {result['country']} | Tor : {str(result['isTor'])} | Total Reports : {str(result['totalReports'])}")
+            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}ABUSEIPDB_SCAN{color_black} ] : Connexion de {remote_ip} ==> Score: {str(result['score'])} | Country : {result['country']} | Tor : {str(result['isTor'])} | Total Reports : {str(result['totalReports'])}")
 
             if result['isTor']:
                 self.Irc.send2socket(f":{service_id} GLINE +*@{remote_ip} {self.Config.GLINE_DURATION} This server do not allow Tor connexions {str(result['isTor'])} - Detected by Abuseipdb")
@@ -768,8 +763,6 @@ class Defender():
             self.Logs.error(f"AbuseIpDb Timeout : {rt}")
         except requests.ConnectionError as ce:
             self.Logs.error(f"AbuseIpDb Connection Error : {ce}")
-        except Exception as err:
-            self.Logs.error(f"General Error Abuseipdb : {err}")
 
     def thread_abuseipdb_scan(self) -> None:
         try:
@@ -777,13 +770,13 @@ class Defender():
             while self.abuseipdb_isRunning:
 
                 list_to_remove:list = []
-                for user in self.abuseipdb_UserModel:
-                    self.abuseipdb_scan(user)
-                    list_to_remove.append(user)
+                for ip in self.abuseipdb_remote_ip:
+                    self.abuseipdb_scan(ip)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
-                    self.abuseipdb_UserModel.remove(user_model)
+                for ip_to_remove in list_to_remove:
+                    self.abuseipdb_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -791,7 +784,7 @@ class Defender():
         except ValueError as ve:
                 self.Logs.error(f"thread_abuseipdb_scan Error : {ve}")
 
-    def freeipapi_scan(self, userModel: User.UserModel) -> Union[dict[str, any], None]:
+    def freeipapi_scan(self, remote_ip:str) -> Union[dict[str, any], None]:
         """Analyse l'ip avec Freeipapi
            Cette methode devra etre lancer toujours via un thread ou un timer.
         Args:
@@ -801,12 +794,6 @@ class Defender():
             dict[str, any] | None: les informations du provider
             keys : 'countryCode', 'isProxy'
         """
-        User = userModel
-        remote_ip = User.remote_ip
-        username = User.username
-        hostname = User.hostname
-        nickname = User.nickname
-
         if remote_ip in self.Config.WHITELISTED_IP:
             return None
         if self.ModConfig.freeipapi_scan == 0:
@@ -814,8 +801,8 @@ class Defender():
 
         service_id = self.Config.SERVICE_ID
         service_chanlog = self.Config.SERVICE_CHANLOG
-        color_red = self.Config.COLORS.red
-        color_black = self.Config.COLORS.black
+        color_red = self.Config.CONFIG_COLOR['rouge']
+        color_black = self.Config.CONFIG_COLOR['noire']
 
         url = f'https://freeipapi.com/api/json/{remote_ip}'
 
@@ -823,12 +810,11 @@ class Defender():
             'Accept': 'application/json',
         }
 
-        try:
         response = requests.request(method='GET', url=url, headers=headers, timeout=self.timeout)
 
         # Formatted output
         decodedResponse = json.loads(response.text)
-
+        try:
             status_code = response.status_code
             if status_code == 429:
                 self.Logs.warning(f'Too Many Requests - The rate limit for the API has been exceeded.')
@@ -842,10 +828,7 @@ class Defender():
                 'isProxy': decodedResponse['isProxy'] if 'isProxy' in decodedResponse else None
             }
 
-            # pseudo!ident@host
-            fullname = f'{nickname}!{username}@{hostname}'
-
-            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}FREEIPAPI_SCAN{color_black} ] : Connexion de {fullname} ({remote_ip}) ==> Proxy: {str(result['isProxy'])} | Country : {str(result['countryCode'])}")
+            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}FREEIPAPI_SCAN{color_black} ] : Connexion de {remote_ip} ==> Proxy: {str(result['isProxy'])} | Country : {str(result['countryCode'])}")
 
             if result['isProxy']:
                 self.Irc.send2socket(f":{service_id} GLINE +*@{remote_ip} {self.Config.GLINE_DURATION} This server do not allow proxy connexions {str(result['isProxy'])} - detected by freeipapi")
@@ -854,22 +837,20 @@ class Defender():
             return result
         except KeyError as ke:
             self.Logs.error(f"FREEIPAPI_SCAN KeyError : {ke}")
-        except Exception as err:
-            self.Logs.error(f"General Error Freeipapi : {err}")
 
     def thread_freeipapi_scan(self) -> None:
         try:
 
             while self.freeipapi_isRunning:
 
-                list_to_remove: list[User.UserModel] = []
-                for user in self.freeipapi_UserModel:
-                    self.freeipapi_scan(user)
-                    list_to_remove.append(user)
+                list_to_remove:list = []
+                for ip in self.freeipapi_remote_ip:
+                    self.freeipapi_scan(ip)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
-                    self.freeipapi_UserModel.remove(user_model)
+                for ip_to_remove in list_to_remove:
+                    self.freeipapi_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -877,7 +858,7 @@ class Defender():
         except ValueError as ve:
             self.Logs.error(f"thread_freeipapi_scan Error : {ve}")
 
-    def cloudfilt_scan(self, userModel: User.UserModel) -> Union[dict[str, any], None]:
+    def cloudfilt_scan(self, remote_ip:str) -> Union[dict[str, any], None]:
         """Analyse l'ip avec cloudfilt
            Cette methode devra etre lancer toujours via un thread ou un timer.
         Args:
@@ -887,12 +868,6 @@ class Defender():
             dict[str, any] | None: les informations du provider
             keys : 'countryCode', 'isProxy'
         """
-        User = userModel
-        remote_ip = User.remote_ip
-        username = User.username
-        hostname = User.hostname
-        nickname = User.nickname
-
         if remote_ip in self.Config.WHITELISTED_IP:
             return None
         if self.ModConfig.cloudfilt_scan == 0:
@@ -902,8 +877,8 @@ class Defender():
 
         service_id = self.Config.SERVICE_ID
         service_chanlog = self.Config.SERVICE_CHANLOG
-        color_red = self.Config.COLORS.red
-        color_black = self.Config.COLORS.black
+        color_red = self.Config.CONFIG_COLOR['rouge']
+        color_black = self.Config.CONFIG_COLOR['noire']
 
         url = f"https://developers18334.cloudfilt.com/"
 
@@ -912,10 +887,11 @@ class Defender():
             'key': self.cloudfilt_key
         }
 
-        try:
         response = requests.post(url=url, data=data)
+
         # Formatted output
         decodedResponse = json.loads(response.text)
+        try:
             status_code = response.status_code
             if status_code != 200:
                 self.Logs.warning(f'Error connecting to cloudfilt API | Code: {str(status_code)}')
@@ -928,10 +904,7 @@ class Defender():
                 'host': decodedResponse['host'] if 'host' in decodedResponse else None
             }
 
-            # pseudo!ident@host
-            fullname = f'{nickname}!{username}@{hostname}'
-
-            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}CLOUDFILT_SCAN{color_black} ] : Connexion de {fullname} ({remote_ip}) ==> Host: {str(result['host'])} | country: {str(result['countryiso'])} | listed: {str(result['listed'])} | listed by : {str(result['listed_by'])}")
+            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}CLOUDFILT_SCAN{color_black} ] : Connexion de {str(remote_ip)} ==> Host: {str(result['host'])} | country: {str(result['countryiso'])} | listed: {str(result['listed'])} | listed by : {str(result['listed_by'])}")
 
             if result['listed']:
                 self.Irc.send2socket(f":{service_id} GLINE +*@{remote_ip} {self.Config.GLINE_DURATION} You connexion is listed as dangerous {str(result['listed'])} {str(result['listed_by'])} - detected by cloudfilt")
@@ -949,13 +922,13 @@ class Defender():
             while self.cloudfilt_isRunning:
 
                 list_to_remove:list = []
-                for user in self.cloudfilt_UserModel:
-                    self.cloudfilt_scan(user)
-                    list_to_remove.append(user)
+                for ip in self.cloudfilt_remote_ip:
+                    self.cloudfilt_scan(ip)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
-                    self.cloudfilt_UserModel.remove(user_model)
+                for ip_to_remove in list_to_remove:
+                    self.cloudfilt_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -964,10 +937,13 @@ class Defender():
             self.Logs.error(f"Thread_cloudfilt_scan Error : {ve}")
 
     def cmd(self, data:list) -> None:
-        try:
+
         service_id = self.Config.SERVICE_ID                 # Defender serveur id
         cmd = list(data).copy()
 
+        if len(cmd) < 2:
+            return None
+
         match cmd[1]:
 
             case 'REPUTATION':
@@ -982,27 +958,28 @@ class Defender():
                     if not self.Base.is_valid_ip(cmd[2]):
                         return None
 
+                    # self.Base.scan_ports(cmd[2])
+                    if self.ModConfig.local_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.localscan_remote_ip.append(cmd[2])
+
+                    if self.ModConfig.psutil_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.psutil_remote_ip.append(cmd[2])
+
+                    if self.ModConfig.abuseipdb_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.abuseipdb_remote_ip.append(cmd[2])
+
+                    if self.ModConfig.freeipapi_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.freeipapi_remote_ip.append(cmd[2])
+
+                    if self.ModConfig.cloudfilt_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.cloudfilt_remote_ip.append(cmd[2])
+
                     # Possibilité de déclancher les bans a ce niveau.
                 except IndexError as ie:
                     self.Logs.error(f'cmd reputation: index error: {ie}')
 
-            if len(cmd) < 3:
-                return None
-
         match cmd[2]:
 
-                case 'MODE':
-                    # ['...', ':001XSCU0Q', 'MODE', '#jail', '+b', '~security-group:unknown-users']
-                    channel = str(cmd[3])
-                    mode = str(cmd[4])
-                    group_to_check = str(cmd[5:])
-                    group_to_unban = '~security-group:unknown-users'
-
-                    if self.Config.SALON_JAIL == channel:
-                        if mode == '+b' and group_to_unban in group_to_check:
-                            self.Irc.send2socket(f":{service_id} MODE {self.Config.SALON_JAIL} -b ~security-group:unknown-users")
-                            self.Irc.send2socket(f":{service_id} MODE {self.Config.SALON_JAIL} -eee ~security-group:webirc-users ~security-group:known-users ~security-group:websocket-users")
-
             case 'PRIVMSG':
                 cmd.pop(0)
                 user_trigger = str(cmd[0]).replace(':','')
@@ -1020,15 +997,6 @@ class Defender():
 
                 # Get User information
                 _User = self.User.get_User(str(cmd[7]))
-
-                    # If user is not service or IrcOp then scan them
-                    if not re.match(fr'^.*[S|o?].*$', _User.umodes):
-                        self.abuseipdb_UserModel.append(_User) if self.ModConfig.abuseipdb_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                        self.freeipapi_UserModel.append(_User) if self.ModConfig.freeipapi_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                        self.cloudfilt_UserModel.append(_User) if self.ModConfig.cloudfilt_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                        self.psutil_UserModel.append(_User) if self.ModConfig.psutil_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                        self.localscan_UserModel.append(_User) if self.ModConfig.local_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-
                 if _User is None:
                     self.Logs.critical(f'This UID: [{cmd[7]}] is not available please check why')
                     return None
@@ -1043,9 +1011,9 @@ class Defender():
                             currentDateTime = self.Base.get_datetime()
                             self.reputation_insert(
                                 self.ReputationModel(
-                                        uid=_User.uid, nickname=_User.nickname, username=_User.username, realname=_User.realname, 
-                                        hostname=_User.hostname, umodes=_User.umodes, vhost=_User.vhost, ip=_User.remote_ip, score=_User.score_connexion,
-                                        secret_code=self.Base.get_random(8), isWebirc=_User.isWebirc, isWebsocket=_User.isWebsocket, connected_datetime=currentDateTime,
+                                    uid=_User.uid, nickname=_User.nickname, username=_User.username, hostname=_User.hostname,
+                                    umodes=_User.umodes, vhost=_User.vhost, ip=_User.remote_ip, score=_User.score_connexion,
+                                    secret_code=self.Base.get_random(8), isWebirc=_User.isWebirc, connected_datetime=currentDateTime,
                                     updated_datetime=currentDateTime
                                 )
                             )
@@ -1068,10 +1036,6 @@ class Defender():
 
                         get_reputation = self.reputation_get_Reputation(parsed_UID)
 
-                            if parsed_chan != self.Config.SALON_JAIL:
-                                self.Irc.send2socket(f":{service_id} MODE {parsed_chan} +b ~security-group:unknown-users")
-                                self.Irc.send2socket(f":{service_id} MODE {parsed_chan} +eee ~security-group:webirc-users ~security-group:known-users ~security-group:websocket-users")
-
                         if not get_reputation is None:
                             isWebirc = get_reputation.isWebirc
 
@@ -1095,20 +1059,20 @@ class Defender():
                 if not self.Base.is_valid_ip(cmd[7]):
                     return None
 
-                    # if self.ModConfig.local_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                    #     self.localscan_remote_ip.append(cmd[7])
+                if self.ModConfig.local_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                    self.localscan_remote_ip.append(cmd[7])
 
-                    # if self.ModConfig.psutil_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                    #     self.psutil_remote_ip.append(cmd[7])
+                if self.ModConfig.psutil_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                    self.psutil_remote_ip.append(cmd[7])
 
-                    # if self.ModConfig.abuseipdb_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                    #     self.abuseipdb_remote_ip.append(cmd[7])
+                if self.ModConfig.abuseipdb_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                    self.abuseipdb_remote_ip.append(cmd[7])
 
-                    # if self.ModConfig.freeipapi_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                    #     self.freeipapi_remote_ip.append(cmd[7])
+                if self.ModConfig.freeipapi_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                    self.freeipapi_remote_ip.append(cmd[7])
 
-                    # if self.ModConfig.cloudfilt_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                    #     self.cloudfilt_remote_ip.append(cmd[7])
+                if self.ModConfig.cloudfilt_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                    self.cloudfilt_remote_ip.append(cmd[7])
 
             case 'NICK':
                 # :0010BS24L NICK [NEWNICK] 1697917711
@@ -1158,13 +1122,6 @@ class Defender():
                             self.Irc.send2socket(f":{service_id} MODE {chan.name} -b {final_nickname}!*@*")
                     self.reputation_delete(final_UID)
 
-        except KeyError as ke:
-            self.Logs.error(f"{ke} / {cmd} / length {str(len(cmd))}")
-        except IndexError as ie:
-            self.Logs.error(f"{ie} / {cmd} / length {str(len(cmd))}")
-        except Exception as err:
-            self.Logs.error(f"General Error: {err}")
-
     def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
 
         command = str(cmd[0]).lower()
@@ -1218,8 +1175,8 @@ class Defender():
 
                     self.Logs.debug(f"IP de {jailed_nickname} : {jailed_IP}")
                     link = self.Config.SERVEUR_LINK
-                    color_green = self.Config.COLORS.green
-                    color_black = self.Config.COLORS.black
+                    color_green = self.Config.CONFIG_COLOR['verte']
+                    color_black = self.Config.CONFIG_COLOR['noire']
 
                     if release_code == get_reputation.secret_code:
                         self.Irc.send2socket(f':{dnickname} PRIVMSG {jailed_salon} : Bon mot de passe. Allez du vent !')
@@ -1263,13 +1220,13 @@ class Defender():
                         if activation == 'on':
 
                             if self.ModConfig.reputation == 1:
-                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}REPUTATION{self.Config.COLORS.black} ] : Already activated")
+                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}REPUTATION{self.Config.CONFIG_COLOR['noire']} ] : Already activated")
                                 return False
 
                             # self.update_db_configuration('reputation', 1)
                             self.__update_configuration(key, 1)
 
-                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}REPUTATION{self.Config.COLORS.black} ] : Activated by {fromuser}")
+                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}REPUTATION{self.Config.CONFIG_COLOR['noire']} ] : Activated by {fromuser}")
                             self.Irc.send2socket(f":{service_id} JOIN {jail_chan}")
                             self.Irc.send2socket(f":{service_id} SAMODE {jail_chan} +{dumodes} {dnickname}")
                             self.Irc.send2socket(f":{service_id} MODE {jail_chan} +{jail_chan_mode}")
@@ -1278,19 +1235,21 @@ class Defender():
                                 for chan in self.Channel.UID_CHANNEL_DB:
                                     if chan.name != jail_chan:
                                         self.Irc.send2socket(f":{service_id} MODE {chan.name} +b ~security-group:unknown-users")
-                                        self.Irc.send2socket(f":{service_id} MODE {chan.name} +eee ~security-group:webirc-users ~security-group:known-users ~security-group:websocket-users")
+                                        self.Irc.send2socket(f":{service_id} MODE {chan.name} +e ~security-group:webirc-users")
+                                        self.Irc.send2socket(f":{service_id} MODE {chan.name} +e ~security-group:known-users")
+                                        self.Irc.send2socket(f":{service_id} MODE {chan.name} +e ~security-group:websocket-users")
 
                             self.Base.db_query_channel('add', self.module_name, jail_chan)
 
                         if activation == 'off':
 
                             if self.ModConfig.reputation == 0:
-                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}REPUTATION{self.Config.COLORS.black} ] : Already deactivated")
+                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}REPUTATION{self.Config.CONFIG_COLOR['noire']} ] : Already deactivated")
                                 return False
 
                             self.__update_configuration(key, 0)
 
-                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.red}REPUTATION{self.Config.COLORS.black} ] : Deactivated by {fromuser}")
+                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['rouge']}REPUTATION{self.Config.CONFIG_COLOR['noire']} ] : Deactivated by {fromuser}")
                             self.Irc.send2socket(f":{service_id} SAMODE {jail_chan} -{dumodes} {dnickname}")
                             self.Irc.send2socket(f":{service_id} MODE {jail_chan} -sS")
                             self.Irc.send2socket(f":{service_id} PART {jail_chan}")
@@ -1298,7 +1257,9 @@ class Defender():
                             for chan in self.Channel.UID_CHANNEL_DB:
                                 if chan.name != jail_chan:
                                     self.Irc.send2socket(f":{service_id} MODE {chan.name} -b ~security-group:unknown-users")
-                                    self.Irc.send2socket(f":{service_id} MODE {chan.name} -eee ~security-group:webirc-users ~security-group:known-users ~security-group:websocket-users")
+                                    self.Irc.send2socket(f":{service_id} MODE {chan.name} -e ~security-group:webirc-users")
+                                    self.Irc.send2socket(f":{service_id} MODE {chan.name} -e ~security-group:known-users")
+                                    self.Irc.send2socket(f":{service_id} MODE {chan.name} -e ~security-group:websocket-users")
 
                             self.Base.db_query_channel('del', self.module_name, jail_chan)
 
@@ -1318,23 +1279,23 @@ class Defender():
                                 if get_value == 'on':
 
                                     if self.ModConfig.reputation_ban_all_chan == 1:
-                                        self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.red}BAN ON ALL CHANS{self.Config.COLORS.black} ] : Already activated")
+                                        self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['rouge']}BAN ON ALL CHANS{self.Config.CONFIG_COLOR['noire']} ] : Already activated")
                                         return False
 
                                     # self.update_db_configuration(key, 1)
                                     self.__update_configuration(key, 1)
 
-                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}BAN ON ALL CHANS{self.Config.COLORS.black} ] : Activated by {fromuser}')
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR["verte"]}BAN ON ALL CHANS{self.Config.CONFIG_COLOR["noire"]} ] : Activated by {fromuser}')
 
                                 elif get_value == 'off':
                                     if self.ModConfig.reputation_ban_all_chan == 0:
-                                        self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.red}BAN ON ALL CHANS{self.Config.COLORS.black} ] : Already deactivated")
+                                        self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['rouge']}BAN ON ALL CHANS{self.Config.CONFIG_COLOR['noire']} ] : Already deactivated")
                                         return False
 
                                     # self.update_db_configuration(key, 0)
                                     self.__update_configuration(key, 0)
 
-                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}BAN ON ALL CHANS{self.Config.COLORS.black} ] : Deactivated by {fromuser}')
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR["verte"]}BAN ON ALL CHANS{self.Config.CONFIG_COLOR["noire"]} ] : Deactivated by {fromuser}')
 
                             case 'limit':
                                 reputation_seuil = int(cmd[3])
@@ -1343,7 +1304,7 @@ class Defender():
                                 # self.update_db_configuration(key, reputation_seuil)
                                 self.__update_configuration(key, reputation_seuil)
 
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}REPUTATION SEUIL{self.Config.COLORS.black} ] : Limit set to {str(reputation_seuil)} by {fromuser}')
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR["verte"]}REPUTATION SEUIL{self.Config.CONFIG_COLOR["noire"]} ] : Limit set to {str(reputation_seuil)} by {fromuser}')
                                 self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Reputation set to {reputation_seuil}')
 
                             case 'timer':
@@ -1351,7 +1312,7 @@ class Defender():
                                 key = 'reputation_timer'
                                 self.__update_configuration(key, reputation_timer)
 
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}REPUTATION TIMER{self.Config.COLORS.black} ] : Timer set to {str(reputation_timer)} minute(s) by {fromuser}')
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR["verte"]}REPUTATION TIMER{self.Config.CONFIG_COLOR["noire"]} ] : Timer set to {str(reputation_timer)} minute(s) by {fromuser}')
                                 self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Reputation set to {reputation_timer}')
 
                             case 'score_after_release':
@@ -1359,7 +1320,7 @@ class Defender():
                                 key = 'reputation_score_after_release'
                                 self.__update_configuration(key, reputation_score_after_release)
 
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}REPUTATION SCORE AFTER RELEASE{self.Config.COLORS.black} ] : Reputation score after release set to {str(reputation_score_after_release)} by {fromuser}')
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR["verte"]}REPUTATION SCORE AFTER RELEASE{self.Config.CONFIG_COLOR["noire"]} ] : Reputation score after release set to {str(reputation_score_after_release)} by {fromuser}')
                                 self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Reputation score after release set to {reputation_score_after_release}')
 
                             case 'security_group':
@@ -1367,7 +1328,7 @@ class Defender():
                                 key = 'reputation_sg'
                                 self.__update_configuration(key, reputation_sg)
 
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}REPUTATION SECURITY-GROUP{self.Config.COLORS.black} ] : Reputation Security-group set to {str(reputation_sg)} by {fromuser}')
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR["verte"]}REPUTATION SECURITY-GROUP{self.Config.CONFIG_COLOR["noire"]} ] : Reputation Security-group set to {str(reputation_sg)} by {fromuser}')
                                 self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Reputation score after release set to {reputation_sg}')
 
                             case _:
@@ -1397,9 +1358,9 @@ class Defender():
                 # .proxy_scan set psutil_scan on/off         --> Active les informations de connexion a la machine locale
                 # .proxy_scan set abuseipdb_scan on/off      --> Active le scan via l'api abuseipdb
                 len_cmd = len(cmd)
-                color_green = self.Config.COLORS.green
-                color_red = self.Config.COLORS.red
-                color_black = self.Config.COLORS.black
+                color_green = self.Config.CONFIG_COLOR['verte']
+                color_red = self.Config.CONFIG_COLOR['rouge']
+                color_black = self.Config.CONFIG_COLOR['noire']
 
                 if len_cmd == 4:
                     set_key = str(cmd[1]).lower()
@@ -1531,21 +1492,21 @@ class Defender():
                         key = 'flood'
                         if activation == 'on':
                             if self.ModConfig.flood == 1:
-                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Already activated")
+                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Already activated")
                                 return False
 
                             self.__update_configuration(key, 1)
 
-                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Activated by {fromuser}")
+                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Activated by {fromuser}")
 
                         if activation == 'off':
                             if self.ModConfig.flood == 0:
-                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.red}FLOOD{self.Config.COLORS.black} ] : Already Deactivated")
+                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['rouge']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Already Deactivated")
                                 return False
 
                             self.__update_configuration(key, 0)
 
-                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Deactivated by {fromuser}")
+                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Deactivated by {fromuser}")
 
                     if len_cmd == 4:
                         set_key = str(cmd[2]).lower()
@@ -1557,21 +1518,21 @@ class Defender():
                                     set_value = int(cmd[3])
                                     self.__update_configuration(key, set_value)
 
-                                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Flood message set to {set_value} by {fromuser}")
+                                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Flood message set to {set_value} by {fromuser}")
 
                                 case 'flood_time':
                                     key = 'flood_time'
                                     set_value = int(cmd[3])
                                     self.__update_configuration(key, set_value)
 
-                                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Flood time set to {set_value} by {fromuser}")
+                                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Flood time set to {set_value} by {fromuser}")
 
                                 case 'flood_timer':
                                     key = 'flood_timer'
                                     set_value = int(cmd[3])
                                     self.__update_configuration(key, set_value)
 
-                                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Flood timer set to {set_value} by {fromuser}")
+                                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Flood timer set to {set_value} by {fromuser}")
 
                                 case _:
                                     pass
@@ -1580,9 +1541,9 @@ class Defender():
                     self.Logs.error(f"{self.__class__.__name__} Value Error : {ve}")
 
             case 'status':
-                color_green = self.Config.COLORS.green
-                color_red = self.Config.COLORS.red
-                color_black = self.Config.COLORS.black
+                color_green = self.Config.CONFIG_COLOR['verte']
+                color_red = self.Config.CONFIG_COLOR['rouge']
+                color_black = self.Config.CONFIG_COLOR['noire']
                 try:
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : [{color_green if self.ModConfig.reputation == 1 else color_red}Reputation{color_black}]                           ==> {self.ModConfig.reputation}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :           reputation_seuil             ==> {self.ModConfig.reputation_seuil}')
@@ -1609,25 +1570,14 @@ class Defender():
                     UserObject = self.User.get_User(nickoruid)
 
                     if not UserObject is None:
-                        channels: list = []
-                        for chan in self.Channel.UID_CHANNEL_DB:
-                            for uid_in_chan in chan.uids:
-                                if self.Base.clean_uid(uid_in_chan) == UserObject.uid:
-                                    channels.append(chan.name)
-
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : UID              : {UserObject.uid}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : NICKNAME         : {UserObject.nickname}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : USERNAME         : {UserObject.username}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : REALNAME         : {UserObject.realname}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : HOSTNAME         : {UserObject.hostname}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : VHOST            : {UserObject.vhost}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : IP               : {UserObject.remote_ip}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Country          : {UserObject.geoip}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : WebIrc           : {UserObject.isWebirc}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : WebWebsocket     : {UserObject.isWebsocket}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : REPUTATION       : {UserObject.score_connexion}')
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : VHOST            : {UserObject.vhost}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : MODES            : {UserObject.umodes}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : CHANNELS         : {channels}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : CONNECTION TIME  : {UserObject.connexion_datetime}')
                     else:
                         self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} : This user {nickoruid} doesn't exist")

mods/mod_jsonrpc.py

@@ -1,306 +0,0 @@
-from dataclasses import dataclass
-from core.irc import Irc
-from unrealircd_rpc_py.Live import Live
-from unrealircd_rpc_py.Loader import Loader
-
-
-class Jsonrpc():
-
-    @dataclass
-    class ModConfModel:
-        """The Model containing the module parameters
-        """
-        jsonrpc: int = 0
-
-    def __init__(self, ircInstance:Irc) -> None:
-
-        # Module name (Mandatory)
-        self.module_name = 'mod_' + str(self.__class__.__name__).lower()
-
-        # Add Irc Object to the module (Mandatory)
-        self.Irc = ircInstance
-
-        # Add Global Configuration to the module (Mandatory)
-        self.Config = ircInstance.Config
-
-        # Add Base object to the module (Mandatory)
-        self.Base = ircInstance.Base
-
-        # Add logs object to the module (Mandatory)
-        self.Logs = ircInstance.Base.logs
-
-        # Add User object to the module (Mandatory)
-        self.User = ircInstance.User
-
-        # Add Channel object to the module (Mandatory)
-        self.Channel = ircInstance.Channel
-
-        # Create module commands (Mandatory)
-        self.commands_level = {
-            1: ['jsonrpc', 'jruser']
-        }
-
-        # Init the module
-        self.__init_module()
-
-        # Log the module
-        self.Logs.debug(f'Module {self.module_name} loaded ...')
-
-    def __init_module(self) -> None:
-
-        # Insert module commands into the core one (Mandatory)
-        self.__set_commands(self.commands_level)
-
-        # Create you own tables (Mandatory)
-        # self.__create_tables()
-
-        # Load module configuration and sync with core one (Mandatory)
-        self.__load_module_configuration()
-        # End of mandatory methods you can start your customization #
-
-        # self.UnrealIrcdRpcLive: Live = Live(
-        #                 req_method='unixsocket',
-        #                 path_to_socket_file=self.Config.JSONRPC_PATH_TO_SOCKET_FILE,
-        #                 callback_object_instance=self,
-        #                 callback_method_name='callback_sent_to_irc'
-        #                )
-
-        self.UnrealIrcdRpcLive: Live = Live(
-                    req_method='websocket',
-                    url=self.Config.JSONRPC_URL,
-                    username=self.Config.JSONRPC_USER,
-                    password=self.Config.JSONRPC_PASSWORD,
-                    callback_object_instance=self,
-                    callback_method_name='callback_sent_to_irc',
-                    debug_level=10
-                    )
-
-        self.Rpc: Loader = Loader(
-            req_method=self.Config.JSONRPC_METHOD,
-            url=self.Config.JSONRPC_URL,
-            username=self.Config.JSONRPC_USER,
-            password=self.Config.JSONRPC_PASSWORD
-        )
-
-        self.subscribed = False
-
-        if self.Rpc.Error.code != 0:
-            self.Irc.sendPrivMsg(f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.Rpc.Error.message}", self.Config.SERVICE_CHANLOG)
-
-        if self.UnrealIrcdRpcLive.Error.code != 0:
-            self.Irc.sendPrivMsg(f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.UnrealIrcdRpcLive.Error.message}", self.Config.SERVICE_CHANLOG)
-
-        if self.ModConfig.jsonrpc == 1:
-            self.Base.create_thread(self.thread_start_jsonrpc, run_once=True)
-
-        return None
-
-    def __set_commands(self, commands:dict[int, list[str]]) -> None:
-        """### Rajoute les commandes du module au programme principal
-
-        Args:
-            commands (list): Liste des commandes du module
-        """
-        for level, com in commands.items():
-            for c in commands[level]:
-                if not c in self.Irc.commands:
-                    self.Irc.commands_level[level].append(c)
-                    self.Irc.commands.append(c)
-
-        return None
-
-    def __create_tables(self) -> None:
-        """Methode qui va créer la base de donnée si elle n'existe pas.
-           Une Session unique pour cette classe sera crée, qui sera utilisé dans cette classe / module
-        Args:
-            database_name (str): Nom de la base de données ( pas d'espace dans le nom )
-
-        Returns:
-            None: Aucun retour n'es attendu
-        """
-
-        table_logs = '''CREATE TABLE IF NOT EXISTS test_logs (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            datetime TEXT,
-            server_msg TEXT
-            )
-        '''
-
-        self.Base.db_execute_query(table_logs)
-        return None
-
-    def callback_sent_to_irc(self, json_response: str):
-
-        dnickname = self.Config.SERVICE_NICKNAME
-        dchanlog = self.Config.SERVICE_CHANLOG
-        green = self.Config.COLORS.green
-        nogc = self.Config.COLORS.nogc
-        bold = self.Config.COLORS.bold
-        red = self.Config.COLORS.red
-
-        if json_response.result == True:
-            self.Irc.sendPrivMsg(msg=f"[{bold}{green}JSONRPC{nogc}{bold}] Event activated", channel=dchanlog)
-            return None
-
-        level = json_response.result.level
-        subsystem = json_response.result.subsystem
-        event_id = json_response.result.event_id
-        log_source = json_response.result.log_source
-        msg = json_response.result.msg
-
-        build_msg = f"{green}{log_source}{nogc}: [{bold}{level}{bold}] {subsystem}.{event_id} - {msg}"
-
-        self.Irc.sendPrivMsg(msg=build_msg, channel=dchanlog)
-
-    def thread_start_jsonrpc(self):
-
-        if self.UnrealIrcdRpcLive.Error.code == 0:
-            self.UnrealIrcdRpcLive.subscribe(["all"])
-            self.subscribed = True
-        else:
-            self.Irc.sendPrivMsg(f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.UnrealIrcdRpcLive.Error.message}", self.Config.SERVICE_CHANLOG)
-
-    def __load_module_configuration(self) -> None:
-        """### Load Module Configuration
-        """
-        try:
-            # Build the default configuration model (Mandatory)
-            self.ModConfig = self.ModConfModel(jsonrpc=0)
-
-            # Sync the configuration with core configuration (Mandatory)
-            self.Base.db_sync_core_config(self.module_name, self.ModConfig)
-
-            return None
-
-        except TypeError as te:
-            self.Logs.critical(te)
-
-    def __update_configuration(self, param_key: str, param_value: str):
-        """Update the local and core configuration
-
-        Args:
-            param_key (str): The parameter key
-            param_value (str): The parameter value
-        """
-        self.Base.db_update_core_config(self.module_name, self.ModConfig, param_key, param_value)
-
-    def unload(self) -> None:
-        if self.UnrealIrcdRpcLive.Error.code != -1:
-            self.UnrealIrcdRpcLive.unsubscribe()
-        return None
-
-    def cmd(self, data:list) -> None:
-
-        return None
-
-    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
-
-        command = str(cmd[0]).lower()
-        dnickname = self.Config.SERVICE_NICKNAME
-        dchannel = self.Config.SERVICE_CHANLOG
-        fromuser = user
-        fromchannel = str(channel) if not channel is None else None
-
-        match command:
-
-            case 'jsonrpc':
-                try:
-                    option = str(cmd[1]).lower()
-
-                    if len(command) == 1:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} jsonrpc on')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} jsonrpc off')
-
-                    match option:
-
-                        case 'on':
-                            for thread in self.Base.running_threads:
-                                if thread.getName() == 'thread_start_jsonrpc':
-                                    if thread.is_alive():
-                                        self.Irc.sendPrivMsg(f"Thread {thread.getName()} is running", dchannel)
-                                    else:
-                                        self.Irc.sendPrivMsg(f"Thread {thread.getName()} is not running, wait untill the process will be cleaned up", dchannel)
-
-                            self.Base.create_thread(self.thread_start_jsonrpc, run_once=True)
-                            self.__update_configuration('jsonrpc', 1)
-
-                        case 'off':
-                            self.UnrealIrcdRpcLive.unsubscribe()
-                            self.__update_configuration('jsonrpc', 0)
-
-                except IndexError as ie:
-                    self.Logs.error(ie)
-
-            case 'jruser':
-                try:
-                    option = str(cmd[1]).lower()
-
-                    if len(command) == 1:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} jruser get nickname')
-
-                    match option:
-
-                        case 'get':
-                            nickname = str(cmd[2])
-                            uid_to_get = self.User.get_uid(nickname)
-                            if uid_to_get is None:
-                                return None
-
-                            rpc = self.Rpc
-
-                            UserInfo = rpc.User.get(uid_to_get)
-                            if rpc.Error.code != 0:
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :{rpc.Error.message}')
-                                return None
-
-                            chan_list = []
-                            for chan in UserInfo.user.channels:
-                                chan_list.append(chan.name)
-
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :UID                  : {UserInfo.id}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :NICKNAME             : {UserInfo.name}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :USERNAME             : {UserInfo.user.username}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :REALNAME             : {UserInfo.user.realname}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :MODES                : {UserInfo.user.modes}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :CHANNELS             : {chan_list}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :SECURITY GROUP       : {UserInfo.user.security_groups}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :REPUTATION           : {UserInfo.user.reputation}')
-
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :IP                   : {UserInfo.ip}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :COUNTRY CODE         : {UserInfo.geoip.country_code}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :ASN                  : {UserInfo.geoip.asn}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :ASNAME               : {UserInfo.geoip.asname}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :CLOAKED HOST         : {UserInfo.user.cloakedhost}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :HOSTNAME             : {UserInfo.hostname}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :VHOST                : {UserInfo.user.vhost}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :CLIENT PORT          : {UserInfo.client_port}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :SERVER PORT          : {UserInfo.server_port}')
-                            
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :CERTFP               : {UserInfo.tls.certfp}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :CIPHER               : {UserInfo.tls.cipher}')
-
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :IDLE SINCE           : {UserInfo.idle_since}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :CONNECTED SINCE      : {UserInfo.connected_since}')
-
-                except IndexError as ie:
-                    self.Logs.error(ie)
-
-            case 'ia':
-                try:
-
-                    self.Base.create_thread(self.thread_ask_ia, ('',))
-
-                    self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} : This is a notice to the sender ...")
-                    self.Irc.send2socket(f":{dnickname} PRIVMSG {fromuser} : This is private message to the sender ...")
-
-                    if not fromchannel is None:
-                        self.Irc.send2socket(f":{dnickname} PRIVMSG {fromchannel} : This is channel message to the sender ...")
-
-                    # How to update your module configuration
-                    self.__update_configuration('param_exemple2', 7)
-
-                    # Log if you want the result
-                    self.Logs.debug(f"Test logs ready")
-
-                except Exception as err:
-                    self.Logs.error(f"Unknown Error: {err}")

mods/mod_test.py

@@ -124,16 +124,8 @@ class Test():
         return None
 
     def cmd(self, data:list) -> None:
-        try:
-            cmd = list(data).copy()
 
         return None
-        except KeyError as ke:
-            self.Base.logs.error(f"Key Error: {ke}")
-        except IndexError as ie:
-            self.Base.logs.error(f"{ie} / {cmd} / length {str(len(cmd))}")
-        except Exception as err:
-            self.Base.logs.error(f"General Error: {err}")
 
     def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
 
@@ -160,4 +152,4 @@ class Test():
                     self.Logs.debug(f"Test logs ready")
 
                 except Exception as err:
-                    self.Logs.error(f"Unknown Error: {err}")
+                    self.Logs.error(f"{err}")

mods/mod_votekick.py

@@ -48,7 +48,8 @@ class Votekick():
 
         # Créer les nouvelles commandes du module
         self.commands_level = {
-            0: ['vote']
+            0: ['vote'],
+            1: ['activate', 'deactivate', 'submit', 'vote_stat', 'vote_verdict', 'vote_cancel']
         }
 
         # Init the module
@@ -59,7 +60,6 @@ class Votekick():
 
     def __init_module(self) -> None:
 
-        # Add admin object to retrieve admin users
         self.Admin = self.Irc.Admin
 
         self.__set_commands(self.commands_level)
@@ -229,11 +229,11 @@ class Votekick():
             if chan.channel_name == channel:
                 target_user = self.User.get_nickname(chan.target_user)
                 if chan.vote_for > chan.vote_against:
-                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll be kicked from the channel')
+                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll be kicked from the channel')
                     self.Irc.send2socket(f":{dnickname} KICK {channel} {target_user} Following the vote, you are not welcome in {channel}")
                     self.Channel.delete_user_from_channel(channel, self.User.get_uid(target_user))
                 elif chan.vote_for <= chan.vote_against:
-                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel')
+                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel')
 
                 # Init the system
                 if self.init_vote_system(channel):
@@ -242,16 +242,15 @@ class Votekick():
         return None
 
     def cmd(self, data:list) -> None:
-        try:
         cmd = list(data).copy()
-            return None
 
-        except KeyError as ke:
-            self.Base.logs.error(f"Key Error: {ke}")
-        except IndexError as ie:
-            self.Base.logs.error(f"{ie} / {cmd} / length {str(len(cmd))}")
-        except Exception as err:
-            self.Base.logs.error(f"General Error: {err}")
+        match cmd[2]:
+            case 'SJOIN':
+                pass
+            case _:
+                pass
+
+        return None
 
     def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
         # cmd is the command starting from the user command
@@ -265,17 +264,6 @@ class Votekick():
         match command:
             case 'vote':
                 option = str(cmd[1]).lower()
-
-                if len(command) == 1:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote activate #channel')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote deactivate #channel')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote +')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote -')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote cancel')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote status')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote submit nickname')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote verdict')
-
                 match option:
 
                     case 'activate':
@@ -472,10 +460,10 @@ class Votekick():
                                 if chan.channel_name == channel:
                                     target_user = self.User.get_nickname(chan.target_user)
                                     if chan.vote_for > chan.vote_against:
-                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll be kicked from the channel')
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll be kicked from the channel')
                                         self.Irc.send2socket(f":{dnickname} KICK {channel} {target_user} Following the vote, you are not welcome in {channel}")
                                     elif chan.vote_for <= chan.vote_against:
-                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel')
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel')
                                     
                                     # Init the system
                                     if self.init_vote_system(channel):
@@ -484,13 +472,3 @@ class Votekick():
                             self.Logs.error(f'{err}')
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option}')
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option}')
-
-                    case _:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote activate #channel')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote deactivate #channel')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote +')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote -')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote cancel')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote status')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote submit nickname')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote verdict')

version.json

@@ -1,9 +1,3 @@
 {
-    "version": "5.4.0",
-
-    "requests": "2.32.3",
-    "psutil": "6.0.0",
-    "unrealircd_rpc_py": "1.0.6",
-    "sqlalchemy": "2.0.35",
-    "faker": "30.1.0"
+    "version": "5.1.5"
 }