Merge pull request #35 from adator85/dev

V5.1.8

.gitignore

@@ -0,0 +1,7 @@
+.pyenv/
+db/
+logs/
+__pycache__/
+configuration.json
+install.log
+test.py

README.md

@@ -1,71 +1,128 @@
 # 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.
+Il permet aux opérateurs de gérer efficacement un canal, tout en offrant aux utilisateurs des outils d'interaction et de décision collective.
 
-Pré-requis :
+# Fonctionnalités principales
+    Commandes opérateurs complètes:
+        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.
+        Halfop/Dehalfop: Attribuer ou retirer les droits
+        Voice/Devoice/VoiceAll/DevoiceAll: Attribuer ou retirer les droits de voix.
 
-    - Python version >= 3.10
-    - Pip de python installé sur la machine
-    - Python librairies psutil & sqlalchemy & requests
-    - IRC Serveur Version >= UnrealIRCd-6.1.2.2
+    Système de quarantaine:
+        Mise en quarantaine: Isoler temporairement un utilisateur dans un canal privé.
+        Libération: Permettre à un utilisateur de quitter la quarantaine en entrant un code spécifique.
 
-Lancement de Defender :
+    Système de vote:
+        Kick: Les utilisateurs peuvent voter pour expulser un membre du canal.
+        Autres actions: Possibilité d'étendre le système de vote à d'autres actions (ban, etc.).
 
-    - Installer les librairies python : psutil & sqlalchemy & requests
-        - pip3 install psutil sqlalchemy requests ou pip install psutil sqlalchemy requests
-    - Ne pas lancer Defender en tant que root
-    - Créer plutot un service qui lancera Defender en tant qu'utilisateur non root
-    - Un fichier PID sera crée.
+# Installation automatique sur une machine Debian/Ubuntu
 
-# TO DO LIST
+    Prérequis:
+        - Système d'exploitation Linux (Windows non supporté)
+        - Un server UnrealIRCD corréctement configuré
+        - Python version 3.10 ou supérieure
 
-    - Optimiser le systeme de réputation:
-        - lorsque les users ce connectent, Ils entrent dans un salon puis une fraction de seconde le service les bans
+    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
+        $ python3 main.py
 
-# VERSION 1
+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:
 
-    [02.01.2024]
-        - Rajout de l'activation de la commande flood
-        - Les deux variables RESTART et INIT ont été déplacées vers le module Irc
-        - Nouvelle class Install:
-            - Le programme va vérifier si les 3 librairies sont installées (SQLAlchemy & requests & psutil)
-            - Une fois la vérification, il va mêtre a jour pip puis installera les dépendances
+    Bash:
+        $ systemctl --user [start | stop | restart | status] defender
 
-    [28.12.2023]
-        - Changement de méthode pour récuperer la version actuelle de python
-        - Ajout de la réponse a une PING de la part d'un utilisateur
-        - Installation automatique des packages sqlalchemy, requests et psutil
+# Installation manuelle:
+    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
+        - 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
 
-# BUG FIX
+# Configuration
 
-    [29.12.2023]
-        - Correction des messages de receptions trop longs > 4070 caractéres; 
-            - la méthode boucle et incrémente la réponse tant que le nombre de caractére reçu est supérieur a 4072
-        - Rajout du protocol MTAGS a la connexion du service
-            - Impact majeur dans la lecture des messages reçu du serveur ( PRIVMSG, SLOGS, UID, QUIT, NICK, PONG, SJOIN)
+    SERVEUR (Serveur)
+        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).
 
-# ALREADY IMPLEMENTED
+    SERVICE (Service)
+        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.
 
-    - Connexion en tant que service
-    - Gestion des messages reçus/envoyés par le serveur
-    - Gestion des caractéres spéciaux
-    - Gestion des logs (salon, fichiers et console)
-        - Mode debug : gestion des logs coté console
-    - Création du systeme de gestion de commandes
-        - Defender reconnait les commandes qui commence par le suffix définit dans la configuration
-        - Defender reconnait aussi reconnaitre les commandes qui viennent de /msg Defender [commande]
-    - Identifications
-        - Systéme d'identification [OK]
-        - Systéme de changement d'information [OK]
-        - Suppression d'un admin
-        - Systéme de groupe d'accés [OK]
+    COMPTE (Compte)
+        OWNER: Nom d'utilisateur possédant les droits d'administration du service.
+        PASSWORD: Mot de passe de l'administrateur du service.
 
-    Reputation security
-        - Activation ou désaction du systéme --> OK | .reputation ON/off
-        - Le user sera en mesure de changer la limite de la réputation --> OK | .reputation set limit 120
-        - Defender devra envoyer l'utilisateur dans un salon définit dans la configuration --> OK
-        - Defender bannira l'utilisateur de la totalité des salons, il le bannira aussi lorsqu'il souhaitera accéder a de nouveau salon --> OK
-        - Defender devra envoyer un message du type "Merci de taper cette comande /msg {nomdudefender} code {un code générer aléatoirement} --> OK
-        - Defender devra reconnaitre le code --> OK
-        - Defender devra liberer l'utilisateur et l'envoyer vers un salon définit dans la configuration --> OK
+    CANAUX (Canaux)
+        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.
+
+    SCANNER (Scanner)
+        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.
+        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).
+
+    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.
+
+# \\!/ 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
+
+# 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).
+
+# Contributions:
+    Les contributions sont les bienvenues ! N'hésitez pas à ouvrir des issues ou des pull requests.
+
+# Avertissement:
+    Ce bot est fourni "tel quel" sans aucune garantie. Utilisez-le à vos risques et périls.

core/Model.py

@@ -0,0 +1,498 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Union
+from core.base import Base
+
+class User:
+
+    @dataclass
+    class UserModel:
+        uid: str
+        nickname: str
+        username: str
+        hostname: str
+        umodes: str
+        vhost: str
+        isWebirc: bool
+        remote_ip: str
+        score_connexion: int
+        connexion_datetime: datetime = field(default=datetime.now())
+
+    UID_DB: list[UserModel] = []
+
+    def __init__(self, Base: Base) -> None:
+        self.log = Base.logs
+        pass
+
+    def insert(self, newUser: UserModel) -> bool:
+        """Insert a new User object
+
+        Args:
+            newUser (UserModel): New userModel object
+
+        Returns:
+            bool: True if inserted
+        """
+        result = False
+        exist = False
+
+        for record in self.UID_DB:
+            if record.uid == newUser.uid:
+                # If the user exist then return False and do not go further
+                exist = True
+                self.log.debug(f'{record.uid} already exist')
+                return result
+
+        if not exist:
+            self.UID_DB.append(newUser)
+            result = True
+            self.log.debug(f'New User Created: ({newUser})')
+
+        if not result:
+            self.log.critical(f'The User Object was not inserted {newUser}')
+
+        return result
+
+    def update(self, uid: str, newNickname: str) -> bool:
+        """Update the nickname starting from the UID
+
+        Args:
+            uid (str): UID of the user
+            newNickname (str): New nickname
+
+        Returns:
+            bool: True if updated
+        """
+        result = False
+
+        for record in self.UID_DB:
+            if record.uid == uid:
+                # If the user exist then update and return True and do not go further
+                record.nickname = newNickname
+                result = True
+                self.log.debug(f'UID ({record.uid}) has been updated with new nickname {newNickname}')
+                return result
+
+        if not result:
+            self.log.critical(f'The new nickname {newNickname} was not updated, uid = {uid}')
+
+        return result
+
+    def delete(self, uid: str) -> bool:
+        """Delete the User starting from the UID
+
+        Args:
+            uid (str): UID of the user
+
+        Returns:
+            bool: True if deleted
+        """
+        result = False
+
+        for record in self.UID_DB:
+            if record.uid == uid:
+                # If the user exist then remove and return True and do not go further
+                self.UID_DB.remove(record)
+                result = True
+                self.log.debug(f'UID ({record.uid}) has been deleted')
+                return result
+
+        if not result:
+            self.log.critical(f'The UID {uid} was not deleted')
+
+        return result
+
+    def get_User(self, uidornickname: str) -> Union[UserModel, None]:
+        """Get The User Object model
+
+        Args:
+            uidornickname (str): UID or Nickname
+
+        Returns:
+            UserModel|None: The UserModel Object | None
+        """
+        User = None
+        for record in self.UID_DB:
+            if record.uid == uidornickname:
+                User = record
+            elif record.nickname == uidornickname:
+                User = record
+
+        self.log.debug(f'Search {uidornickname} -- result = {User}')
+
+        return User
+
+    def get_uid(self, uidornickname:str) -> Union[str, None]:
+        """Get the UID of the user starting from the UID or the Nickname
+
+        Args:
+            uidornickname (str): UID or Nickname
+
+        Returns:
+            str|None: Return the UID
+        """
+        uid = None
+        for record in self.UID_DB:
+            if record.uid == uidornickname:
+                uid = record.uid
+            if record.nickname == uidornickname:
+                uid = record.uid
+
+        self.log.debug(f'The UID that you are looking for {uidornickname} has been found {uid}')
+        return uid
+
+    def get_nickname(self, uidornickname:str) -> Union[str, None]:
+        """Get the Nickname starting from UID or the nickname
+
+        Args:
+            uidornickname (str): UID or Nickname of the user
+
+        Returns:
+            str|None: the nickname
+        """
+        nickname = None
+        for record in self.UID_DB:
+            if record.nickname == uidornickname:
+                nickname = record.nickname
+            if record.uid == uidornickname:
+                nickname = record.nickname
+        self.log.debug(f'The value to check {uidornickname} -> {nickname}')
+        return nickname
+
+class Admin:
+
+    @dataclass
+    class AdminModel:
+        uid: str
+        nickname: str
+        username: str
+        hostname: str
+        umodes: str
+        vhost: str
+        level: int
+        connexion_datetime: datetime = field(default=datetime.now())
+
+    UID_ADMIN_DB: list[AdminModel] = []
+
+    def __init__(self, Base: Base) -> None:
+        self.log = Base.logs
+        pass
+
+    def insert(self, newAdmin: AdminModel) -> bool:
+
+        result = False
+        exist = False
+
+        for record in self.UID_ADMIN_DB:
+            if record.uid == newAdmin.uid:
+                # If the admin exist then return False and do not go further
+                exist = True
+                self.log.debug(f'{record.uid} already exist')
+                return result
+
+        if not exist:
+            self.UID_ADMIN_DB.append(newAdmin)
+            result = True
+            self.log.debug(f'UID ({newAdmin.uid}) has been created')
+
+        if not result:
+            self.log.critical(f'The User Object was not inserted {newAdmin}')
+
+        return result
+
+    def update(self, uid: str, newNickname: str) -> bool:
+
+        result = False
+
+        for record in self.UID_ADMIN_DB:
+            if record.uid == uid:
+                # If the admin exist, update and do not go further
+                record.nickname = newNickname
+                result = True
+                self.log.debug(f'UID ({record.uid}) has been updated with new nickname {newNickname}')
+                return result
+
+        if not result:
+            self.log.critical(f'The new nickname {newNickname} was not updated, uid = {uid}')
+
+        return result
+
+    def delete(self, uid: str) -> bool:
+
+        result = False
+
+        for record in self.UID_ADMIN_DB:
+            if record.uid == uid:
+                # If the admin exist, delete and do not go further
+                self.UID_ADMIN_DB.remove(record)
+                result = True
+                self.log.debug(f'UID ({record.uid}) has been created')
+                return result
+
+        if not result:
+            self.log.critical(f'The UID {uid} was not deleted')
+
+        return result
+
+    def get_Admin(self, uidornickname: str) -> Union[AdminModel, None]:
+
+        Admin = None
+        for record in self.UID_ADMIN_DB:
+            if record.uid == uidornickname:
+                Admin = record
+            elif record.nickname == uidornickname:
+                Admin = record
+
+        self.log.debug(f'Search {uidornickname} -- result = {Admin}')
+
+        return Admin
+
+    def get_uid(self, uidornickname:str) -> Union[str, None]:
+
+        uid = None
+        for record in self.UID_ADMIN_DB:
+            if record.uid == uidornickname:
+                uid = record.uid
+            if record.nickname == uidornickname:
+                uid = record.uid
+
+        self.log.debug(f'The UID that you are looking for {uidornickname} has been found {uid}')
+        return uid
+
+    def get_nickname(self, uidornickname:str) -> Union[str, None]:
+
+        nickname = None
+        for record in self.UID_ADMIN_DB:
+            if record.nickname == uidornickname:
+                nickname = record.nickname
+            if record.uid == uidornickname:
+                nickname = record.nickname
+        self.log.debug(f'The value {uidornickname} -- {nickname}')
+        return nickname
+
+class Channel:
+
+    @dataclass
+    class ChannelModel:
+        name: str
+        """### Channel name 
+        It include the #"""
+        uids: list
+        """### List of UID available in the channel
+        including their modes ~ @ % + *
+
+        Returns:
+            list: The list of UID's including theirs modes
+        """
+
+    UID_CHANNEL_DB: list[ChannelModel] = []
+    """List that contains all the Channels objects (ChannelModel)
+    """
+
+    def __init__(self, Base: Base) -> None:
+        self.log = Base.logs
+        self.Base = Base
+        pass
+
+    def insert(self, newChan: ChannelModel) -> bool:
+        """This method will insert a new channel and if the channel exist it will update the user list (uids)
+
+        Args:
+            newChan (ChannelModel): The channel model object
+
+        Returns:
+            bool: True if new channel, False if channel exist (However UID could be updated)
+        """
+        result = False
+        exist = False
+
+        for record in self.UID_CHANNEL_DB:
+            if record.name == newChan.name:
+                # If the channel exist, update the user list and do not go further
+                exist = True
+                self.log.debug(f'{record.name} already exist')
+
+                for user in newChan.uids:
+                    record.uids.append(user)
+
+                # Supprimer les doublons
+                del_duplicates = list(set(record.uids))
+                record.uids = del_duplicates
+                self.log.debug(f'Updating a new UID to the channel {record}')
+                return result
+
+
+        if not exist:
+            # If the channel don't exist, then create it
+            self.UID_CHANNEL_DB.append(newChan)
+            result = True
+            self.log.debug(f'New Channel Created: ({newChan})')
+
+        if not result:
+            self.log.critical(f'The Channel Object was not inserted {newChan}')
+
+        return result
+
+    def delete(self, name: str) -> bool:
+
+        result = False
+
+        for record in self.UID_CHANNEL_DB:
+            if record.name == name:
+                # If the channel exist, then remove it and return True.
+                # As soon as the channel found, return True and stop the loop
+                self.UID_CHANNEL_DB.remove(record)
+                result = True
+                self.log.debug(f'Channel ({record.name}) has been created')
+                return result
+
+        if not result:
+            self.log.critical(f'The Channel {name} was not deleted')
+
+        return result
+
+    def delete_user_from_channel(self, chan_name: str, uid:str) -> bool:
+        try:
+            result = False
+
+            for record in self.UID_CHANNEL_DB:
+                if record.name == chan_name:
+                    for user_id in record.uids:
+                        if self.Base.clean_uid(user_id) == uid:
+                            record.uids.remove(user_id)
+                            self.log.debug(f'The UID {uid} has been removed, here is the new object: {record}')
+                            result = True
+
+            for record in self.UID_CHANNEL_DB:
+                if not record.uids:
+                    self.UID_CHANNEL_DB.remove(record)
+                    self.log.debug(f'The Channel {record.name} has been removed, here is the new object: {record}')
+
+            return result
+        except ValueError as ve:
+            self.log.error(f'{ve}')
+
+    def delete_user_from_all_channel(self, uid:str) -> bool:
+        try:
+            result = False
+
+            for record in self.UID_CHANNEL_DB:
+                for user_id in record.uids:
+                    if self.Base.clean_uid(user_id) == self.Base.clean_uid(uid):
+                        record.uids.remove(user_id)
+                        self.log.debug(f'The UID {uid} has been removed, here is the new object: {record}')
+                        result = True
+
+            for record in self.UID_CHANNEL_DB:
+                if not record.uids:
+                    self.UID_CHANNEL_DB.remove(record)
+                    self.log.debug(f'The Channel {record.name} has been removed, here is the new object: {record}')
+
+            return result
+        except ValueError as ve:
+            self.log.error(f'{ve}')
+
+    def get_Channel(self, name: str) -> Union[ChannelModel, None]:
+
+        Channel = None
+        for record in self.UID_CHANNEL_DB:
+            if record.name == name:
+                Channel = record
+
+        self.log.debug(f'Search {name} -- result = {Channel}')
+
+        return Channel
+
+class Clones:
+
+    @dataclass
+    class CloneModel:
+        alive: bool
+        nickname: str
+        username: str
+
+    UID_CLONE_DB: list[CloneModel] = []
+
+    def __init__(self, Base: Base) -> None:
+        self.log = Base.logs
+
+    def insert(self, newCloneObject: CloneModel) -> bool:
+        """Create new Clone object
+
+        Args:
+            newCloneObject (CloneModel): New CloneModel object
+
+        Returns:
+            bool: True if inserted
+        """
+        result = False
+        exist = False
+
+        for record in self.UID_CLONE_DB:
+            if record.nickname == newCloneObject.nickname:
+                # If the user exist then return False and do not go further
+                exist = True
+                self.log.debug(f'{record.nickname} already exist')
+                return result
+
+        if not exist:
+            self.UID_CLONE_DB.append(newCloneObject)
+            result = True
+            self.log.debug(f'New Clone Object Created: ({newCloneObject})')
+
+        if not result:
+            self.log.critical(f'The Clone Object was not inserted {newCloneObject}')
+
+        return result
+
+    def delete(self, nickname: str) -> bool:
+        """Delete the Clone Object starting from the nickname
+
+        Args:
+            nickname (str): nickname of the clone
+
+        Returns:
+            bool: True if deleted
+        """
+        result = False
+
+        for record in self.UID_CLONE_DB:
+            if record.nickname == nickname:
+                # If the user exist then remove and return True and do not go further
+                self.UID_CLONE_DB.remove(record)
+                result = True
+                self.log.debug(f'The clone ({record.nickname}) has been deleted')
+                return result
+
+        if not result:
+            self.log.critical(f'The UID {nickname} was not deleted')
+
+        return result
+
+    def exists(self, nickname: str) -> bool:
+        """Check if the nickname exist
+
+        Args:
+            nickname (str): Nickname of the clone
+
+        Returns:
+            bool: True if the nickname exist
+        """
+        response = False
+
+        for cloneObject in self.UID_CLONE_DB:
+            if cloneObject.nickname == nickname:
+                response = True
+
+        return response
+
+    def kill(self, nickname:str) -> bool:
+
+        response = False
+
+        for cloneObject in self.UID_CLONE_DB:
+            if cloneObject.nickname == nickname:
+                cloneObject.alive = False # Kill the clone
+                response = True
+
+        return response

core/base.py

@@ -1,24 +1,19 @@
-import time, threading, os, random, socket, hashlib
+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
 from sqlalchemy import create_engine, Engine, Connection, CursorResult
 from sqlalchemy.sql import text
-from core.configuration import Config
+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
-    DB_SCHEMA:list[str] = {
-        'admins': 'sys_admins',
-        'commandes': 'sys_commandes',
-        'logs': 'sys_logs',
-        'modules': 'sys_modules'
-    }
-
-    def __init__(self, Config: Config) -> None:
+    def __init__(self, Config: ConfigDataModel) -> None:
 
         self.Config = Config                                    # Assigner l'objet de configuration
+        self.init_log_system()                                  # Demarrer le systeme de log
+        self.check_for_new_version(True)                        # Verifier si une nouvelle version est disponible
 
         self.running_timers:list[threading.Timer] = []          # Liste des timers en cours
         self.running_threads:list[threading.Thread] = []        # Liste des threads en cours
@@ -27,12 +22,88 @@ class Base:
 
         self.lock = threading.RLock()                           # Création du lock
 
+        self.install: bool = False                              # Initialisation de la variable d'installation
         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 get_unixtime(self)->int:
+    def __set_current_defender_version(self) -> None:
+        """This will put the current version of Defender
+        located in version.json
+        """
+
+        version_filename = f'.{os.sep}version.json'
+        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
+
+    def __get_latest_defender_version(self) -> None:
+        try:
+            self.logs.debug(f'Looking for a new version available on Github')
+            # print(f'===> Looking for a new version available on Github')
+            token = ''
+            json_url = f'https://raw.githubusercontent.com/adator85/IRC_DEFENDER_MODULES/main/version.json'
+            headers = {
+                'Authorization': f'token {token}',
+                'Accept': 'application/vnd.github.v3.raw'  # Indique à GitHub que nous voulons le contenu brut du fichier
+            }
+
+            if token == '':
+                response = requests.get(json_url, timeout=self.Config.API_TIMEOUT)
+            else:
+                response = requests.get(json_url, headers=headers, timeout=self.Config.API_TIMEOUT)
+
+            response.raise_for_status()  # Vérifie si la requête a réussi
+            json_response:dict = response.json()
+            # self.LATEST_DEFENDER_VERSION = json_response["version"]
+            self.Config.latest_version = json_response['version']
+
+            return None
+        except requests.HTTPError as err:
+            self.logs.error(f'Github not available to fetch latest version: {err}')
+        except:
+            self.logs.warning(f'Github not available to fetch latest version')
+
+    def check_for_new_version(self, online:bool) -> bool:
+        try:
+            self.logs.debug(f'Checking for a new service version')
+
+            # Assigner la version actuelle de Defender
+            self.__set_current_defender_version()
+            # Récuperer la dernier version disponible dans github
+            if online:
+                self.logs.debug(f'Retrieve the latest version from Github')
+                self.__get_latest_defender_version()
+
+            isNewVersion = False
+            latest_version = self.Config.latest_version
+            current_version = self.Config.current_version
+
+            curr_major , curr_minor, curr_patch = current_version.split('.')
+            last_major, last_minor, last_patch = latest_version.split('.')
+
+            if int(last_major) > int(curr_major):
+                self.logs.info(f'New version available: {current_version} >>> {latest_version}')
+                isNewVersion = True
+            elif int(last_major) == int(curr_major) and int(last_minor) > int(curr_minor):
+                self.logs.info(f'New version available: {current_version} >>> {latest_version}')
+                isNewVersion = True
+            elif int(last_major) == int(curr_major) and int(last_minor) == int(curr_minor) and int(last_patch) > int(curr_patch):
+                self.logs.info(f'New version available: {current_version} >>> {latest_version}')
+                isNewVersion = True
+            else:
+                isNewVersion = False
+
+            return isNewVersion
+        except ValueError as ve:
+            self.logs.error(f'Impossible to convert in version number : {ve}')
+
+    def get_unixtime(self) -> int:
         """
         Cette fonction retourne un UNIXTIME de type 12365456
         Return: Current time in seconds since the Epoch (int)
@@ -40,13 +111,23 @@ class Base:
         unixtime = int( time.time() )
         return unixtime
 
-    def get_datetime(self)->str:
+    def get_datetime(self) -> str:
         """
         Retourne une date au format string (24-12-2023 20:50:59)
         """
         currentdate = datetime.now().strftime('%d-%m-%Y %H:%M:%S')
         return currentdate
 
+    def get_all_modules(self) -> list:
+
+        all_files = os.listdir('mods/')
+        all_modules: list = []
+        for module in all_files:
+            if module.endswith('.py') and not module == '__init__.py':
+                all_modules.append(module.replace('.py', '').lower())
+
+        return all_modules
+
     def create_log(self, log_message: str) -> None:
         """Enregiste les logs
 
@@ -56,19 +137,43 @@ class Base:
         Returns:
             None: Aucun retour
         """
-        sql_insert = f"INSERT INTO {self.DB_SCHEMA['logs']} (datetime, server_msg) VALUES (:datetime, :server_msg)"
+        sql_insert = f"INSERT INTO {self.Config.table_log} (datetime, server_msg) VALUES (:datetime, :server_msg)"
         mes_donnees = {'datetime': str(self.get_datetime()),'server_msg': f'{log_message}'}
         self.db_execute_query(sql_insert, mes_donnees)
 
         return None
 
+    def init_log_system(self) -> None:
+        # Create folder if not available
+        logs_directory = f'logs{os.sep}'
+        if not os.path.exists(f'{logs_directory}'):
+            os.makedirs(logs_directory)
+
+        # Init logs object
+        self.logs = logging
+        self.logs.basicConfig(level=self.Config.DEBUG_LEVEL,
+                              filename='logs/defender.log',
+                              encoding='UTF-8',
+                              format='%(asctime)s - %(levelname)s - %(filename)s - %(lineno)d - %(funcName)s - %(message)s')
+
+        self.logs.info('#################### STARTING DEFENDER ####################')
+
+        return None
+
     def log_cmd(self, user_cmd:str, cmd:str) -> None:
         """Enregistre les commandes envoyées par les utilisateurs
 
         Args:
             cmd (str): la commande a enregistrer
         """
-        insert_cmd_query = f"INSERT INTO {self.DB_SCHEMA['commandes']} (datetime, user, commande) VALUES (:datetime, :user, :commande)"
+        cmd_list = cmd.split()
+        if len(cmd_list) == 3:
+            if cmd_list[0].replace('.', '') == 'auth':
+                cmd_list[1] = '*******'
+                cmd_list[2] = '*******'
+                cmd = ' '.join(cmd_list)
+
+        insert_cmd_query = f"INSERT INTO {self.Config.table_commande} (datetime, user, commande) VALUES (:datetime, :user, :commande)"
         mes_donnees = {'datetime': self.get_datetime(), 'user': user_cmd, 'commande': cmd}
         self.db_execute_query(insert_cmd_query, mes_donnees)
 
@@ -83,8 +188,8 @@ class Base:
         Returns:
             bool: True si le module existe déja dans la base de données sinon False
         """
-        query = f"SELECT id FROM {self.DB_SCHEMA['modules']} WHERE module = :module"
-        mes_donnes = {'module': module_name}
+        query = f"SELECT id FROM {self.Config.table_module} WHERE module_name = :module_name"
+        mes_donnes = {'module_name': module_name}
         results = self.db_execute_query(query, mes_donnes)
 
         if results.fetchall():
@@ -92,7 +197,7 @@ class Base:
         else:
             return False
 
-    def db_record_module(self, user_cmd:str, module_name:str) -> None:
+    def db_record_module(self, user_cmd:str, module_name:str, isdefault:int = 0) -> None:
         """Enregistre les modules dans la base de données
 
         Args:
@@ -100,13 +205,12 @@ class Base:
         """
 
         if not self.db_isModuleExist(module_name):
-            self.__debug(f"Le module {module_name} n'existe pas alors ont le créer")
-            insert_cmd_query = f"INSERT INTO {self.DB_SCHEMA['modules']} (datetime, user, module) VALUES (:datetime, :user, :module)"
-            mes_donnees = {'datetime': self.get_datetime(), 'user': user_cmd, 'module': module_name}
+            self.logs.debug(f"Le module {module_name} n'existe pas alors ont le créer")
+            insert_cmd_query = f"INSERT INTO {self.Config.table_module} (datetime, user, module_name, isdefault) VALUES (:datetime, :user, :module_name, :isdefault)"
+            mes_donnees = {'datetime': self.get_datetime(), 'user': user_cmd, 'module_name': module_name, 'isdefault': isdefault}
             self.db_execute_query(insert_cmd_query, mes_donnees)
-            # self.db_close_session(self.session)
         else:
-            self.__debug(f"Le module {module_name} existe déja dans la base de données")
+            self.logs.debug(f"Le module {module_name} existe déja dans la base de données")
 
         return False
 
@@ -116,28 +220,196 @@ class Base:
         Args:
             cmd (str): le module a enregistrer
         """
-        insert_cmd_query = f"DELETE FROM {self.DB_SCHEMA['modules']} WHERE module = :module"
-        mes_donnees = {'module': module_name}
+        insert_cmd_query = f"DELETE FROM {self.Config.table_module} WHERE module_name = :module_name"
+        mes_donnees = {'module_name': module_name}
         self.db_execute_query(insert_cmd_query, mes_donnees)
 
         return False
 
+    def db_sync_core_config(self, module_name: str, dataclassObj: object) -> bool:
+        """Sync module local parameters with the database
+        if new module then local param will be stored in the database
+        if old module then db param will be moved to the local dataclassObj
+        if new local param it will be stored in the database
+        if local param was removed then it will also be removed from the database
+
+        Args:
+            module_name (str): The module name ex. mod_defender
+            dataclassObj (object): The Dataclass object
+
+        Returns:
+            bool: _description_
+        """
+        try:
+            response = True
+            current_date = self.get_datetime()
+            core_table = self.Config.table_config
+
+            # Add local parameters to DB
+            for field in fields(dataclassObj):
+                param_key = field.name
+                param_value = str(getattr(dataclassObj, field.name))
+
+                param_to_search = {'module_name': module_name, 'param_key': param_key}
+
+                search_query = f'''SELECT id FROM {core_table} WHERE module_name = :module_name AND param_key = :param_key'''
+                excecute_search_query = self.db_execute_query(search_query, param_to_search)
+                result_search_query = excecute_search_query.fetchone()
+
+                if result_search_query is None:
+                    # If param and module_name doesn't exist create the record
+                    param_to_insert = {'datetime': current_date,'module_name': module_name,
+                                       'param_key': param_key,'param_value': param_value
+                                    }
+
+                    insert_query = f'''INSERT INTO {core_table} (datetime, module_name, param_key, param_value) 
+                                        VALUES (:datetime, :module_name, :param_key, :param_value)
+                                        '''
+                    execution = self.db_execute_query(insert_query, param_to_insert)
+
+                    if execution.rowcount > 0:
+                        self.logs.debug(f'New parameter added to the database: {param_key} --> {param_value}')
+
+            # Delete from DB unused parameter
+            query_select = f"SELECT module_name, param_key, param_value FROM {core_table} WHERE module_name = :module_name"
+            parameter = {'module_name': module_name}
+            execute_query_select = self.db_execute_query(query_select, parameter)
+            result_query_select = execute_query_select.fetchall()
+
+            for result in result_query_select:
+                db_mod_name, db_param_key, db_param_value = result
+                if not hasattr(dataclassObj, db_param_key):
+                    mes_donnees = {'param_key': db_param_key, 'module_name': db_mod_name}
+                    execute_delete = self.db_execute_query(f'DELETE FROM {core_table} WHERE module_name = :module_name and param_key = :param_key', mes_donnees)
+                    row_affected = execute_delete.rowcount
+                    if row_affected > 0:
+                        self.logs.debug(f'A parameter has been deleted from the database: {db_param_key} --> {db_param_value} | Mod: {db_mod_name}')
+
+            # Sync local variable with Database
+            query = f"SELECT param_key, param_value FROM {core_table} WHERE module_name = :module_name"
+            parameter = {'module_name': module_name}
+            response = self.db_execute_query(query, parameter)
+            result = response.fetchall()
+
+            for param, value in result:
+                if type(getattr(dataclassObj, param)) == list:
+                    value = ast.literal_eval(value)
+
+                setattr(dataclassObj, param, self.int_if_possible(value))
+
+            return response
+
+        except AttributeError as attrerr:
+            self.logs.error(f'Attribute Error: {attrerr}')
+        except Exception as err:
+            self.logs.error(err)
+            return False
+
+    def db_update_core_config(self, module_name:str, dataclassObj: object, param_key:str, param_value: str) -> bool:
+
+        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")
+            return False
+
+        mes_donnees = {'module_name': module_name, 'param_key': param_key, 'param_value': param_value}
+        search_param_query = f"SELECT id FROM {core_table} WHERE module_name = :module_name AND param_key = :param_key"
+        result = self.db_execute_query(search_param_query, mes_donnees)
+        isParamExist = result.fetchone()
+
+        if not isParamExist is None:
+            mes_donnees = {'datetime': self.get_datetime(),
+                           'module_name': module_name,
+                           'param_key': param_key,
+                           'param_value': param_value
+                           }
+            query = f'''UPDATE {core_table} SET datetime = :datetime, param_value = :param_value WHERE module_name = :module_name AND param_key = :param_key'''
+            update = self.db_execute_query(query, mes_donnees)
+            updated_rows = update.rowcount
+            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}')
+
+        self.logs.debug(dataclassObj)
+
+        return True
+
+    def db_query_channel(self, action: Literal['add','del'], module_name: str, channel_name: str) -> bool:
+        """You can add a channel or delete a channel.
+
+        Args:
+            action (Literal['add','del']): Action on the database
+            module_name (str): The module name (mod_test)
+            channel_name (str): The channel name (With #)
+
+        Returns:
+            bool: True if action done
+        """
+        try:
+            channel_name = channel_name.lower() if self.Is_Channel(channel_name) else None
+            core_table = 'core_channel'
+
+            if not channel_name:
+                self.logs.warn(f'The channel [{channel_name}] is not correct')
+                return False
+
+            match action:
+
+                case 'add':
+                    mes_donnees = {'module_name': module_name, 'channel_name': channel_name}
+                    response = self.db_execute_query(f"SELECT id FROM {core_table} WHERE module_name = :module_name AND channel_name = :channel_name", mes_donnees)
+                    isChannelExist = response.fetchone()
+
+                    if isChannelExist is None:
+                        mes_donnees = {'datetime': self.get_datetime(), 'channel_name': channel_name, 'module_name': module_name}
+                        insert = self.db_execute_query(f"INSERT INTO {core_table} (datetime, channel_name, module_name) VALUES (:datetime, :channel_name, :module_name)", mes_donnees)
+                        if insert.rowcount:
+                            self.logs.debug(f'New channel added: channel={channel_name} / module_name={module_name}')
+                            return True
+                    else:
+                        return False
+                    pass
+
+                case 'del':
+                    mes_donnes = {'channel_name': channel_name, 'module_name': module_name}
+                    response = self.db_execute_query(f"DELETE FROM {core_table} WHERE channel_name = :channel_name AND module_name = :module_name", mes_donnes)
+
+                    if response.rowcount > 0:
+                        self.logs.debug(f'Channel deleted: channel={channel_name} / module: {module_name}')
+                        return True
+                    else:
+                        
+                        return False
+
+                case _:
+                    return False
+
+        except Exception as err:
+            self.logs.error(err)
+
     def db_create_first_admin(self) -> None:
 
-        user = self.db_execute_query(f"SELECT id FROM {self.DB_SCHEMA['admins']}")
+        user = self.db_execute_query(f"SELECT id FROM {self.Config.table_admin}")
         if not user.fetchall():
             admin = self.Config.OWNER
             password = self.crypt_password(self.Config.PASSWORD)
 
-            mes_donnees = {'createdOn': self.get_datetime(), 'user': admin, 'password': password, 'hostname': '*', 'vhost': '*', 'level': 5}
+            mes_donnees = {'createdOn': self.get_datetime(), 
+                           'user': admin, 
+                           'password': password, 
+                           'hostname': '*', 
+                           'vhost': '*', 
+                           'level': 5
+                           }
             self.db_execute_query(f"""
-                                  INSERT INTO {self.DB_SCHEMA['admins']} 
+                                  INSERT INTO {self.Config.table_admin} 
                                   (createdOn, user, password, hostname, vhost, level) 
                                   VALUES 
                                   (:createdOn, :user, :password, :hostname, :vhost, :level)"""
                                   , mes_donnees)
 
-        pass
+        return None
 
     def create_timer(self, time_to_wait: float, func: object, func_args: tuple = ()) -> None:
 
@@ -148,126 +420,142 @@ class Base:
 
             self.running_timers.append(t)
 
-            self.__debug(f"Timer ID : {str(t.ident)} | Running Threads : {len(threading.enumerate())}")
+            self.logs.debug(f"Timer ID : {str(t.ident)} | Running Threads : {len(threading.enumerate())}")
 
         except AssertionError as ae:
-            self.__debug(f'Assertion Error -> {ae}')
+            self.logs.error(f'Assertion Error -> {ae}')
 
-    def create_thread(self, func:object, func_args: tuple = ()) -> 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:
+            func (object): The method/function you want to execute via this thread
+            func_args (tuple, optional): Arguments of the function/method. Defaults to ().
+            run_once (bool, optional): If you want to ensure that this method/function run once. Defaults to False.
+        """
         try:
             func_name = func.__name__
-            # if func_name in self.running_threads:
-            #     print(f"HeartBeat is running")
-            #     return None
+
+            if run_once:
+                for thread in self.running_threads:
+                    if thread.getName() == func_name:
+                        return None
 
             th = threading.Thread(target=func, args=func_args, name=str(func_name), daemon=True)
             th.start()
 
             self.running_threads.append(th)
-            self.__debug(f"Thread ID : {str(th.ident)} | Thread name : {th.getName()} | Running Threads : {len(threading.enumerate())}")
+            self.logs.debug(f"Thread ID : {str(th.ident)} | Thread name : {th.getName()} | Running Threads : {len(threading.enumerate())}")
 
         except AssertionError as ae:
-            self.__debug(f'Assertion Error -> {ae}')
+            self.logs.error(f'{ae}')
 
     def garbage_collector_timer(self) -> None:
         """Methode qui supprime les timers qui ont finis leurs job
         """
         try:
-            self.__debug(f"=======> Checking for Timers to stop")
-            # print(f"{self.running_timers}")
+
             for timer in self.running_timers:
                 if not timer.is_alive():
                     timer.cancel()
                     self.running_timers.remove(timer)
-                    self.__debug(f"Timer {str(timer)} removed")
+                    self.logs.info(f"Timer {str(timer)} removed")
                 else:
-                    self.__debug(f"===> Timer {str(timer)} Still running ...")
+                    self.logs.debug(f"===> Timer {str(timer)} Still running ...")
 
         except AssertionError as ae:
-            print(f'Assertion Error -> {ae}')
+            self.logs.error(f'Assertion Error -> {ae}')
 
     def garbage_collector_thread(self) -> None:
         """Methode qui supprime les threads qui ont finis leurs job
         """
         try:
-            self.__debug(f"=======> Checking for Threads to stop")
             for thread in self.running_threads:
                 if thread.getName() != 'heartbeat':
                     if not thread.is_alive():
                         self.running_threads.remove(thread)
-                        self.__debug(f"Thread {str(thread.getName())} {str(thread.native_id)} removed")
+                        self.logs.info(f"Thread {str(thread.getName())} {str(thread.native_id)} removed")
 
             # print(threading.enumerate())
         except AssertionError as ae:
-            self.__debug(f'Assertion Error -> {ae}')
+            self.logs.error(f'Assertion Error -> {ae}')
 
     def garbage_collector_sockets(self) -> None:
 
-        self.__debug(f"=======> Checking for Sockets to stop")
         for soc in self.running_sockets:
             while soc.fileno() != -1:
-                self.__debug(soc.fileno())
+                self.logs.debug(soc.fileno())
                 soc.close()
 
             soc.close()
             self.running_sockets.remove(soc)
-            self.__debug(f"Socket ==> closed {str(soc.fileno())}")
+            self.logs.debug(f"Socket ==> closed {str(soc.fileno())}")
 
     def shutdown(self) -> None:
         """Methode qui va préparer l'arrêt complêt du service
         """
         # Nettoyage des timers
-        print(f"=======> Checking for Timers to stop")
+        self.logs.debug(f"=======> Checking for Timers to stop")
         for timer in self.running_timers:
             while timer.is_alive():
-                print(f"> waiting for {timer.getName()} to close")
+                self.logs.debug(f"> waiting for {timer.getName()} to close")
                 timer.cancel()
                 time.sleep(0.2)
             self.running_timers.remove(timer)
-            print(f"> Cancelling {timer.getName()} {timer.native_id}")
+            self.logs.debug(f"> Cancelling {timer.getName()} {timer.native_id}")
 
-        print(f"=======> Checking for Threads to stop")
+        self.logs.debug(f"=======> Checking for Threads to stop")
         for thread in self.running_threads:
             if thread.getName() == 'heartbeat' and thread.is_alive():
                 self.execute_periodic_action()
-                print(f"> Running the last periodic action")
+                self.logs.debug(f"> Running the last periodic action")
             self.running_threads.remove(thread)
-            print(f"> Cancelling {thread.getName()} {thread.native_id}")
+            self.logs.debug(f"> Cancelling {thread.getName()} {thread.native_id}")
 
-        print(f"=======> Checking for Sockets to stop")
+        self.logs.debug(f"=======> Checking for Sockets to stop")
         for soc in self.running_sockets:
             soc.close()
             while soc.fileno() != -1:
                 soc.close()
 
             self.running_sockets.remove(soc)
-            print(f"> Socket ==> closed {str(soc.fileno())}")
+            self.logs.debug(f"> Socket ==> closed {str(soc.fileno())}")
 
-        pass
+        return None
 
     def db_init(self) -> tuple[Engine, Connection]:
 
-        db_directory = self.Config.DEFENDER_DB_PATH
-        full_path_db = self.Config.DEFENDER_DB_PATH + self.Config.DEFENDER_DB_NAME
+        db_directory = self.Config.db_path
+        full_path_db = self.Config.db_path + self.Config.db_name
 
         if not os.path.exists(db_directory):
+            self.install = True
             os.makedirs(db_directory)
 
         engine = create_engine(f'sqlite:///{full_path_db}.db', echo=False)
         cursor = engine.connect()
-
+        self.logs.info("database connexion has been initiated")
         return engine, cursor
 
     def __create_db(self) -> None:
 
-        table_logs = f'''CREATE TABLE IF NOT EXISTS {self.DB_SCHEMA['logs']} (
+        table_core_log = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_log} (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             datetime TEXT,
             server_msg TEXT
             ) 
         '''
 
-        table_cmds = f'''CREATE TABLE IF NOT EXISTS {self.DB_SCHEMA['commandes']} (
+        table_core_config = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_config} (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            datetime TEXT,
+            module_name TEXT,
+            param_key TEXT,
+            param_value TEXT
+            )
+        '''
+
+        table_core_log_command = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_commande} (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             datetime TEXT,
             user TEXT,
@@ -275,15 +563,24 @@ class Base:
             )
         '''
 
-        table_modules = f'''CREATE TABLE IF NOT EXISTS {self.DB_SCHEMA['modules']} (
+        table_core_module = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_module} (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             datetime TEXT,
             user TEXT,
-            module TEXT
+            module_name TEXT,
+            isdefault INTEGER
+            )
+        '''
+        
+        table_core_channel = '''CREATE TABLE IF NOT EXISTS core_channel (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            datetime TEXT,
+            module_name TEXT,
+            channel_name TEXT
             )
         '''
 
-        table_admins = f'''CREATE TABLE IF NOT EXISTS {self.DB_SCHEMA['admins']} (
+        table_core_admin = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_admin} (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             createdOn TEXT,
             user TEXT,
@@ -294,10 +591,17 @@ class Base:
             )
         '''
 
-        self.db_execute_query(table_logs)
-        self.db_execute_query(table_cmds)
-        self.db_execute_query(table_modules)
-        self.db_execute_query(table_admins)
+        self.db_execute_query(table_core_log)
+        self.db_execute_query(table_core_log_command)
+        self.db_execute_query(table_core_module)
+        self.db_execute_query(table_core_admin)
+        self.db_execute_query(table_core_channel)
+        self.db_execute_query(table_core_config)
+
+        if self.install:
+            self.db_record_module('sys', 'mod_command', 1)
+            self.db_record_module('sys', 'mod_defender', 1)
+            self.install = False
 
         return None
 
@@ -319,7 +623,7 @@ class Base:
         try:
             self.cursor.close()
         except AttributeError as ae:
-            self.__debug(f"Attribute Error : {ae}")
+            self.logs.error(f"Attribute Error : {ae}")
 
     def crypt_password(self, password:str) -> str:
         """Retourne un mot de passe chiffré en MD5
@@ -352,6 +656,39 @@ class Base:
         except TypeError:
             return value
 
+    def is_valid_ip(self, ip_to_control:str) -> bool:
+
+        try:
+            if ip_to_control in self.Config.WHITELISTED_IP:
+                return False
+
+            ipaddress.ip_address(ip_to_control)
+            return True
+        except ValueError:
+            return False
+
+    def decode_ip(self, ip_b64encoded: str) -> Union[str, None]:
+
+        binary_ip = b64decode(ip_b64encoded)
+        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 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.
@@ -367,7 +704,7 @@ class Base:
             # Run Garbage Collector Timer
             self.garbage_collector_timer()
             self.garbage_collector_thread()
-            self.garbage_collector_sockets()
+            # self.garbage_collector_sockets()
             return None
 
         for key, value in self.periodic_func.items():
@@ -380,9 +717,43 @@ class Base:
         # Vider le dictionnaire de fonction
         self.periodic_func.clear()
 
-    def __debug(self, debug_msg:str) -> None:
+    def clean_uid(self, uid:str) -> str:
+        """Clean UID by removing @ / % / + / ~ / * / :
 
-        if self.Config.DEBUG == 1:
-            print(f"[{self.get_datetime()}] - {debug_msg}")
+        Args:
+            uid (str): The UID to clean
 
-        return None
+        Returns:
+            str: Clean UID without any sign
+        """
+
+        pattern = fr'[:|@|%|\+|~|\*]*'
+        parsed_UID = re.sub(pattern, '', uid)
+
+        return parsed_UID
+
+    def Is_Channel(self, channelToCheck: str) -> bool:
+        """Check if the string has the # caractere and return True if this is a channel
+
+        Args:
+            channelToCheck (str): The string to test if it is a channel or not
+
+        Returns:
+            bool: True if the string is a channel / False if this is not a channel
+        """
+        try:
+            
+            if channelToCheck is None:
+                return False
+
+            pattern = fr'^#'
+            isChannel = re.findall(pattern, channelToCheck)
+
+            if not isChannel:
+                return False
+            else:
+                return True
+        except TypeError as te:
+            self.logs.error(f'TypeError: [{channelToCheck}] - {te}')
+        except Exception as err:
+            self.logs.error(f'Error Not defined: {err}')

core/connection.py

@@ -0,0 +1,224 @@
+import socket, ssl
+from ssl import SSLSocket
+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, 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.channels:list[str] = channels
+        self.CHARSET = ['utf-8', 'iso-8859-1']
+        self.Clones = CloneObject
+        self.signal: bool = True
+        for clone in self.Clones.UID_CLONE_DB:
+            if clone.nickname == nickname:
+                self.currentCloneObject = clone
+
+        self.create_socket(self.Config.SERVEUR_IP, self.Config.SERVEUR_HOSTNAME, server_port, ssl)
+        self.send_connection_information_to_server(self.IrcSocket)
+        self.connect()
+
+    def create_socket(self, server_ip: str,  server_hostname: str, server_port: int, ssl: bool = False) -> bool:
+
+        try:
+            soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM or socket.SOCK_NONBLOCK)
+            connexion_information = (server_ip, server_port)
+
+            if ssl:
+                # Créer un object ssl
+                ssl_context = self.__ssl_context()
+                ssl_connexion = ssl_context.wrap_socket(soc, server_hostname=server_hostname)
+                ssl_connexion.connect(connexion_information)
+                self.IrcSocket:SSLSocket = ssl_connexion
+                self.SSL_VERSION = self.IrcSocket.version()
+                self.Base.logs.debug(f'> Connexion en mode SSL : Version = {self.SSL_VERSION}')
+            else:
+                soc.connect(connexion_information)
+                self.IrcSocket:socket.socket = soc
+                self.Base.logs.debug(f'> Connexion en mode normal')
+
+            return True
+
+        except ssl.SSLEOFError as soe:
+            self.Base.logs.critical(f"SSLEOFError __create_socket: {soe} - {soc.fileno()}")
+            return False
+        except ssl.SSLError as se:
+            self.Base.logs.critical(f"SSLError __create_socket: {se} - {soc.fileno()}")
+            return False
+        except OSError as oe:
+            self.Base.logs.critical(f"OSError __create_socket: {oe} - {soc.fileno()}")
+            return False
+        except AttributeError as ae:
+            self.Base.logs.critical(f"AttributeError __create_socket: {ae} - {soc.fileno()}")
+            return False
+
+    def send2socket(self, send_message:str) -> None:
+        """Envoit les commandes à envoyer au serveur.
+
+        Args:
+            string (Str): contient la commande à envoyer au serveur.
+        """
+        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}')
+
+        except UnicodeDecodeError:
+            self.Base.logs.error(f'Decode Error try iso-8859-1 - message: {send_message}')
+            self.IrcSocket.send(f"{send_message}\r\n".encode(self.CHARSET[1],'replace'))
+        except UnicodeEncodeError:
+            self.Base.logs.error(f'Encode Error try iso-8859-1 - message: {send_message}')
+            self.IrcSocket.send(f"{send_message}\r\n".encode(self.CHARSET[1],'replace'))
+        except AssertionError as ae:
+            self.Base.logs.warning(f'Assertion Error {ae} - message: {send_message}')
+        except ssl.SSLEOFError as soe:
+            self.Base.logs.error(f"SSLEOFError: {soe} - {send_message}")
+        except ssl.SSLError as se:
+            self.Base.logs.error(f"SSLError: {se} - {send_message}")
+        except OSError as oe:
+            self.Base.logs.error(f"OSError: {oe} - {send_message}")
+
+    def send_connection_information_to_server(self, writer:Union[socket.socket, SSLSocket]) -> None:
+        """Créer le link et envoyer les informations nécessaires pour la 
+        connexion au serveur.
+
+        Args:
+            writer (StreamWriter): permet l'envoi des informations au serveur.
+        """
+        try:
+            nickname = self.nickname
+            username = self.username
+
+            # 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} :{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')
+
+            return None
+        except AttributeError as ae:
+            self.Base.logs.critical(f'{ae}')
+
+    def connect(self):
+        try:
+
+            while self.signal:
+                try:
+                    # 4072 max what the socket can grab
+                    buffer_size = self.IrcSocket.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF)
+                    data_in_bytes = self.IrcSocket.recv(buffer_size)
+                    data = data_in_bytes.splitlines(True)
+                    count_bytes = len(data_in_bytes)
+
+                    while count_bytes > 4070:
+                        # If the received message is > 4070 then loop and add the value to the variable
+                        new_data = self.IrcSocket.recv(buffer_size)
+                        data_in_bytes += new_data
+                        count_bytes = len(new_data)
+
+                    data = data_in_bytes.splitlines(True)
+
+                    if not data:
+                        break
+
+                    self.parser(data)
+                except ssl.SSLEOFError as soe:
+                    self.Base.logs.error(f"SSLEOFError __connect_to_irc: {soe} - {data}")
+                    self.signal = False
+                except ssl.SSLError as se:
+                    self.Base.logs.error(f"SSLError __connect_to_irc: {se} - {data}")
+                    self.signal = False
+                except OSError as oe:
+                    self.Base.logs.error(f"OSError __connect_to_irc: {oe} - {data}")
+                    self.signal = False
+
+            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}')
+        except ValueError as ve:
+            self.Base.logs.error(f'Value Error : {ve}')
+        except ssl.SSLEOFError as soe:
+            self.Base.logs.error(f"OS Error __connect_to_irc: {soe}")
+        except AttributeError as atte:
+            self.Base.logs.critical(f"{atte}")
+        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()
+                self.signal = self.currentCloneObject.alive
+                # print(response)
+
+                match response[0]:
+                    case 'PING':
+                        pong = str(response[1]).replace(':','')
+                        self.send2socket(f"PONG :{pong}")
+                        return None
+                    case 'ERROR':
+                        error_value = str(response[1]).replace(':','')
+                        if error_value == 'Closing':
+                            self.signal = False
+
+                match response[1]:
+                    case '376':
+                        for channel in self.channels:
+                            self.send2socket(f"JOIN {channel}")
+                        return None
+                    case 'PRIVMSG':
+                        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 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])
+                                final_message = ' '.join(message)
+
+                                self.send2socket(f"PRIVMSG {clone_channel} :{final_message}")
+                                
+
+        except UnicodeEncodeError:
+            for data in cmd:
+                response = data.decode(self.CHARSET[1],'replace').split()
+        except UnicodeDecodeError:
+            for data in cmd:
+                response = data.decode(self.CHARSET[1],'replace').split()
+        except AssertionError as ae:
+            self.Base.logs.error(f"Assertion error : {ae}")
+
+    def __ssl_context(self) -> ssl.SSLContext:
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+
+        self.Base.logs.debug(f'SSLContext initiated with verified mode {ctx.verify_mode}')
+
+        return ctx

core/dataClass.py

@@ -0,0 +1,274 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Union
+
+class User:
+
+    @dataclass
+    class UserDataClass:
+        uid: str
+        nickname: str
+        username: str
+        hostname: str
+        umodes: str
+        vhost: str
+        isWebirc: bool
+        connexion_datetime: datetime = field(default=datetime.now())
+
+    UID_DB:list[UserDataClass] = []
+
+    def __init__(self) -> None:
+        pass
+
+    def insert(self, user: UserDataClass) -> bool:
+        """Insert new user
+
+        Args:
+            user (UserDataClass): The User dataclass
+
+        Returns:
+            bool: True if the record has been created
+        """
+        exists = False
+        inserted = False
+
+        for record in self.UID_DB:
+          if record.uid == user.uid:
+                exists = True
+                print(f'{user.uid} already exist')
+
+        if not exists:
+            self.UID_DB.append(user)
+            print(f'New record with uid: {user.uid}')
+            inserted = True
+
+        return inserted
+
+    def update(self, uid: str, newnickname: str) -> bool:
+        """Updating a single record with a new nickname
+
+        Args:
+            uid (str): the uid of the user
+            newnickname (str): the new nickname
+
+        Returns:
+            bool: True if the record has been updated
+        """
+        status = False
+        for user in self.UID_DB:
+            if user.uid == uid:
+                user.nickname = newnickname
+                status = True
+                print(f'Updating record with uid: {uid}')
+
+        return status
+
+    def delete(self, uid: str) -> bool:
+        """Delete a user based on his uid
+
+        Args:
+            uid (str): The UID of the user
+
+        Returns:
+            bool: True if the record has been deleted
+        """
+        status = False
+        for user in self.UID_DB:
+            if user.uid == uid:
+              self.UID_DB.remove(user)
+              status = True
+              print(f'Removing record with uid: {uid}')
+
+        return status
+
+    def isexist(self, uidornickname:str) -> bool:
+        """do the UID or Nickname exist ?
+
+        Args:
+            uidornickname (str): The UID or the Nickname
+
+        Returns:
+            bool: True if exist or False if don't exist
+        """
+        result = False
+        for record in self.UID_DB:
+            if record.uid == uidornickname:
+                result = True
+            if record.nickname == uidornickname:
+                result = True
+
+        return result
+
+    def get_User(self, uidornickname) -> Union[UserDataClass, None]:
+
+        UserObject = None
+        for record in self.UID_DB:
+            if record.uid == uidornickname:
+                UserObject = record
+            elif record.nickname == uidornickname:
+                UserObject = record
+        
+        return UserObject
+
+    def get_uid(self, uidornickname:str) -> Union[str, None]:
+
+        uid = None
+        for record in self.UID_DB:
+            if record.uid == uidornickname:
+                uid = record.uid
+            if record.nickname == uidornickname:
+                uid = record.uid
+
+        return uid
+
+    def get_nickname(self, uidornickname:str) -> Union[str, None]:
+
+        nickname = None
+        for record in self.UID_DB:
+            if record.nickname == uidornickname:
+                nickname = record.nickname
+            if record.uid == uidornickname:
+                nickname = record.nickname
+
+        return nickname
+
+class Admin:
+    @dataclass
+    class AdminDataClass:
+        uid: str
+        nickname: str
+        username: str
+        hostname: str
+        umodes: str
+        vhost: str
+        level: int
+        connexion_datetime: datetime = field(default=datetime.now())
+
+    UID_ADMIN_DB:list[AdminDataClass] = []
+
+    def __init__(self) -> None:
+        pass
+
+    def insert(self, admin: AdminDataClass) -> bool:
+        """Insert new user
+
+        Args:
+            user (UserDataClass): The User dataclass
+
+        Returns:
+            bool: True if the record has been created
+        """
+        exists = False
+        inserted = False
+
+        for record in self.UID_ADMIN_DB:
+          if record.uid == admin.uid:
+                exists = True
+                print(f'{admin.uid} already exist')
+
+        if not exists:
+            self.UID_ADMIN_DB.append(admin)
+            print(f'New record with uid: {admin.uid}')
+            inserted = True
+        
+        return inserted
+
+    def update(self, uid: str, newnickname: str) -> bool:
+        """Updating a single record with a new nickname
+
+        Args:
+            uid (str): the uid of the user
+            newnickname (str): the new nickname
+
+        Returns:
+            bool: True if the record has been updated
+        """
+        status = False
+        for admin in self.UID_ADMIN_DB:
+            if admin.uid == uid:
+                admin.nickname = newnickname
+                status = True
+                print(f'Updating record with uid: {uid}')
+
+        return status
+
+    def delete(self, uid: str) -> bool:
+        """Delete a user based on his uid
+
+        Args:
+            uid (str): The UID of the user
+
+        Returns:
+            bool: True if the record has been deleted
+        """
+        status = False
+        for admin in self.UID_ADMIN_DB:
+            if admin.uid == uid:
+              self.UID_ADMIN_DB.remove(admin)
+              status = True
+              print(f'Removing record with uid: {uid}')
+
+        return status
+
+    def isexist(self, uidornickname:str) -> bool:
+        """do the UID or Nickname exist ?
+
+        Args:
+            uidornickname (str): The UID or the Nickname
+
+        Returns:
+            bool: True if exist or False if don't exist
+        """
+        result = False
+        for record in self.UID_ADMIN_DB:
+            if record.uid == uidornickname:
+                result = True
+            if record.nickname == uidornickname:
+                result = True
+
+        return result
+
+    def get_Admin(self, uidornickname) -> Union[AdminDataClass, None]:
+
+        AdminObject = None
+        for record in self.UID_ADMIN_DB:
+            if record.uid == uidornickname:
+                AdminObject = record
+            elif record.nickname == uidornickname:
+                AdminObject = record
+        
+        return AdminObject
+
+    def get_uid(self, uidornickname:str) -> Union[str, None]:
+
+        uid = None
+        for record in self.UID_ADMIN_DB:
+            if record.uid == uidornickname:
+                uid = record.uid
+            if record.nickname == uidornickname:
+                uid = record.uid
+
+        return uid
+
+    def get_nickname(self, uidornickname:str) -> Union[str, None]:
+
+        nickname = None
+        for record in self.UID_ADMIN_DB:
+            if record.nickname == uidornickname:
+                nickname = record.nickname
+            if record.uid == uidornickname:
+                nickname = record.nickname
+
+        return nickname
+
+    def get_level(self, uidornickname:str) -> int:
+
+        level = 0
+        for record in self.UID_ADMIN_DB:
+            if record.uid == uidornickname:
+                level = record.level
+            if record.nickname == uidornickname:
+                level = record.level
+
+        return level
+

core/exemple_configuration.json

@@ -0,0 +1,48 @@
+{
+    "SERVEUR_IP": "0.0.0.0",
+    "SERVEUR_HOSTNAME": "your.host.name",
+    "SERVEUR_LINK": "your.link.to.server",
+    "SERVEUR_PORT": 7002,
+    "SERVEUR_PASSWORD": "link_password",
+    "SERVEUR_ID": "006",
+    "SERVEUR_SSL": true,
+
+    "SERVICE_NAME": "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": "ntsO",
+    "SERVICE_UMODES": "o",
+    "SERVICE_PREFIX": "!",
+
+    "OWNER": "admin",
+    "PASSWORD": "password",
+
+    "SALON_JAIL": "#jail",
+    "SALON_JAIL_MODES": "sS",
+    "SALON_LIBERER": "#welcome",
+
+    "API_TIMEOUT": 2,
+
+    "PORTS_TO_SCAN": [3028, 8080, 1080, 1085, 4145, 9050],
+    "WHITELISTED_IP": ["127.0.0.1"],
+    "GLINE_DURATION": "30",
+
+    "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/exemple_configuration.py

@@ -1,53 +0,0 @@
-import os
-##########################################
-#   CONFIGURATION FILE :                 #
-#   Rename file to : configuration.py    #
-##########################################
-
-class Config:
-
-    DEFENDER_VERSION = '1.1.0'                              # MAJOR.MINOR.BATCH
-    DEFENDER_DB_PATH = 'db' + os.sep                        # Séparateur en fonction de l'OS
-    DEFENDER_DB_NAME = 'defender'                           # Le nom de la base de données principale
-    SERVICE_NAME = 'defender'                               # Le nom du service
-
-    SERVEUR_IP = '8.8.8.8'                                  # IP ou host du serveur à rejoindre
-    SERVEUR_HOSTNAME = 'your hostname'                      # Le hostname du serveur IRC 
-    SERVEUR_LINK = 'your link'                              # Host attendu par votre IRCd (ex. dans votre link block pour Unrealircd)
-    SERVEUR_PORT = 6666                                     # Port du link
-    SERVEUR_PASSWORD = 'your link password'                 # Mot de passe du link (Privilégiez argon2 sur Unrealircd)
-    SERVEUR_ID = '002'                                      # SID (identification) du bot en tant que Services
-
-    SERVICE_NICKNAME = 'BotName'                            # Nick du bot sur IRC
-    SERVICE_REALNAME = 'BotRealname'                        # Realname du bot
-    SERVICE_USERNAME = 'BotIdent'                           # Ident du bot
-    SERVICE_HOST = 'your service host'                      # Host du bot
-    SERVICE_INFO = 'Network IRC Service'                    # swhois du bot
-    SERVICE_CHANLOG = '#services'                           # Salon des logs et autres messages issus du bot
-    SERVICE_SMODES = '+ioqBS'                               # Mode du service
-    SERVICE_CMODES = 'ntsO'                                 # Mode du salon (#ChanLog) que le bot appliquera à son entrée
-    SERVICE_UMODES = 'o'                                    # Mode que le bot pourra se donner à sa connexion au salon chanlog
-    SERVICE_PREFIX = '.'                                    # Prefix pour envoyer les commandes au bot
-    SERVICE_ID = SERVEUR_ID + 'AAAAAB'                      # L'identifiant du service
-
-    OWNER = 'admin'                                         # Identifiant du compte admin
-    PASSWORD = 'password'                                   # Mot de passe du compte admin
-
-    SALON_JAIL = '#JAIL'                                    # Salon pot de miel
-    SALON_JAIL_MODES = 'sS'                                 # Mode du salon pot de miel
-    SALON_LIBERER = '#welcome'                              # Le salon ou sera envoyé l'utilisateur clean
-
-    PORTS_TO_SCAN = [3028, 8080, 1080, 1085, 4145, 9050]    # Liste des ports a scanné pour une detection de proxy
-
-    DEBUG = 0                                               # Afficher l'ensemble des messages du serveurs dans la console
-
-    CONFIG_COLOR = {
-        'blanche': '\x0300',                                # Couleur blanche
-        'noire': '\x0301',                                  # Couleur noire
-        'bleue': '\x0302',                                  # Couleur Bleue
-        'verte': '\x0303',                                  # Couleur Verte
-        'rouge': '\x0304',                                  # Couleur rouge
-        'jaune': '\x0306',                                  # Couleur jaune
-        'gras': '\x02',                                     # Gras
-        'nogc': '\x02\x03'                                  # Retirer gras et couleur
-    }

core/installation.py

@@ -1,44 +1,160 @@
-from importlib.util import find_spec
-from subprocess import check_call, run
-from platform import python_version
+from dataclasses import dataclass
+from subprocess import check_call, run, CalledProcessError, PIPE
+from platform import python_version, python_version_tuple
 from sys import exit
+import os
 
 class Install:
 
-    def __init__(self) -> None:
-        self.PYTHON_MIN_VERSION = '3.10'
-        self.module_to_install = ['sqlalchemy','psutil','requests']
+    @dataclass
+    class CoreConfig:
+        install_log_file: str
+        unix_systemd_folder: str
+        service_file_name: str
+        service_cmd_executable: list
+        service_cmd_daemon_reload: list
+        defender_main_executable: str
+        python_min_version: str
+        python_current_version_tuple: tuple[str, str, str]
+        python_current_version: str
+        defender_install_folder: str
+        venv_folder: str
+        venv_cmd_installation: list
+        venv_cmd_requirements: list
+        venv_pip_executable: str
+        venv_python_executable: str
 
-        if not self.checkPythonVersion():
+    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:
+                return None
+
+            print(f'Configuration loaded : {self.config}')
+
             # Sinon tester les dependances python et les installer avec pip
-            self.checkDependencies()
+            if self.do_install():
+
+                self.install_dependencies()
+
+                self.create_service_file()
+
+                self.print_final_message()
 
         return None
 
-    def checkPythonVersion(self) -> bool:
+    def set_configuration(self):
+
+        self.skip_install = False
+        defender_install_folder = os.getcwd()
+        venv_folder = '.pyenv'
+        unix_user_home_directory = os.path.expanduser("~")
+        unix_systemd_folder = os.path.join(unix_user_home_directory, '.config', 'systemd', 'user')
+        defender_main_executable = os.path.join(defender_install_folder, 'main.py')
+
+        self.config = self.CoreConfig(
+                install_log_file='install.log',
+                unix_systemd_folder=unix_systemd_folder,
+                service_file_name='defender.service',
+                service_cmd_executable=['systemctl', '--user', 'start', 'defender'],
+                service_cmd_daemon_reload=['systemctl', '--user', 'daemon-reload'],
+                defender_main_executable=defender_main_executable,
+                python_min_version='3.10',
+                python_current_version_tuple=python_version_tuple(),
+                python_current_version=python_version(),
+                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'],
+                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'
+            )
+
+        # Exclude Windows OS
+        if os.name == 'nt':
+            #print('/!\\ Skip installation /!\\')
+            self.skip_install = True
+        else:
+            if self.is_root():
+                self.skip_install = True
+
+    def is_root(self) -> bool:
+
+        if os.geteuid() != 0:
+            print('User without privileges ==> PASS')
+            return False
+        elif os.geteuid() == 0:
+            print('/!\\ Do not use root to install Defender /!\\')
+            exit("Do not use root to install Defender")
+            return True
+
+    def do_install(self) -> bool:
+
+        full_service_file_path = os.path.join(self.config.unix_systemd_folder, self.config.service_file_name)
+
+        if not os.path.exists(full_service_file_path):
+            print(f'/!\\ Service file does not exist /!\\')
+            return True
+
+        # Check if virtual env exist
+        if not os.path.exists(f'{os.path.join(self.config.defender_install_folder, self.config.venv_folder)}'):
+            self.run_subprocess(self.config.venv_cmd_installation)
+            print(f'/!\\ Virtual env does not exist run the install /!\\')
+            return True
+
+    def run_subprocess(self, command:list) -> None:
+
+        print(f'> {command}')
+        try:
+            check_call(command)
+            print("The command completed successfully.")
+        except CalledProcessError as e:
+            print(f"The command failed with the return code: {e.returncode}")
+            print(f"Try to install dependencies ...")
+            exit(5)
+
+    def check_python_version(self) -> bool:
         """Test si la version de python est autorisée ou non
 
         Returns:
             bool: True si la version de python est autorisé sinon False
         """
-        python_required_version = self.PYTHON_MIN_VERSION.split('.')
-        python_current_version = python_version().split('.')
+        # Current system version
+        sys_major, sys_minor, sys_patch = self.config.python_current_version_tuple
 
-        if int(python_current_version[0]) < int(python_required_version[0]):
-            print(f"## Your python version must be greather than or equal to {self.PYTHON_MIN_VERSION} ##")
-            return False
-        elif int(python_current_version[1]) < int(python_required_version[1]):
-            print(f"### Your python version must be greather than or equal to {self.PYTHON_MIN_VERSION} ###")
+        # min python version required
+        python_required_version = self.config.python_min_version.split('.')
+        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} ##")
             return False
 
-        print(f"===> Version of python : {python_version()} ==> OK")
+        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} ##")
+            return False
+
+        print(f"> Version of python : {self.config.python_current_version} ==> OK")
 
         return True
-    
-    def checkDependencies(self) -> None:
+
+    def check_package(self, package_name) -> bool:
+
+        try:
+            # Run a command in the virtual environment's Python to check if the package is installed
+            run([self.config.venv_python_executable, '-c', f'import {package_name}'], check=True, stdout=PIPE, stderr=PIPE)
+            return True
+        except CalledProcessError as cpe:
+            print(cpe)
+            return False
+
+    def install_dependencies(self) -> None:
         """### Verifie les dépendances si elles sont installées
         - Test si les modules sont installés
         - Met a jour pip
@@ -46,27 +162,83 @@ class Install:
         """
         do_install = False
 
-        for module in self.module_to_install:
-            if find_spec(module) is None:
+        # Check if virtual env exist
+        if not os.path.exists(f'{os.path.join(self.config.defender_install_folder, self.config.venv_folder)}'):
+            self.run_subprocess(self.config.venv_cmd_installation)
+            do_install = True
+
+        for module in self.config.venv_cmd_requirements:
+            if not self.check_package(module):
                 do_install = True
 
         if not do_install:
             return None
 
         print("===> Vider le cache de pip")
-        check_call(['pip','cache','purge'])
+        self.run_subprocess([self.config.venv_pip_executable, 'cache', 'purge'])
         
         print("===> Verifier si pip est a jour")
-        check_call(['python', '-m', 'pip', 'install', '--upgrade', 'pip'])
+        self.run_subprocess([self.config.venv_python_executable, '-m', 'pip', 'install', '--upgrade', 'pip'])
 
-        if find_spec('greenlet') is None:
-            check_call(['pip','install', '--only-binary', ':all:', 'greenlet'])
+        if not self.check_package('greenlet'):
+            self.run_subprocess([self.config.venv_pip_executable, 'install', '--only-binary', ':all:', 'greenlet'])
             print('====> Module Greenlet installé')
 
-        for module in self.module_to_install:
-            if find_spec(module) is None:
+        for module in self.config.venv_cmd_requirements:
+            if not self.check_package(module):
                 print("### Trying to install missing python packages ###")
-                check_call(['pip','install', module])
+                self.run_subprocess([self.config.venv_pip_executable, 'install', module])
                 print(f"====> Module {module} installé")
             else:
                 print(f"==> {module} already installed")
+
+    def create_service_file(self) -> None:
+
+        full_service_file_path = os.path.join(self.config.unix_systemd_folder, self.config.service_file_name)
+
+        if os.path.exists(full_service_file_path):
+            print(f'/!\\ Service file already exist /!\\')
+            self.run_subprocess(self.config.service_cmd_executable)
+            return None
+
+        contain = f'''[Unit]
+Description=Defender IRC Service
+
+[Service]
+ExecStart={self.config.venv_python_executable} {self.config.defender_main_executable}
+WorkingDirectory={self.config.defender_install_folder}
+SyslogIdentifier=Defender
+Restart=on-failure
+
+[Install]
+WantedBy=default.target
+'''
+        # Check if user systemd is available (.config/systemd/user/)
+        if not os.path.exists(self.config.unix_systemd_folder):
+            self.run_subprocess(['mkdir', '-p', self.config.unix_systemd_folder])
+
+            with open(full_service_file_path, 'w+') as servicefile:
+                servicefile.write(contain)
+                servicefile.close()
+                print(f'Service file generated with current configuration')
+                print(f'Running Defender IRC Service ...')
+                self.run_subprocess(self.config.service_cmd_daemon_reload)
+                self.run_subprocess(self.config.service_cmd_executable)
+
+        else:
+            with open(full_service_file_path, 'w+') as servicefile:
+                servicefile.write(contain)
+                servicefile.close()
+                print(f'Service file generated with current configuration')
+                print(f'Running Defender IRC Service ...')
+                self.run_subprocess(self.config.service_cmd_daemon_reload)
+                self.run_subprocess(self.config.service_cmd_executable)
+
+    def print_final_message(self) -> None:
+
+        print(f"#"*24)
+        print("Installation complete ...")
+        print("If the configuration is correct, then you must see your service connected to your irc server")
+        print(f"If any issue, you can see the log file for debug {self.config.defender_install_folder}{os.sep}logs{os.sep}defender.log")
+        print(f"#"*24)
+        exit(1)

core/loadConf.py

@@ -0,0 +1,205 @@
+import json, sys
+from os import sep
+from typing import Union, Literal
+from dataclasses import dataclass, field
+
+##########################################
+#   CONFIGURATION FILE                   #
+##########################################
+
+@dataclass
+class ConfigDataModel:
+
+    SERVEUR_IP: str
+    """Server public IP (could be 127.0.0.1 localhost)"""
+
+    SERVEUR_HOSTNAME: str
+    """IRC Server Hostname (your.hostname.extension)"""
+
+    SERVEUR_LINK: str
+    """The link hostname (should be the same as your unrealircd link block)"""
+
+    SERVEUR_PORT: int
+    """Server port as configured in your unrealircd link block"""
+
+    SERVEUR_PASSWORD: str
+    """Your link password"""
+
+    SERVEUR_ID: str
+    """Service identification could be Z01 should be unique"""
+
+    SERVEUR_SSL: bool
+    """Activate SSL connexion"""
+
+    SERVICE_NAME: str
+    """Service name (Ex. Defender)"""
+
+    SERVICE_NICKNAME: str
+    """Nickname of the service (Ex. Defender)"""
+
+    SERVICE_REALNAME: str
+    """Realname of the service"""
+
+    SERVICE_USERNAME: str
+    """Username of the service"""
+
+    SERVICE_HOST: str
+    """The service hostname"""
+
+    SERVICE_INFO: str
+    """Swhois of the service"""
+
+    SERVICE_CHANLOG: str
+    """The channel used by the service (ex. #services)"""
+
+    SERVICE_SMODES: str
+    """The service mode (ex. +ioqBS)"""
+
+    SERVICE_CMODES: str
+    """The mode of the log channel (ex. ntsO)"""
+
+    SERVICE_UMODES: str
+    """The mode of the service when joining chanlog (ex. o, the service will be operator in the chanlog)"""
+
+    SERVICE_PREFIX: str
+    """The default prefix to communicate with the service"""
+
+    SERVICE_ID: str = field(init=False)
+    """The service unique ID"""
+
+    OWNER: str
+    """The nickname of the admin of the service"""
+
+    PASSWORD: str
+    """The password of the admin of the service"""
+
+    SALON_JAIL: str
+    """The JAIL channel (ex. #jail)"""
+
+    SALON_JAIL_MODES: str
+    """The jail channel modes (ex. sS)"""
+
+    SALON_LIBERER: str
+    """Channel where the nickname will be released"""
+
+    API_TIMEOUT: int
+    """Default api timeout in second"""
+
+    PORTS_TO_SCAN: list
+    """List of ports to scan available for proxy_scan in the mod_defender module"""
+
+    WHITELISTED_IP: list
+    """List of remote IP to don't scan"""
+
+    GLINE_DURATION: str
+    """Gline duration"""
+
+    DEBUG_LEVEL:Literal[10, 20, 30, 40, 50]
+    """Logs level: DEBUG 10 | INFO 20 | WARNING 30 | ERROR 40 | CRITICAL 50"""
+
+    CONFIG_COLOR: dict[str, str]
+
+    table_admin: str
+    """Admin table"""
+
+    table_commande: str
+    """Core command table"""
+
+    table_log: str
+    """Core log table"""
+
+    table_module: str
+    """Core module table"""
+
+    table_config: str
+    """Core configuration table"""
+
+    table_channel: str
+    """Core channel table"""
+
+    current_version: str
+    """Current version of Defender"""
+
+    latest_version: str
+    """The Latest version fetched from github"""
+
+    db_name: str
+    """The database name"""
+
+    db_path: str
+    """The database path"""
+
+    def __post_init__(self):
+        # Initialiser SERVICE_ID après la création de l'objet
+        self.SERVICE_ID:str = f"{self.SERVEUR_ID}AAAAAB"
+        """The service ID which is SERVEUR_ID and AAAAAB"""
+
+class Config:
+
+    def __init__(self):
+
+        self.ConfigObject: ConfigDataModel = self.__load_service_configuration()
+        return None
+
+    def __load_json_service_configuration(self):
+        try:
+            conf_filename = f'core{sep}configuration.json'
+            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)
+
+    def __load_service_configuration(self) -> ConfigDataModel:
+        import_config = self.__load_json_service_configuration()
+
+        ConfigObject: ConfigDataModel = ConfigDataModel(
+            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',
+            table_module='core_module',
+            table_config='core_config',
+            table_channel='core_channel',
+            current_version='',
+            latest_version='',
+            db_name='defender',
+            db_path=f'db{sep}'
+        )
+
+        return ConfigObject

mods/mod_clone.py

@@ -0,0 +1,304 @@
+from dataclasses import dataclass, fields, field
+import random, faker, time
+from datetime import datetime
+from typing import Union
+from core.irc import Irc
+from core.connection import Connection
+
+class Clone():
+
+    @dataclass
+    class ModConfModel:
+        clone_nicknames: list[str]
+
+    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
+
+        self.Clone = ircInstance.Clones
+
+        # Créer les nouvelles commandes du module
+        self.commands_level = {
+            1: ['clone']
+        }
+
+        # Init the module (Mandatory)
+        self.__init_module()
+
+        # Log the module
+        self.Logs.debug(f'Module {self.module_name} loaded ...')
+
+    def __init_module(self) -> None:
+
+        # Enrigstrer les nouvelles commandes dans le code
+        self.__set_commands(self.commands_level)
+
+        # Créer les tables necessaire a votre module (ce n'es pas obligatoire)
+        self.__create_tables()
+
+        # Load module configuration (Mandatory)
+        self.__load_module_configuration()
+
+    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_channel = '''CREATE TABLE IF NOT EXISTS clone_list (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            datetime TEXT,
+            nickname TEXT,
+            username TEXT
+            )
+        '''
+
+        self.Base.db_execute_query(table_channel)
+
+        return None
+
+    def __load_module_configuration(self) -> None:
+        """### Load Module Configuration
+        """
+        try:
+            # Variable qui va contenir les options de configuration du module Defender
+            self.ModConfig = self.ModConfModel(
+                                    clone_nicknames=[]
+                                )
+
+            # 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 unload(self) -> None:
+        """Cette methode sera executée a chaque désactivation ou 
+        rechargement de module
+        """
+
+        # kill all clones before unload
+        for clone in self.ModConfig.clone_nicknames:
+            self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone} :KILL')
+
+        return None
+
+    def thread_create_clones(self, nickname: str, username: str, channels: list, server_port: int, ssl: bool) -> None:
+
+        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):
+
+        if clone_name is None:
+            for clone in self.Clone.UID_CLONE_DB:
+                self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
+                time.sleep(wait)
+        else:
+            for clone in self.Clone.UID_CLONE_DB:
+                if clone_name == clone.nickname:
+                    self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
+                    time.sleep(wait)
+
+    def generate_names(self) -> tuple[str, str]:
+        try:
+            fake = faker.Faker('en_GB')
+            nickname = fake.first_name()
+            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)
+                    )
+            else:
+                self.Clone.insert(
+                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username)
+                    )
+
+            # 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}')
+        except Exception as err:
+            self.Logs.error(err)
+
+    def cmd(self, data:list) -> None:
+
+        service_id = self.Config.SERVICE_ID                 # Defender serveur id
+        cmd = list(data).copy()
+
+        if len(cmd) < 2:
+            return None
+
+        match cmd[1]:
+
+            case 'REPUTATION':
+                pass
+
+    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
+
+        command = str(cmd[0]).lower()
+        fromuser = user
+
+        dnickname = self.Config.SERVICE_NICKNAME            # Defender nickname
+
+        match command:
+
+            case 'clone':
+                option = str(cmd[1]).lower()
+
+                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')
+
+                match option:
+
+                    case 'connect':
+                        try:
+                            number_of_clones = int(cmd[2])
+                            for i in range(number_of_clones):
+                                nickname, username = self.generate_names()
+                                self.Base.create_thread(
+                                    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]')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} clone connect 6')
+
+                    case 'kill':
+                        try:
+                            # clone kill [all | nickname]
+                            clone_name = str(cmd[2])
+                            clone_to_kill: list[str] = []
+
+                            if clone_name.lower() == 'all':
+                                for clone in self.Clone.UID_CLONE_DB:
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {clone.nickname} :KILL')
+                                    clone_to_kill.append(clone.nickname)
+                                    clone.alive = False
+
+                                for clone_nickname in clone_to_kill:
+                                    self.Clone.delete(clone_nickname)
+
+                                del clone_to_kill
+
+                            else:
+                                if self.Clone.exists(clone_name):
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {clone_name} :KILL')
+                                    self.Clone.kill(clone_name)
+                                    self.Clone.delete(clone_name)
+
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill all')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill clone_nickname')
+
+                    case 'join':
+                        try:
+                            # clone join [all | nickname] #channel
+                            clone_name = str(cmd[2])
+                            clone_channel_to_join = str(cmd[3])
+
+                            if clone_name.lower() == 'all':
+                                self.Base.create_thread(self.thread_join_channels, (clone_channel_to_join, 2))
+                            else:
+                                self.Base.create_thread(self.thread_join_channels, (clone_channel_to_join, 2, clone_name))
+
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join all #channel')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join clone_nickname #channel')
+
+                    case 'list':
+                        try:
+                            for clone_name in self.Clone.UID_CLONE_DB:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :>> {clone_name.nickname} | {clone_name.username}')
+                            pass
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+
+                    case 'say':
+                        try:
+                            # clone say clone_nickname #channel message
+                            clone_name = str(cmd[2])
+                            clone_channel = str(cmd[3]) if self.Base.Is_Channel(str(cmd[3])) else None
+
+                            message = []
+                            for i in range(4, len(cmd)):
+                                message.append(cmd[i])
+                            final_message = ' '.join(message)
+
+                            if clone_channel is None or not self.Clone.exists(clone_name):
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel message')
+                                return None
+                            
+                            if self.Clone.exists(clone_name):
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {clone_name} :SAY {clone_channel} {final_message}')
+
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel message')
+
+                    case _:
+                        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 say [clone_nickname] #channel [message]')
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone list')

mods/mod_command.py

@@ -0,0 +1,644 @@
+from dataclasses import dataclass, fields
+from core.irc import Irc
+
+class Command():
+
+    @dataclass
+    class ModConfModel:
+        """The Model containing the module parameters
+        """
+        pass
+
+    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: ['join', 'part'],
+            2: ['owner', 'deowner', 'op', 'deop', 'halfop', 'dehalfop', 'voice', 
+                'devoice', 'opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 
+                'unban','kick', 'kickban', 'umode', 'svsjoin', 'svspart', 'svsnick']
+        }
+
+        # 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 #
+
+        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 __load_module_configuration(self) -> None:
+        """### Load Module Configuration
+        """
+        try:
+            # Build the default configuration model (Mandatory)
+            self.ModConfig = self.ModConfModel()
+
+            # 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:
+
+        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:
+
+        return None
+
+    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
+
+        command = str(cmd[0]).lower()
+        dnickname = self.Config.SERVICE_NICKNAME
+        service_id = self.Config.SERVICE_ID
+        dchanlog = self.Config.SERVICE_CHANLOG
+        fromuser = user
+        fromchannel = channel
+
+        match command:
+
+            case 'deopall':
+                try:
+                    self.Irc.send2socket(f":{service_id} SVSMODE {fromchannel} -o")
+
+                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:
+                    self.Irc.send2socket(f":{service_id} SVSMODE {fromchannel} -v")
+
+                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 = ''
+                    users:str = ''
+                    uids_split = [chan_info.uids[i:i + 6] for i in range(0, len(chan_info.uids), 6)]
+
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{set_mode} {dnickname}")
+                    for uid in uids_split:
+                        for i in range(0, len(uid)):
+                            mode += set_mode
+                            users += f'{self.User.get_nickname(self.Base.clean_uid(uid[i]))} '
+                            if i == len(uid) - 1:
+                                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 = ''
+                    users:str = ''
+                    uids_split = [chan_info.uids[i:i + 6] for i in range(0, len(chan_info.uids), 6)]
+
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{set_mode} {dnickname}")
+                    for uid in uids_split:
+                        for i in range(0, len(uid)):
+                            mode += set_mode
+                            users += f'{self.User.get_nickname(self.Base.clean_uid(uid[i]))} '
+                            if i == len(uid) - 1:
+                                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
+                # .op #channel user
+                # /msg dnickname op #channel user
+                # [':adator', 'PRIVMSG', '#services', ':.o', '#services', 'dktmb']
+                try:
+                    if fromchannel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} op [#SALON] [NICKNAME]')
+                        return False
+
+                    if len(cmd) == 1:
+                        self.Irc.send2socket(f":{dnickname} MODE {fromchannel} +o {fromuser}")
+                        return True
+
+                    # deop nickname
+                    if len(cmd) == 2:
+                        nickname = cmd[1]
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} +o {nickname}")
+                        return True
+
+                    nickname = cmd[2]
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} +o {nickname}")
+
+                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
+                # .deop #channel user
+                try:
+                    if fromchannel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} deop [#SALON] [NICKNAME]')
+                        return False
+
+                    if len(cmd) == 1:
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -o {fromuser}")
+                        return True
+
+                    # deop nickname
+                    if len(cmd) == 2:
+                        nickname = cmd[1]
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -o {nickname}")
+                        return True
+
+                    nickname = cmd[2]
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} -o {nickname}")
+
+                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
+                # .owner #channel user
+                try:
+                    if fromchannel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} owner [#SALON] [NICKNAME]')
+                        return False
+
+                    if len(cmd) == 1:
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} +q {fromuser}")
+                        return True
+
+                    # owner nickname
+                    if len(cmd) == 2:
+                        nickname = cmd[1]
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} +q {nickname}")
+                        return True
+
+                    nickname = cmd[2]
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} +q {nickname}")
+
+                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
+                # .deowner #channel user
+                try:
+                    if fromchannel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} deowner [#SALON] [NICKNAME]')
+                        return False
+
+                    if len(cmd) == 1:
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -q {fromuser}")
+                        return True
+
+                    # deowner nickname
+                    if len(cmd) == 2:
+                        nickname = cmd[1]
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -q {nickname}")
+                        return True
+
+                    nickname = cmd[2]
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} -q {nickname}")
+
+                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 'halfop':
+                # /mode #channel +h user
+                # .halfop #channel user
+                try:
+                    if fromchannel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} halfop [#SALON] [NICKNAME]')
+                        return False
+
+                    if len(cmd) == 1:
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} +h {fromuser}")
+                        return True
+
+                    # deop nickname
+                    if len(cmd) == 2:
+                        nickname = cmd[1]
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} +h {nickname}")
+                        return True
+
+                    nickname = cmd[2]
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} +h {nickname}")
+
+                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
+                # .dehalfop #channel user
+                try:
+                    if fromchannel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} dehalfop [#SALON] [NICKNAME]')
+                        return False
+
+                    if len(cmd) == 1:
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -h {fromuser}")
+                        return True
+
+                    # dehalfop nickname
+                    if len(cmd) == 2:
+                        nickname = cmd[1]
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -h {nickname}")
+                        return True
+
+                    nickname = cmd[2]
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} -h {nickname}")
+
+                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
+                # .voice #channel user
+                try:
+                    if fromchannel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} voice [#SALON] [NICKNAME]')
+                        return False
+
+                    if len(cmd) == 1:
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} +v {fromuser}")
+                        return True
+
+                    # voice nickname
+                    if len(cmd) == 2:
+                        nickname = cmd[1]
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} +v {nickname}")
+                        return True
+
+                    nickname = cmd[2]
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} +v {nickname}")
+
+                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
+                # .devoice #channel user
+                try:
+                    if fromchannel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} devoice [#SALON] [NICKNAME]')
+                        return False
+
+                    if len(cmd) == 1:
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -v {fromuser}")
+                        return True
+
+                    # dehalfop nickname
+                    if len(cmd) == 2:
+                        nickname = cmd[1]
+                        self.Irc.send2socket(f":{service_id} MODE {fromchannel} -v {nickname}")
+                        return True
+
+                    nickname = cmd[2]
+                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} -v {nickname}")
+
+                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} ban [#SALON] [NICKNAME]')
+                        return False
+
+                    nickname = cmd[2]
+
+                    self.Irc.send2socket(f":{service_id} MODE {sentchannel} +b {nickname}!*@*")
+                    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} ban [#SALON] [NICKNAME]')
+                except Exception as err:
+                    self.Logs.warning(f'Unknown Error: {str(err)}')
+
+            case 'unban':
+                # .unban #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} ban [#SALON] [NICKNAME]')
+                        return False
+                    nickname = cmd[2]
+
+                    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
+                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} ban [#SALON] [NICKNAME]')
+                        return False
+                    nickname = cmd[2]
+                    reason = []
+
+                    for i in range(3, len(cmd)):
+                        reason.append(cmd[i]) 
+
+                    final_reason = ' '.join(reason)
+
+                    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
+                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} ban [#SALON] [NICKNAME]')
+                        return False
+                    nickname = cmd[2]
+                    reason = []
+
+                    for i in range(3, len(cmd)):
+                        reason.append(cmd[i]) 
+
+                    final_reason = ' '.join(reason)
+
+                    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':
+
+                try:
+                    sent_channel = str(cmd[1]) if self.Base.Is_Channel(cmd[1]) else None
+                    if sent_channel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :{self.Config.SERVICE_PREFIX}JOIN #channel')
+                        return False
+
+                    self.Irc.send2socket(f':{service_id} JOIN {sent_channel}')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : {dnickname} JOINED {sent_channel}')
+                    self.Base.db_query_channel('add', self.module_name, sent_channel)
+
+                except IndexError as ie:
+                    self.Logs.error(f'{ie}')
+                except Exception as err:
+                    self.Logs.warning(f'Unknown Error: {str(err)}')
+
+            case 'part':
+
+                try:
+                    sent_channel = str(cmd[1]) if self.Base.Is_Channel(cmd[1]) else None
+                    if sent_channel is None:
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :{self.Config.SERVICE_PREFIX}PART #channel')
+                        return False
+
+                    if sent_channel ==  dchanlog:
+                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} : {dnickname} CAN'T LEFT {sent_channel} AS IT IS LOG CHANNEL")
+                        return False
+
+                    self.Irc.send2socket(f':{service_id} PART {sent_channel}')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : {dnickname} LEFT {sent_channel}')
+                    self.Base.db_query_channel('del', self.module_name, sent_channel)
+
+                except IndexError as ie:
+                    self.Logs.error(f'{ie}')
+                except Exception as err:
+                    self.Logs.warning(f'Unknown Error: {str(err)}')
+
+            case 'umode':
+                try:
+                    # .umode nickname +mode
+                    nickname = str(cmd[1])
+                    umode = str(cmd[2])
+
+                    self.Irc.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 '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 '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} SVSNICK 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} SVSNICK nickname newnickname')
+                    self.Logs.warning(f'Unknown Error: {str(err)}')

mods/mod_test.py

@@ -1,49 +1,81 @@
-import threading
+from dataclasses import dataclass, fields
 from core.irc import Irc
 
-#   Le module crée devra réspecter quelques conditions
-#       1. Importer le module de configuration
-#       2. Le nom de class devra toujours s'appeler comme le module exemple => nom de class Dktmb | nom du module mod_dktmb
-#       3. la fonction __init__ devra toujours avoir les parametres suivant (self, irc:object)
-#           1 . Créer la variable irc dans le module
-#           2 . Récuperer la configuration dans une variable
-#           3 . Définir et enregistrer les nouvelles commandes
-#       4. une fonction _hcmds(self, user:str, cmd: list) devra toujours etre crée.
-
 class Test():
 
+    @dataclass
+    class ModConfModel:
+        """The Model containing the module parameters
+        """
+        param_exemple1: str
+        param_exemple2: int
+
     def __init__(self, ircInstance:Irc) -> None:
-        print(f'Module {self.__class__.__name__} loaded ...')
 
-        self.irc = ircInstance                                              # Ajouter l'object mod_irc a la classe
+        # Module name (Mandatory)
+        self.module_name = 'mod_' + str(self.__class__.__name__).lower()
 
-        self.config = ircInstance.Config                                    # Ajouter la configuration a la classe
+        # Add Irc Object to the module (Mandatory)
+        self.Irc = ircInstance
 
-        # Créer les nouvelles commandes du module
-        self.commands = ['test']
+        # Add Global Configuration to the module (Mandatory)
+        self.Config = ircInstance.Config
 
-        self.__set_commands(self.commands)                                  # Enrigstrer les nouvelles commandes dans le code
+        # Add Base object to the module (Mandatory)
+        self.Base = ircInstance.Base
 
-        self.core = ircInstance.Base                                        # Instance du module Base
+        # Add logs object to the module (Mandatory)
+        self.Logs = ircInstance.Base.logs
 
-        self.session = ''                                                   # Instancier une session pour la base de données
-        self.__create_db('mod_test')                                       # Créer la base de données si necessaire
+        # Add User object to the module (Mandatory)
+        self.User = ircInstance.User
 
-    def __set_commands(self, commands:list) -> None:
-        """Rajoute les commandes du module au programme principal
+        # Add Channel object to the module (Mandatory)
+        self.Channel = ircInstance.Channel
+
+        # Create module commands (Mandatory)
+        self.commands_level = {
+            0: ['test-command'],
+            1: ['test_level_1'],
+            2: ['test_level_2'],
+            3: ['test_level_3']
+        }
+
+        # 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 #
+
+        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
-
-        Returns:
-            None: Aucun retour attendu
         """
-        for command in commands:
-            self.irc.commands.append(command)
+        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 True
+        return None
 
-    def __create_db(self, db_name:str) -> 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:
@@ -52,32 +84,72 @@ class Test():
         Returns:
             None: Aucun retour n'es attendu
         """
-        db_directory = self.core.MODS_DB_PATH
 
-        self.session = self.core.db_init(db_directory, db_name)
-
-        table_logs = '''CREATE TABLE IF NOT EXISTS logs (
+        table_logs = '''CREATE TABLE IF NOT EXISTS test_logs (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             datetime TEXT,
             server_msg TEXT
-            ) 
+            )
         '''
 
-        self.core.db_execute_query(self.session, table_logs)
+        self.Base.db_execute_query(table_logs)
         return None
 
-    def _hcmds(self, user:str, cmd: list) -> None:
+    def __load_module_configuration(self) -> None:
+        """### Load Module Configuration
+        """
+        try:
+            # Build the default configuration model (Mandatory)
+            self.ModConfig = self.ModConfModel(param_exemple1='param value 1', param_exemple2=1)
 
-        command = cmd[0].lower()
+            # 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:
+
+        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
+        fromuser = user
+        fromchannel = str(channel) if not channel is None else None
 
         match command:
 
-            case 'test':
+            case 'test-command':
                 try:
-                    user_action = cmd[1]
-                    self.irc.send2socket(f'PRIVMSG #webmail Je vais voicer {user}')
-                    self.irc.send2socket(f'MODE #webmail +v {user_action}')
-                    self.core.create_log(f"MODE +v sur {user_action}")
-                except KeyError as ke:
-                    self.core.create_log(f"Key Error : {ke}")
 
+                    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_votekick.py

@@ -0,0 +1,495 @@
+from core.irc import Irc
+import re
+from dataclasses import dataclass, field
+
+# Activer le systeme sur un salon (activate #salon)
+#   Le service devra se connecter au salon
+#   Le service devra se mettre en op
+# Soumettre un nom de user (submit nickname)
+# voter pour un ban (vote_for)
+# voter contre un ban (vote_against)
+
+
+
+class Votekick():
+
+    @dataclass
+    class VoteChannelModel:
+        channel_name: str
+        target_user: str
+        voter_users: list
+        vote_for: int
+        vote_against: int
+
+    VOTE_CHANNEL_DB:list[VoteChannelModel] = []
+
+    def __init__(self, ircInstance:Irc) -> None:
+
+        # Module name (Mandatory)
+        self.module_name = 'mod_' + str(self.__class__.__name__).lower()
+
+        # Add Irc Object to the module
+        self.Irc = ircInstance
+
+        # Add Global Configuration to the module
+        self.Config = ircInstance.Config
+
+        # Add Base object to the module
+        self.Base = ircInstance.Base
+
+        # Add logs object to the module
+        self.Logs = ircInstance.Base.logs
+
+        # Add User object to the module
+        self.User = ircInstance.User
+
+        # Add Channel object to the module
+        self.Channel = ircInstance.Channel
+
+        # Créer les nouvelles commandes du module
+        self.commands_level = {
+            0: ['vote']
+        }
+
+        # Init the module
+        self.__init_module()
+
+        # Log the module
+        self.Logs.debug(f'Module {self.module_name} loaded ...')
+
+    def __init_module(self) -> None:
+
+        # Add admin object to retrieve admin users
+        self.Admin = self.Irc.Admin
+
+        self.__set_commands(self.commands_level)
+        self.__create_tables()
+        self.join_saved_channels()
+
+        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 votekick_logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            datetime TEXT,
+            server_msg TEXT
+            ) 
+        '''
+
+        table_vote = '''CREATE TABLE IF NOT EXISTS votekick_channel (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            datetime TEXT,
+            channel TEXT
+            )
+        '''
+
+        self.Base.db_execute_query(table_logs)
+        self.Base.db_execute_query(table_vote)
+        return None
+
+    def unload(self) -> None:
+        try:
+            for chan in self.VOTE_CHANNEL_DB:
+                self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} PART {chan.channel_name}")
+
+            self.VOTE_CHANNEL_DB = []
+            self.Logs.debug(f'Delete memory DB VOTE_CHANNEL_DB: {self.VOTE_CHANNEL_DB}')
+
+            return None
+        except UnboundLocalError as ne:
+            self.Logs.error(f'{ne}')
+        except NameError as ue:
+            self.Logs.error(f'{ue}')
+        except:
+            self.Logs.error('Error on the module')
+
+    def init_vote_system(self, channel: str) -> bool:
+
+        response = False
+        for chan in self.VOTE_CHANNEL_DB:
+            if chan.channel_name == channel:
+                chan.target_user = ''
+                chan.voter_users = []
+                chan.vote_against = 0
+                chan.vote_for = 0
+                response = True
+
+        return response
+
+    def insert_vote_channel(self, ChannelObject: VoteChannelModel) -> bool:
+        result = False
+        found = False
+        for chan in self.VOTE_CHANNEL_DB:
+            if chan.channel_name == ChannelObject.channel_name:
+                found = True
+
+        if not found:
+            self.VOTE_CHANNEL_DB.append(ChannelObject)
+            self.Logs.debug(f"The channel has been added {ChannelObject}")
+            # self.db_add_vote_channel(ChannelObject.channel_name)
+
+        return result
+
+    def db_add_vote_channel(self, channel:str) -> bool:
+        """Cette fonction ajoute les salons ou seront autoriser les votes
+
+        Args:
+            channel (str): le salon à enregistrer.
+        """
+        current_datetime = self.Base.get_datetime()
+        mes_donnees = {'channel': channel}
+
+        response = self.Base.db_execute_query("SELECT id FROM votekick_channel WHERE channel = :channel", mes_donnees)
+
+        isChannelExist = response.fetchone()
+
+        if isChannelExist is None:
+            mes_donnees = {'datetime': current_datetime, 'channel': channel}
+            insert = self.Base.db_execute_query(f"INSERT INTO votekick_channel (datetime, channel) VALUES (:datetime, :channel)", mes_donnees)
+            if insert.rowcount > 0:
+                return True
+            else:
+                return False
+        else:
+            return False
+
+    def db_delete_vote_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 votekick_channel WHERE channel = :channel", mes_donnes)
+        
+        affected_row = response.rowcount
+
+        if affected_row > 0:
+            return True
+        else:
+            return False
+
+    def join_saved_channels(self) -> None:
+
+        param = {'module_name': self.module_name}
+        result = self.Base.db_execute_query(f"SELECT id, channel_name FROM {self.Config.table_channel} WHERE module_name = :module_name", param)
+
+        channels = result.fetchall()
+        unixtime = self.Base.get_unixtime()
+
+        for channel in channels:
+            id, chan = channel
+            self.insert_vote_channel(self.VoteChannelModel(channel_name=chan, target_user='', voter_users=[], vote_for=0, vote_against=0))
+            self.Irc.send2socket(f":{self.Config.SERVEUR_ID} SJOIN {unixtime} {chan} + :{self.Config.SERVICE_ID}")
+            self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} SAMODE {chan} +o {self.Config.SERVICE_NICKNAME}")
+
+        return None
+
+    def is_vote_ongoing(self, channel: str) -> bool:
+
+        response = False
+        for vote in self.VOTE_CHANNEL_DB:
+            if vote.channel_name == channel:
+                if vote.target_user:
+                    response = True
+
+        return response
+
+    def timer_vote_verdict(self, channel: str) -> None:
+
+        dnickname = self.Config.SERVICE_NICKNAME
+
+        if not self.is_vote_ongoing(channel):
+            return None
+
+        for chan in self.VOTE_CHANNEL_DB:
+            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.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.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):
+                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :System vote re initiated')
+
+        return None
+
+    def cmd(self, data:list) -> None:
+        cmd = list(data).copy()
+
+        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
+        # full cmd is sending the entire server response
+
+        command = str(cmd[0]).lower()
+        dnickname = self.Config.SERVICE_NICKNAME
+        fromuser = user
+        fromchannel = channel
+
+        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':
+                        try:
+                            # vote activate #channel
+                            if self.Admin.get_Admin(fromuser) is None:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
+                                return None
+
+                            sentchannel = str(cmd[2]).lower() if self.Base.Is_Channel(str(cmd[2]).lower()) else None
+                            if sentchannel is None:
+                                self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The correct command is {self.Config.SERVICE_PREFIX}{command} {option} #CHANNEL")
+
+                            self.insert_vote_channel(
+                                self.VoteChannelModel(
+                                    channel_name=sentchannel,
+                                    target_user='',
+                                    voter_users=[],
+                                    vote_for=0,
+                                    vote_against=0
+                                    )
+                                )
+
+                            self.Base.db_query_channel('add', self.module_name, sentchannel)
+
+                            self.Irc.send2socket(f":{dnickname} JOIN {sentchannel}")
+                            self.Irc.send2socket(f":{dnickname} SAMODE {sentchannel} +o {dnickname}")
+                            self.Irc.send2socket(f":{dnickname} PRIVMSG {sentchannel} :You can now use !submit <nickname> to decide if he will stay or not on this channel ")
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option} #channel')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option} #welcome')
+
+                    case 'deactivate':
+                        try:
+                            # vote deactivate #channel
+                            if self.Admin.get_Admin(fromuser) is None:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
+                                return None
+
+                            sentchannel = str(cmd[2]).lower() if self.Base.Is_Channel(str(cmd[2]).lower()) else None
+                            if sentchannel is None:
+                                self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The correct command is {self.Config.SERVICE_PREFIX}{command} {option} #CHANNEL")
+
+                            self.Irc.send2socket(f":{dnickname} SAMODE {sentchannel} -o {dnickname}")
+                            self.Irc.send2socket(f":{dnickname} PART {sentchannel}")
+
+                            for chan in self.VOTE_CHANNEL_DB:
+                                if chan.channel_name == sentchannel:
+                                    self.VOTE_CHANNEL_DB.remove(chan)
+                                    self.Base.db_query_channel('del', self.module_name, chan.channel_name)
+
+                            self.Logs.debug(f"The Channel {sentchannel} has been deactivated from the vote system")
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option} #channel')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option} #welcome')
+
+                    case '+':
+                        try:
+                            # vote +
+                            channel = fromchannel
+                            for chan in self.VOTE_CHANNEL_DB:
+                                if chan.channel_name == channel:
+                                    if fromuser in chan.voter_users:
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :You already submitted a vote')
+                                    else:
+                                        chan.vote_for += 1
+                                        chan.voter_users.append(fromuser)
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote recorded, thank you')
+                        except Exception as err:
+                            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 '-':
+                        try:
+                            # vote -
+                            channel = fromchannel
+                            for chan in self.VOTE_CHANNEL_DB:
+                                if chan.channel_name == channel:
+                                    if fromuser in chan.voter_users:
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :You already submitted a vote')
+                                    else:
+                                        chan.vote_against += 1
+                                        chan.voter_users.append(fromuser)
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote recorded, thank you')
+                        except Exception as err:
+                            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 'cancel':
+                        try:
+                            # vote cancel
+                            if self.Admin.get_Admin(fromuser) is None:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
+                                return None
+
+                            if channel is None:
+                                self.Logs.error(f"The channel is not known, defender can't cancel the vote")
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :You need to specify the channel => /msg {dnickname} vote_cancel #channel')
+
+                            for vote in self.VOTE_CHANNEL_DB:
+                                if vote.channel_name == channel:
+                                    self.init_vote_system(channel)
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote system re-initiated')
+
+                        except Exception as err:
+                            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 'status':
+                        try:
+                            # vote status
+                            for chan in self.VOTE_CHANNEL_DB:
+                                if chan.channel_name == channel:
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Channel: {chan.channel_name} | Target: {self.User.get_nickname(chan.target_user)} | For: {chan.vote_for} | Against: {chan.vote_against} | Number of voters: {str(len(chan.voter_users))}')
+
+                        except Exception as err:
+                            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 'submit':
+                        try:
+                            # vote submit nickname
+                            if self.Admin.get_Admin(fromuser) is None:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
+                                return None
+
+                            nickname_submitted = cmd[2]
+                            uid_submitted = self.User.get_uid(nickname_submitted)
+                            user_submitted = self.User.get_User(nickname_submitted)
+
+                            # check if there is an ongoing vote
+                            if self.is_vote_ongoing(channel):
+                                for vote in self.VOTE_CHANNEL_DB:
+                                    if vote.channel_name == channel:
+                                        ongoing_user = self.User.get_nickname(vote.target_user)
+
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :There is an ongoing vote on {ongoing_user}')
+                                return False
+
+                            # check if the user exist
+                            if user_submitted is None:
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This nickname <{nickname_submitted}> do not exist')
+                                return False
+
+                            uid_cleaned = self.Base.clean_uid(uid_submitted)
+                            ChannelInfo = self.Channel.get_Channel(channel)
+                            if ChannelInfo is None:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :This channel [{channel}] do not exist in the Channel Object')
+                                return False
+
+                            clean_uids_in_channel: list = []
+                            for uid in ChannelInfo.uids:
+                                clean_uids_in_channel.append(self.Base.clean_uid(uid))
+
+                            if not uid_cleaned in clean_uids_in_channel:
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This nickname <{nickname_submitted}> is not available in this channel')
+                                return False
+
+                            # check if Ircop or Service or Bot
+                            pattern = fr'[o|B|S]'
+                            operator_user = re.findall(pattern, user_submitted.umodes)
+                            if operator_user:
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :You cant vote for this user ! he/she is protected')
+                                return False
+
+                            for chan in self.VOTE_CHANNEL_DB:
+                                if chan.channel_name == channel:
+                                    chan.target_user = self.User.get_uid(nickname_submitted)
+
+                            self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :{nickname_submitted} has been targeted for a vote')
+
+                            self.Base.create_timer(60, self.timer_vote_verdict, (channel, ))
+                            self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This vote will end after 60 secondes')
+
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option} nickname')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option} adator')
+
+                    case 'verdict':
+                        try:
+                            # vote verdict
+                            if self.Admin.get_Admin(fromuser) is None:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
+                                return None
+
+                            for chan in self.VOTE_CHANNEL_DB:
+                                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.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.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):
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :System vote re initiated')
+                        except Exception as err:
+                            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

@@ -0,0 +1,3 @@
+{
+    "version": "5.1.8"
+}