Merge pull request #19 from adator85/dev

V5.0.4 - Delete a user when a user has been kicked

.gitignore

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

README.md

@@ -1,242 +1,71 @@
 # 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.
 
-# Fonctionnalités principales
+Pré-requis :
-    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.
 
-    Système de quarantaine:
+    - Python version >= 3.10
-        Mise en quarantaine: Isoler temporairement un utilisateur dans un canal privé.
+    - Pip de python installé sur la machine
-        Libération: Permettre à un utilisateur de quitter la quarantaine en entrant un code spécifique.
+    - Python librairies psutil & sqlalchemy & requests
+    - IRC Serveur Version >= UnrealIRCd-6.1.2.2
 
-    Système de vote:
+Lancement de Defender :
-        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.).
 
-# Installation automatique sur une machine Debian/Ubuntu
+    - 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.
 
-    Prérequis:
+# TO DO LIST
-        - Système d'exploitation Linux (Windows non supporté)
-        - Un server UnrealIRCD corréctement configuré
-        - Python version 3.10 ou supérieure
-```bash
-        # Bash
-        $ git clone https://github.com/adator85/IRC_DEFENDER_MODULES.git
-        # Renommer le fichier exemple_configuration.json en configuration.json
-        # Configurer le fichier configuration.json
-        $ python3 main.py
-```
-Si votre configuration est bonne, votre service est censé etre connecté a votre réseau IRC
-Pour Les prochains lancement de defender vous devez utiliser la commande suivante:
 
-```bash
+    - Optimiser le systeme de réputation:
-    # Bash
+        - lorsque les users ce connectent, Ils entrent dans un salon puis une fraction de seconde le service les bans
-    $ systemctl --user [start | stop | restart | status] defender
-```
-# Installation manuelle:
-```bash
-    # Bash
-    $ git clone https://github.com/adator85/IRC_DEFENDER_MODULES.git
-    $ cd IRC_DEFENDER_MODULES
-    $ python3 -m venv .pyenv
-    $ source .pyenv/bin/activate
-    (pyenv)$ pip install sqlalchemy, psutil, requests, faker, unrealircd_rpc_py
 
-    # Créer un service nommé "defender.service" 
+# VERSION 1
-    # pour votre service et placer le dans "/PATH/TO/USER/.config/systemd/user/"
-    # Si le dossier n'existe pas il faut les créer
-    $ sudo systemctl --user start defender
-```
-# Configuration
-```
-    SERVEUR (Serveur)
-        * SERVEUR_IP: Adresse IP du serveur IRC à rejoindre. (default : 127.0.0.1)
-        * SERVEUR_HOSTNAME: Nom d'hôte du serveur IRC à rejoindre (optionnel).
-        * SERVEUR_LINK: Lien vers le serveur IRC (optionnel).
-        * SERVEUR_PORT: Port de connexion au serveur IRC.
-        * SERVEUR_PASSWORD: Mot de passe d'enregistrement du service sur le serveur IRC.
-        SERVEUR_ID: Identifiant unique du service. (default : 19Z)
-        SERVEUR_SSL: Active la connexion SSL sécurisée au serveur IRC (true/false) (default : false).
 
-    SERVICE (Service)
+    [02.01.2024]
-        SERVICE_NAME: Nom du service IRC. (default : Defender)
+        - Rajout de l'activation de la commande flood
-        SERVICE_NICKNAME: Surnom utilisé par le service sur le serveur IRC. (default : Defender)
+        - Les deux variables RESTART et INIT ont été déplacées vers le module Irc
-        SERVICE_REALNAME: Nom réel du service affiché sur le serveur IRC. (default : Defender Security)
+        - Nouvelle class Install:
-        SERVICE_USERNAME: Nom d'utilisateur utilisé par le service pour se connecter au serveur IRC. (default : IRCSecurity)
+            - Le programme va vérifier si les 3 librairies sont installées (SQLAlchemy & requests & psutil)
-        SERVICE_HOST: Nom d'hôte du service affiché sur le serveur IRC (optionnel). (default : defender.local.network)
+            - Une fois la vérification, il va mêtre a jour pip puis installera les dépendances
-        SERVICE_INFO: Description du service. (default : Defender Network IRC Service)
-        SERVICE_CHANLOG: Canal utilisé pour la journalisation des actions du service. (default : #services)
-        SERVICE_SMODES: Modes serveur appliqués aux canaux rejoints par le service. (default : +ioqBS)
-        SERVICE_CMODES: Modes de canal appliqués aux canaux rejoints par le service. (default : ntsOP)
-        SERVICE_UMODES: Modes utilisateur appliqués au service. (default : o)
-        SERVICE_PREFIX: Caractère utilisé comme préfixe des commandes du service. (default : !)
 
-    COMPTE (Compte)
+    [28.12.2023]
-        OWNER: Nom d'utilisateur possédant les droits d'administration du service. (default : admin)
+        - Changement de méthode pour récuperer la version actuelle de python
-        PASSWORD: Mot de passe de l'administrateur du service. (default : admin)
+        - Ajout de la réponse a une PING de la part d'un utilisateur
+        - Installation automatique des packages sqlalchemy, requests et psutil
 
-    CANAUX (Canaux)
+# BUG FIX
-        SALON_JAIL: Canal utilisé comme prison pour les utilisateurs sanctionnés. (default : #jail)
-        SALON_JAIL_MODES: Modes appliqués au canal de prison. (default : sS)
-        SALON_LIBERER: Canal utilisé pour la libération des utilisateurs sanctionnés. (default : #welcome)
 
-    API (API)
+    [29.12.2023]
-        API_TIMEOUT: Durée maximale d'attente d'une réponse de l'API en secondes. (default : 2)
+        - 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)
 
-    SCANNER (Scanner)
+# ALREADY IMPLEMENTED
-        PORTS_TO_SCAN: Liste des ports à scanner pour détecter des serveurs potentiellement malveillants. (default : [])
 
-    SÉCURITÉ (Sécurité)
+    - Connexion en tant que service
-        WHITELISTED_IP: Liste d'adresses IP autorisées à contourner certaines restrictions. (default : ['127.0.0.1'])
+    - Gestion des messages reçus/envoyés par le serveur
-        GLINE_DURATION: Durée de bannissement temporaire d'un utilisateur en minutes. (default : "30")
+    - 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]
 
-    DEBUG (Debug)
+    Reputation security
-        DEBUG_LEVEL: Niveau de verbosité des messages de debug (plus grand est le nombre, plus il y a d'informations). (default : 20) Pour une production
+        - 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
-    Modification de la configuration
+        - 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
-        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.
+        - Defender devra reconnaitre le code --> OK
-
+        - Defender devra liberer l'utilisateur et l'envoyer vers un salon définit dans la configuration --> OK
-## Exemple de configuration de base
-```json
-{
-    "SERVEUR_IP": "IP.DE.TON.SERVER",
-    "SERVEUR_HOSTNAME": "HOST.DE.TON.SERVER",
-    "SERVEUR_LINK": "LINK.DE.TON.SERVER",
-    "SERVEUR_PORT": 6901,
-    "SERVEUR_PASSWORD": "MOT_DE_PASS_DE_TON_LINK",
-    "SERVEUR_ID": "10Z",
-    "SERVEUR_SSL": true,
-
-    "SERVICE_NAME": "defender",
-    "SERVICE_NICKNAME": "PyDefender",
-    "SERVICE_REALNAME": "Python Defender Security",
-    "SERVICE_USERNAME": "PyDefender",
-    "SERVICE_HOST": "HOST.DE.TON.DEFENDER",
-
-    "OWNER": "TON_NICK_NAME",
-    "PASSWORD": "TON_PASSWORD"
-
-}
-
-```
-
-## Exemple complet de configuration
-```json
-{
-    "SERVEUR_IP": "YOUR.SERVER.IP",
-    "SERVEUR_HOSTNAME": "YOUR.SERVER.HOST",
-    "SERVEUR_LINK": "LINK.DE.TON.SERVER",
-    "SERVEUR_PORT": 6901,
-    "SERVEUR_PASSWORD": "YOUR_LINK_PASSWORD",
-    "SERVEUR_ID": "10Z",
-    "SERVEUR_SSL": true,
-
-    "SERVICE_NAME": "defender",
-    "SERVICE_NICKNAME": "PyDefender",
-    "SERVICE_REALNAME": "Python Defender Security",
-    "SERVICE_USERNAME": "PyDefender",
-    "SERVICE_HOST": "HOST.DE.TON.DEFENDER",
-    "SERVICE_INFO": "Network IRC Service",
-    "SERVICE_CHANLOG": "#services",
-    "SERVICE_SMODES": "+ioqBS",
-    "SERVICE_CMODES": "ntsOP",
-    "SERVICE_UMODES": "o",
-    "SERVICE_PREFIX": "!",
-
-    "OWNER": "TON_NICK_NAME",
-    "PASSWORD": "TON_PASSWORD",
-
-    "JSONRPC_URL": "https://your.domaine.com:8600/api",
-    "JSONRPC_PATH_TO_SOCKET_FILE": "/PATH/TO/YOUR/IRCD/data/rpc.socket",
-    "JSONRPC_METHOD": "socket",
-    "JSONRPC_USER": "YOUR_RPC_USER",
-    "JSONRPC_PASSWORD": "YOUR_RPC_PASSWORD",
-
-    "SALON_JAIL": "#jail",
-    "SALON_JAIL_MODES": "sS",
-    "SALON_LIBERER": "#welcome",
-
-    "CLONE_CHANNEL": "#clones",
-    "CLONE_CMODES": "+nts",
-    "CLONE_LOG_HOST_EXEMPT": ["HOST.TO.SKIP"],
-    "CLONE_CHANNEL_PASSWORD": "YOUR_CHANNEL_PASSWORD",
-
-    "API_TIMEOUT": 2,
-
-    "PORTS_TO_SCAN": [3028, 8080, 1080, 1085, 4145, 9050],
-    "WHITELISTED_IP": ["127.0.0.1"],
-    "GLINE_DURATION": "30",
-
-    "DEBUG_LEVEL": 20
-
-}
-```
-
-# \\!/ Attention \\!/
-Le mot de passe de l'administrateur et le mot de passe du service doivent être modifiés pour des raisons de sécurité.
-Ne partagez pas vos informations de connexion au serveur IRC avec des tiers.
-a votre premiere connexion vous devez tapez 
-```
-    /msg [NomDuService] auth [nickname] [password]
-    -- Une fois identifié tapez la commande suivante
-    /msg [NomDuService] editaccess [nickname] [Nouveau-Password] 5
-```
-# Unrealircd configuration
-```
-listen {
-	ip *;
-	port 6901;
-	options { tls; serversonly; }
-}
-
-link LINK.DE.TON.SERVER
-{
-
-	incoming {
-                mask *;
-                bind-ip *;
-                port 6901;
-                //options { tls; };
-        }
-
-	outgoing {
-                bind-ip *; /* ou une IP précise */
-                hostname LINK.DE.TON.SERVER;
-                port 6901;
-                //options { tls; }
-        }
-
-	password "YOUR_LINK_PASSWORD";
-	
-        class servers;
-
-}
-
-ulines {
-	LINK.DE.TON.SERVER;
-}
-```
-
-# Extension:
-    Le code est modulaire et conçu pour être facilement étendu. Vous pouvez ajouter de nouvelles commandes, de nouvelles fonctionnalités (mods/mod_test.py  est un exemple pour bien demarrer la création de son module).
-
-# 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

@@ -10,15 +10,12 @@ class User:
         uid: str
         nickname: str
         username: str
-        realname: str
         hostname: str
         umodes: str
         vhost: str
         isWebirc: bool
-        isWebsocket: bool
         remote_ip: str
         score_connexion: int
-        geoip: str = None
         connexion_datetime: datetime = field(default=datetime.now())
 
     UID_DB: list[UserModel] = []
@@ -41,10 +38,8 @@ class User:
 
         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)
@@ -70,11 +65,9 @@ class User:
 
         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}')
@@ -94,11 +87,9 @@ class User:
 
         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')
@@ -188,10 +179,8 @@ class Admin:
 
         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)
@@ -209,11 +198,9 @@ class Admin:
 
         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}')
@@ -226,11 +213,9 @@ class Admin:
 
         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')
@@ -278,19 +263,9 @@ 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
@@ -298,20 +273,12 @@ class Channel:
         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')
                 
@@ -322,11 +289,9 @@ class Channel:
                 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})')
@@ -342,12 +307,9 @@ class Channel:
 
         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')
@@ -363,33 +325,13 @@ class Channel:
                     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}')
+                            self.log.debug(f'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}')
+                    self.log.debug(f'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:
@@ -406,101 +348,12 @@ class Channel:
 
         return Channel
 
-class Clones:
+    def get_mode(self, name:str) -> Union[str, None]:
 
-    @dataclass
+        mode = None
-    class CloneModel:
+        for record in self.UID_CHANNEL_DB:
-        alive: bool
+            if record.name == name:
-        nickname: str
+                mode = record.mode
-        username: str
-        realname: str
-        channels: list
-        vhost: str = None
-        init: bool = True
-        connected: bool = False
 
-    UID_CLONE_DB: list[CloneModel] = []
+        self.log.debug(f'The mode of the channel {name} has been found: {mode}')
-
+        return mode
-    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,27 +1,17 @@
-import os
+import time, threading, os, random, socket, hashlib, ipaddress, logging, requests, json, re
-import re
+from typing import Union
-import json
+from base64 import b64decode
-import time
+from datetime import datetime
-import random
-import socket
-import hashlib
-import logging
-import threading
-import ipaddress
-
-import ast
-import requests
-
-from dataclasses import fields
-from typing import Union, Literal
-from base64 import b64decode, b64encode
-from datetime import datetime, timedelta, timezone
 from sqlalchemy import create_engine, Engine, Connection, CursorResult
 from sqlalchemy.sql import text
 from core.loadConf import ConfigDataModel
 
 class Base:
 
+    CORE_DB_PATH = 'core' + os.sep + 'db' + os.sep              # Le dossier bases de données core
+    MODS_DB_PATH = 'mods' + os.sep + 'db' + os.sep              # Le dossier bases de données des modules
+    PYTHON_MIN_VERSION = '3.10'                                 # Version min de python
+
     def __init__(self, Config: ConfigDataModel) -> None:
 
         self.Config = Config                                    # Assigner l'objet de configuration
@@ -35,10 +25,11 @@ 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 __set_current_defender_version(self) -> None:
         """This will put the current version of Defender
         located in version.json
@@ -56,7 +47,7 @@ class Base:
     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')
+            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 = {
@@ -65,9 +56,9 @@ class Base:
             }
 
             if token == '':
-                response = requests.get(json_url, timeout=self.Config.API_TIMEOUT)
+                response = requests.get(json_url)
             else:
-                response = requests.get(json_url, headers=headers, timeout=self.Config.API_TIMEOUT)
+                response = requests.get(json_url, headers=headers)
 
             response.raise_for_status()  # Vérifie si la requête a réussi
             json_response:dict = response.json()
@@ -119,11 +110,7 @@ class Base:
         Cette fonction retourne un UNIXTIME de type 12365456
         Return: Current time in seconds since the Epoch (int)
         """
-        cet_offset = timezone(timedelta(hours=2))
-        now_cet = datetime.now(cet_offset)
-        unixtime_cet = int(now_cet.timestamp())
         unixtime = int( time.time() )
-
         return unixtime
 
     def get_datetime(self) -> str:
@@ -133,16 +120,6 @@ class Base:
         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
 
@@ -171,7 +148,7 @@ class Base:
                               encoding='UTF-8',
                               format='%(asctime)s - %(levelname)s - %(filename)s - %(lineno)d - %(funcName)s - %(message)s')
 
-        self.logs.info('#################### STARTING DEFENDER ####################')
+        self.logs.info('#################### STARTING INTERCEPTOR HQ ####################')
 
         return None
 
@@ -203,8 +180,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.Config.table_module} WHERE module_name = :module_name"
+        query = f"SELECT id FROM {self.Config.table_module} WHERE module = :module"
-        mes_donnes = {'module_name': module_name}
+        mes_donnes = {'module': module_name}
         results = self.db_execute_query(query, mes_donnes)
 
         if results.fetchall():
@@ -212,7 +189,7 @@ class Base:
         else:
             return False
 
-    def db_record_module(self, user_cmd:str, module_name:str, isdefault:int = 0) -> None:
+    def db_record_module(self, user_cmd:str, module_name:str) -> None:
         """Enregistre les modules dans la base de données
 
         Args:
@@ -221,9 +198,10 @@ class Base:
 
         if not self.db_isModuleExist(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)"
+            insert_cmd_query = f"INSERT INTO {self.Config.table_module} (datetime, user, module) VALUES (:datetime, :user, :module)"
-            mes_donnees = {'datetime': self.get_datetime(), 'user': user_cmd, 'module_name': module_name, 'isdefault': isdefault}
+            mes_donnees = {'datetime': self.get_datetime(), 'user': user_cmd, 'module': module_name}
             self.db_execute_query(insert_cmd_query, mes_donnees)
+            # self.db_close_session(self.session)
         else:
             self.logs.debug(f"Le module {module_name} existe déja dans la base de données")
 
@@ -233,180 +211,14 @@ class Base:
         """Supprime les modules de la base de données
 
         Args:
-            cmd (str): le module a supprimer
+            cmd (str): le module a enregistrer
         """
-        insert_cmd_query = f"DELETE FROM {self.Config.table_module} WHERE module_name = :module_name"
+        insert_cmd_query = f"DELETE FROM {self.Config.table_module} WHERE module = :module"
-        mes_donnees = {'module_name': module_name}
+        mes_donnees = {'module': 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 = self.Config.table_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}')
-            else:
-                self.logs.error(f'Parameter NOT updated : {param_key} - {param_value} | Module: {module_name}')
-        else:
-            self.logs.error(f'Parameter and Module do not exist: Param ({param_key}) - Value ({param_value}) | Module ({module_name})')
-
-        self.logs.debug(dataclassObj)
-
-        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.Config.table_admin}")
@@ -444,14 +256,7 @@ class Base:
         except AssertionError as ae:
             self.logs.error(f'Assertion Error -> {ae}')
 
-    def create_thread(self, func:object, func_args: tuple = (), run_once:bool = False, daemon: bool = True) -> None:
+    def create_thread(self, func:object, func_args: tuple = (), run_once:bool = False) -> None:
-        """Create a new thread and store it into running_threads variable
-
-        Args:
-            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__
 
@@ -460,7 +265,11 @@ class Base:
                     if thread.getName() == func_name:
                         return None
 
-            th = threading.Thread(target=func, args=func_args, name=str(func_name), daemon=daemon)
+            # if func_name in self.running_threads:
+            #     print(f"HeartBeat is running")
+            #     return None
+
+            th = threading.Thread(target=func, args=func_args, name=str(func_name), daemon=True)
             th.start()
 
             self.running_threads.append(th)
@@ -493,7 +302,7 @@ class Base:
                 if thread.getName() != 'heartbeat':
                     if not thread.is_alive():
                         self.running_threads.remove(thread)
-                        self.logs.info(f"Thread {str(thread.getName())} {str(thread.native_id)} removed")
+                        self.logs.debug(f"Thread {str(thread.getName())} {str(thread.native_id)} removed")
 
             # print(threading.enumerate())
         except AssertionError as ae:
@@ -548,7 +357,6 @@ class Base:
         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)
@@ -558,23 +366,14 @@ class Base:
 
     def __create_db(self) -> None:
 
-        table_core_log = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_log} (
+        table_logs = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_log} (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             datetime TEXT,
             server_msg TEXT
             ) 
         '''
 
-        table_core_config = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_config} (
+        table_cmds = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_commande} (
-            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,
@@ -582,24 +381,15 @@ class Base:
             )
         '''
 
-        table_core_module = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_module} (
+        table_modules = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_module} (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             datetime TEXT,
             user TEXT,
-            module_name TEXT,
+            module TEXT
-            isdefault INTEGER
             )
         '''
 
-        table_core_channel = '''CREATE TABLE IF NOT EXISTS core_channel (
+        table_admins = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_admin} (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            datetime TEXT,
-            module_name TEXT,
-            channel_name TEXT
-            )
-        '''
-
-        table_core_admin = f'''CREATE TABLE IF NOT EXISTS {self.Config.table_admin} (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             createdOn TEXT,
             user TEXT,
@@ -610,17 +400,10 @@ class Base:
             )
         '''
 
-        self.db_execute_query(table_core_log)
+        self.db_execute_query(table_logs)
-        self.db_execute_query(table_core_log_command)
+        self.db_execute_query(table_cmds)
-        self.db_execute_query(table_core_module)
+        self.db_execute_query(table_modules)
-        self.db_execute_query(table_core_admin)
+        self.db_execute_query(table_admins)
-        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
 
@@ -697,17 +480,6 @@ class Base:
             self.logs.critical(f'This remote ip is not valid : {ve}')
             return None
 
-    # def encode_ip(self, remote_ip_address: str) -> Union[str, None]:
-
-    #     binary_ip = b64encode()
-    #     try:
-    #         decoded_ip = ipaddress.ip_address(binary_ip)
-
-    #         return decoded_ip.exploded
-    #     except ValueError as ve:
-    #         self.logs.critical(f'This remote ip is not valid : {ve}')
-    #         return None
-
     def get_random(self, lenght:int) -> str:
         """
         Retourn une chaîne aléatoire en fonction de la longueur spécifiée.
@@ -737,7 +509,7 @@ class Base:
         self.periodic_func.clear()
 
     def clean_uid(self, uid:str) -> str:
-        """Clean UID by removing @ / % / + / ~ / * / :
+        """Clean UID by removing @ / % / + / Owner / and *
 
         Args:
             uid (str): The UID to clean
@@ -746,7 +518,7 @@ class Base:
             str: Clean UID without any sign
         """
 
-        pattern = fr'[:|@|%|\+|~|\*]*'
+        pattern = fr'[@|%|\+|~|\*]*'
         parsed_UID = re.sub(pattern, '', uid)
 
         return parsed_UID
@@ -760,10 +532,6 @@ class Base:
         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)
@@ -772,7 +540,3 @@ class Base:
             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

@@ -1,274 +0,0 @@
-import socket
-import ssl
-import traceback
-from ssl import SSLSocket
-from typing import Union
-from core.loadConf import Config
-from core.Model import Clones
-from core.base import Base
-
-class Connection:
-
-    def __init__(self, server_port: int, nickname: str, username: str, realname: str, channels:list[str], CloneObject: Clones, ssl:bool = False) -> None:
-
-        self.Config = Config().ConfigObject
-        self.Base = Base(self.Config)
-        self.IrcSocket: Union[socket.socket, SSLSocket] = None
-        self.nickname = nickname
-        self.username = username
-        self.realname = realname
-        self.clone_chanlog = self.Config.CLONE_CHANNEL
-        self.clone_log_exempt = self.Config.CLONE_LOG_HOST_EXEMPT
-        self.channels:list[str] = channels
-        self.CHARSET = ['utf-8', 'iso-8859-1']
-        self.Clones = CloneObject
-        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, disconnect: bool = False) -> None:
-        """Envoit les commandes à envoyer au serveur.
-
-        Args:
-            string (Str): contient la commande à envoyer au serveur.
-        """
-        try:
-            with self.Base.lock:
-                self.IrcSocket.send(f"{send_message}\r\n".encode(self.CHARSET[0]))
-                self.Base.logs.debug(f'<<{self.currentCloneObject.nickname}>>: {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
-            realname = self.realname
-
-            # Envoyer un message d'identification
-            writer.send(f"USER {nickname} {username} {username} {nickname} {username} :{username}\r\n".encode('utf-8'))
-            writer.send(f"USER {username} {username} {username} :{realname}\r\n".encode('utf-8'))
-            writer.send(f"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:
-                        # If no data then quit the loop
-                        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_WR)
-            self.IrcSocket.shutdown(socket.SHUT_RD)
-            self.currentCloneObject.init = False
-            self.Base.logs.info(f"<<{self.currentCloneObject.nickname}>> 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}")
-            self.Base.logs.critical(f"{traceback.format_exc()}")
-        except Exception as e:
-            self.Base.logs.error(f"Exception: {e}")
-
-    def parser(self, cmd:list[bytes]):
-        try:
-
-            for data in cmd:
-                response = data.decode(self.CHARSET[0]).split()
-                current_clone_nickname = self.currentCloneObject.nickname
-                # 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.Base.logs.info(f"<<{self.currentCloneObject.nickname}>> {response} ...")
-                            self.currentCloneObject.connected = False
-                        else:
-                            self.Base.logs.info(f"<<{self.currentCloneObject.nickname}>> {response} ...")
-                            # self.signal = False
-
-                match response[1]:
-                    case '376':
-                        # End of MOTD
-                        self.currentCloneObject.connected = True
-                        self.currentCloneObject.init = False
-                        for channel in self.channels:
-                            self.send2socket(f"JOIN {channel}")
-
-                        self.send2socket(f"JOIN {self.clone_chanlog} {self.Config.CLONE_CHANNEL_PASSWORD}")
-
-                        return None
-
-                    case '422':
-                        # Missing MOTD
-                        self.currentCloneObject.connected = True
-                        self.currentCloneObject.init = False
-                        for channel in self.channels:
-                            self.send2socket(f"JOIN {channel}")
-
-                        self.send2socket(f"JOIN {self.clone_chanlog} {self.Config.CLONE_CHANNEL_PASSWORD}")
-                        return None
-
-                    case '433':
-                        # Nickname already in use
-                        self.currentCloneObject.connected = False
-                        self.currentCloneObject.init = False
-                        self.send2socket(f'QUIT :Thanks and goodbye')
-                        self.Base.logs.warning(f"Nickname {self.currentCloneObject.nickname} already in use >> Clone should be disconnected")
-                        return None
-
-                    case 'PRIVMSG':
-                        self.Base.logs.debug(f'<<{self.currentCloneObject.nickname}>> Response: {response}')
-                        self.Base.logs.debug(f'<<{self.currentCloneObject.nickname}>> Alive: {self.currentCloneObject.alive}')
-                        fullname = str(response[0]).replace(':', '')
-                        nickname = fullname.split('!')[0].replace(':','')
-
-                        if response[2] == current_clone_nickname and nickname != self.Config.SERVICE_NICKNAME:
-                            message = []
-                            for i in range(3, len(response)):
-                                    message.append(response[i])
-                            final_message = ' '.join(message)
-
-                            exampt = False
-                            for log_exception in self.clone_log_exempt:
-                                if log_exception in fullname:
-                                    exampt = True
-
-                            if not exampt:
-                                self.send2socket(f"PRIVMSG {self.clone_chanlog} :{fullname} => {final_message[1:]}")
-
-                        if nickname == self.Config.SERVICE_NICKNAME:
-                            command = str(response[3]).replace(':','')
-
-                            if command == 'KILL':
-                                self.send2socket(f'QUIT :Thanks and goodbye')
-
-                            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/exemple_configuration.json

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

core/installation.py

@@ -1,164 +1,44 @@
-import os
+from importlib.util import find_spec
+from subprocess import check_call, run
+from platform import python_version
 from sys import exit
-from dataclasses import dataclass
-from subprocess import check_call, run, CalledProcessError, PIPE
-from platform import python_version, python_version_tuple
 
 class Install:
 
-    @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
-
     def __init__(self) -> None:
+        self.PYTHON_MIN_VERSION = '3.10'
+        self.module_to_install = ['sqlalchemy','psutil','requests']
 
-        self.set_configuration()
+        if not self.checkPythonVersion():
-
+            # Tester si c'est la bonne version de python
-        if self.skip_install:
+            exit("Python Version Error")
-            return None
+        else:
-
             # Sinon tester les dependances python et les installer avec pip
-        if self.do_install():
+            self.checkDependencies()
-
-            self.install_dependencies()
-
-            self.create_service_file()
-
-            self.print_final_message()
 
         return None
 
-    def set_configuration(self):
+    def checkPythonVersion(self) -> bool:
-
-        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','unrealircd_rpc_py'],
-                venv_pip_executable=f'{os.path.join(defender_install_folder, venv_folder, "bin")}{os.sep}pip',
-                venv_python_executable=f'{os.path.join(defender_install_folder, venv_folder, "bin")}{os.sep}python'
-            )
-
-        if not self.check_python_version():
-            # If the Python version is not good then Exit
-            exit("/!\\ Python version error /!\\")
-
-        if not os.path.exists(os.path.join(self.config.defender_install_folder, 'core', 'configuration.json')):
-            # If configuration file do not exist
-            exit("/!\\ Configuration file (configuration.json) doesn't exist /!\\")
-
-        # Exclude Windows OS from the installation
-        if os.name == 'nt':
-            #print('/!\\ Skip installation /!\\')
-            self.skip_install = True
-            return False
-
-        if self.is_root():
-            exit(f'/!\\ I highly not recommend running Defender as root /!\\')
-            self.skip_install = True
-            return False
-
-    def is_root(self) -> bool:
-
-        if os.geteuid() != 0:
-            print('User without privileges ==> 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
         """
-        # Current system version
+        python_required_version = self.PYTHON_MIN_VERSION.split('.')
-        sys_major, sys_minor, sys_patch = self.config.python_current_version_tuple
+        python_current_version = python_version().split('.')
 
-        # min python version required
+        if int(python_current_version[0]) < int(python_required_version[0]):
-        python_required_version = self.config.python_min_version.split('.')
+            print(f"## Your python version must be greather than or equal to {self.PYTHON_MIN_VERSION} ##")
-        min_major, min_minor = tuple((python_required_version[0], python_required_version[1]))
+            return False
-
+        elif int(python_current_version[1]) < int(python_required_version[1]):
-        if int(sys_major) < int(min_major):
+            print(f"### Your python version must be greather than or equal to {self.PYTHON_MIN_VERSION} ###")
-            print(f"## Your python version must be greather than or equal to {self.config.python_min_version} ##")
             return False
 
-        elif (int(sys_major) <= int(min_major)) and (int(sys_minor) < int(min_minor)):
+        print(f"===> Version of python : {python_version()} ==> OK")
-            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 check_package(self, package_name) -> bool:
+    def checkDependencies(self) -> None:
-
-        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
@@ -166,83 +46,27 @@ class Install:
         """
         do_install = False
 
-        # Check if virtual env exist
+        for module in self.module_to_install:
-        if not os.path.exists(f'{os.path.join(self.config.defender_install_folder, self.config.venv_folder)}'):
+            if find_spec(module) is None:
-            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")
-        self.run_subprocess([self.config.venv_pip_executable, 'cache', 'purge'])
+        check_call(['pip','cache','purge'])
         
         print("===> Verifier si pip est a jour")
-        self.run_subprocess([self.config.venv_python_executable, '-m', 'pip', 'install', '--upgrade', 'pip'])
+        check_call(['python', '-m', 'pip', 'install', '--upgrade', 'pip'])
 
-        if not self.check_package('greenlet'):
+        if find_spec('greenlet') is None:
-            self.run_subprocess([self.config.venv_pip_executable, 'install', '--only-binary', ':all:', 'greenlet'])
+            check_call(['pip','install', '--only-binary', ':all:', 'greenlet'])
             print('====> Module Greenlet installé')
 
-        for module in self.config.venv_cmd_requirements:
+        for module in self.module_to_install:
-            if not self.check_package(module):
+            if find_spec(module) is None:
                 print("### Trying to install missing python packages ###")
-                self.run_subprocess([self.config.venv_pip_executable, 'install', module])
+                check_call(['pip','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

@@ -1,181 +1,66 @@
-import sys
 import json
 from os import sep
-from typing import Union, Literal
+from typing import Union
 from dataclasses import dataclass, field
 
 ##########################################
 #   CONFIGURATION FILE                   #
 ##########################################
 
-@dataclass
-class ColorModel:
-    white: str  = "\x0300"
-    black: str  = "\x0301"
-    blue: str   = "\x0302"
-    green: str  = "\x0303"
-    red: str    = "\x0304"
-    yellow: str = "\x0306"
-    bold: str   = "\x02"
-    nogc: str   = "\x03"
-
 @dataclass
 class ConfigDataModel:
 
     SERVEUR_IP: str
-    """Server public IP (could be 127.0.0.1 localhost)"""
+    SERVEUR_HOSTNAME: str                     # Le hostname du serveur IRC
+    SERVEUR_LINK: str                 # Host attendu par votre IRCd (ex. dans votre link block pour Unrealircd)
+    SERVEUR_PORT: int                                     # Port du link
+    SERVEUR_PASSWORD: str             # Mot de passe du link (Privilégiez argon2 sur Unrealircd)
+    SERVEUR_ID: str                                      # SID (identification) du bot en tant que Services
+    SERVEUR_SSL: bool                                      # Activer la connexion SSL
 
-    SERVEUR_HOSTNAME: str
+    SERVICE_NAME: str                               # Le nom du service
-    """IRC Server Hostname (your.hostname.extension)"""
+    SERVICE_NICKNAME: str                     # Nick du bot sur IRC
+    SERVICE_REALNAME: str                     # Realname du bot
+    SERVICE_USERNAME: str                     # Ident du bot
+    SERVICE_HOST: str                 # Host du bot
+    SERVICE_INFO: str                    # swhois du bot
+    SERVICE_CHANLOG: str                           # Salon des logs et autres messages issus du bot
+    SERVICE_SMODES: str                               # Mode du service
+    SERVICE_CMODES: str                                 # Mode du salon (#ChanLog) que le bot appliquera à son entrée
+    SERVICE_UMODES: str                                    # Mode que le bot pourra se donner à sa connexion au salon chanlog
+    SERVICE_PREFIX: str                                    # Prefix pour envoyer les commandes au bot
+    SERVICE_ID: str = field(init=False)                      # L'identifiant du service
 
-    SERVEUR_LINK: str
+    OWNER: str                                        # Identifiant du compte admin
-    """The link hostname (should be the same as your unrealircd link block)"""
+    PASSWORD: str                                     # Mot de passe du compte admin
 
-    SERVEUR_PORT: int
+    SALON_JAIL: str                                    # Salon pot de miel
-    """Server port as configured in your unrealircd link block"""
+    SALON_JAIL_MODES: str                                 # Mode du salon pot de miel
+    SALON_LIBERER: str                              # Le salon ou sera envoyé l'utilisateur clean
 
-    SERVEUR_PASSWORD: str
+    API_TIMEOUT: int                                         # Timeout des api's
-    """Your link password"""
 
-    SERVEUR_ID: str
+    PORTS_TO_SCAN: list    # Liste des ports a scanné pour une detection de proxy
-    """Service identification could be Z01 should be unique"""
+    WHITELISTED_IP: list                          # IP a ne pas scanner
+    GLINE_DURATION: str                                   # La durée du gline
 
-    SERVEUR_SSL: bool
+    DEBUG_LEVEL: int                                        # Le niveau des logs DEBUG 10 | INFO 20 | WARNING 30 | ERROR 40 | CRITICAL 50
-    """Activate SSL connexion"""
 
-    SERVICE_NAME: str
+    CONFIG_COLOR: dict[str, 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"""
-
-    JSONRPC_URL: str
-    """The RPC url, if local https://127.0.0.1:PORT/api should be fine"""
-
-    JSONRPC_PATH_TO_SOCKET_FILE: str
-    """The full path of the socket file (/PATH/TO/YOUR/UNREALIRCD/SOCKET/FILE.socket)"""
-
-    JSONRPC_METHOD: str
-    """3 methods are available; requests/socket/unixsocket"""
-
-    JSONRPC_USER: str
-    """The RPC User defined in your unrealircd.conf"""
-
-    JSONRPC_PASSWORD: str
-    """The RPC Password defined in your unrealircd.conf"""
-
-    SALON_JAIL: str
-    """The JAIL channel (ex. #jail)"""
-
-    SALON_JAIL_MODES: str
-    """The jail channel modes (ex. sS)"""
-
-    SALON_LIBERER: str
-    """Channel where the nickname will be released"""
-
-    CLONE_CHANNEL: str
-    """Channel where clones are hosted and will log PRIVMSG"""
-
-    CLONE_CMODES: str
-    """Clone channel modes"""
-
-    CLONE_LOG_HOST_EXEMPT: list[str]
-    """Hosts that clones will not log"""
-
-    CLONE_CHANNEL_PASSWORD: str
-    """Clone password channel"""
-
-    API_TIMEOUT: int
-    """Default api timeout in second"""
-
-    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"""
 
     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"""
-
-    COLORS: ColorModel = field(default_factory=ColorModel)
-    """Available colors in Defender"""
-
-    BATCH_SIZE: int = 400
-    """The batch size used for privmsg and notice"""
 
     def __post_init__(self):
         # Initialiser SERVICE_ID après la création de l'objet
         self.SERVICE_ID:str = f"{self.SERVEUR_ID}AAAAAB"
-        """The service ID which is SERVEUR_ID and AAAAAB"""
 
 class Config:
 
@@ -185,72 +70,53 @@ class Config:
         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)
 
-            return configuration
+        for key, value in configuration['CONFIG_COLOR'].items():
+            configuration['CONFIG_COLOR'][key] = str(value).encode('utf-8').decode('unicode_escape')
         
-        except FileNotFoundError as fe:
+        return configuration
-            print(f'FileNotFound: {fe}')
-            print('Configuration file not found please create core/configuration.json')
-            sys.exit(0)
-        except KeyError as ke:
-            print(f'Key Error: {ke}')
-            print('The key must be defined in core/configuration.json')
     
     def __load_service_configuration(self) -> ConfigDataModel:
         import_config = self.__load_json_service_configuration()
 
         ConfigObject: ConfigDataModel = ConfigDataModel(
-            SERVEUR_IP=import_config["SERVEUR_IP"] if "SERVEUR_IP" in import_config else '127.0.0.1',
+            SERVEUR_IP=import_config["SERVEUR_IP"],
-            SERVEUR_HOSTNAME=import_config["SERVEUR_HOSTNAME"] if "SERVEUR_HOSTNAME" in import_config else None,
+            SERVEUR_HOSTNAME=import_config["SERVEUR_HOSTNAME"],
-            SERVEUR_LINK=import_config["SERVEUR_LINK"] if "SERVEUR_LINK" in import_config else None,
+            SERVEUR_LINK=import_config["SERVEUR_LINK"],
-            SERVEUR_PORT=import_config["SERVEUR_PORT"] if "SERVEUR_PORT" in import_config else 6667,
+            SERVEUR_PORT=import_config["SERVEUR_PORT"],
-            SERVEUR_PASSWORD=import_config["SERVEUR_PASSWORD"] if "SERVEUR_PASSWORD" in import_config else None,
+            SERVEUR_PASSWORD=import_config["SERVEUR_PASSWORD"],
-            SERVEUR_ID=import_config["SERVEUR_ID"] if "SERVEUR_ID" in import_config else '19Z',
+            SERVEUR_ID=import_config["SERVEUR_ID"],
-            SERVEUR_SSL=import_config["SERVEUR_SSL"] if "SERVEUR_SSL" in import_config else False,
+            SERVEUR_SSL=import_config["SERVEUR_SSL"],
-            SERVICE_NAME=import_config["SERVICE_NAME"] if "SERVICE_NAME" in import_config else 'Defender',
+            SERVICE_NAME=import_config["SERVICE_NAME"],
-            SERVICE_NICKNAME=import_config["SERVICE_NICKNAME"] if "SERVICE_NICKNAME" in import_config else 'Defender',
+            SERVICE_NICKNAME=import_config["SERVICE_NICKNAME"],
-            SERVICE_REALNAME=import_config["SERVICE_REALNAME"] if "SERVICE_REALNAME" in import_config else 'Defender Security',
+            SERVICE_REALNAME=import_config["SERVICE_REALNAME"],
-            SERVICE_USERNAME=import_config["SERVICE_USERNAME"] if "SERVICE_USERNAME" in import_config else 'IRCSecurity',
+            SERVICE_USERNAME=import_config["SERVICE_USERNAME"],
-            SERVICE_HOST=import_config["SERVICE_HOST"] if "SERVICE_HOST" in import_config else 'defender.local.network',
+            SERVICE_HOST=import_config["SERVICE_HOST"],
-            SERVICE_INFO=import_config["SERVICE_INFO"] if "SERVICE_INFO" in import_config else 'Defender Network IRC Service',
+            SERVICE_INFO=import_config["SERVICE_INFO"],
-            SERVICE_CHANLOG=import_config["SERVICE_CHANLOG"] if "SERVICE_CHANLOG" in import_config else '#services',
+            SERVICE_CHANLOG=import_config["SERVICE_CHANLOG"],
-            SERVICE_SMODES=import_config["SERVICE_SMODES"] if "SERVICE_SMODES" in import_config else '+ioqBS',
+            SERVICE_SMODES=import_config["SERVICE_SMODES"],
-            SERVICE_CMODES=import_config["SERVICE_CMODES"] if "SERVICE_CMODES" in import_config else 'ntsOP',
+            SERVICE_CMODES=import_config["SERVICE_CMODES"],
-            SERVICE_UMODES=import_config["SERVICE_UMODES"] if "SERVICE_UMODES" in import_config else 'o',
+            SERVICE_UMODES=import_config["SERVICE_UMODES"],
-            SERVICE_PREFIX=import_config["SERVICE_PREFIX"] if "SERVICE_PREFIX" in import_config else '!',
+            SERVICE_PREFIX=import_config["SERVICE_PREFIX"],
-            OWNER=import_config["OWNER"] if "OWNER" in import_config else 'admin',
+            OWNER=import_config["OWNER"],
-            PASSWORD=import_config["PASSWORD"] if "PASSWORD" in import_config else 'admin',
+            PASSWORD=import_config["PASSWORD"],
-
+            SALON_JAIL=import_config["SALON_JAIL"],
-            JSONRPC_METHOD=import_config["JSONRPC_METHOD"] if "JSONRPC_METHOD" in import_config else 'socket',
+            SALON_JAIL_MODES=import_config["SALON_JAIL_MODES"],
-            JSONRPC_URL=import_config["JSONRPC_URL"] if "JSONRPC_URL" in import_config else None,
+            SALON_LIBERER=import_config["SALON_LIBERER"],
-            JSONRPC_PATH_TO_SOCKET_FILE=import_config["JSONRPC_PATH_TO_SOCKET_FILE"] if "JSONRPC_PATH_TO_SOCKET_FILE" in import_config else None,
+            API_TIMEOUT=import_config["API_TIMEOUT"],
-            JSONRPC_USER=import_config["JSONRPC_USER"] if "JSONRPC_USER" in import_config else None,
+            PORTS_TO_SCAN=import_config["PORTS_TO_SCAN"],
-            JSONRPC_PASSWORD=import_config["JSONRPC_PASSWORD"] if "JSONRPC_PASSWORD" in import_config else None,
+            WHITELISTED_IP=import_config["WHITELISTED_IP"],
-
+            GLINE_DURATION=import_config["GLINE_DURATION"],
-            SALON_JAIL=import_config["SALON_JAIL"] if "SALON_JAIL" in import_config else '#jail',
+            DEBUG_LEVEL=import_config["DEBUG_LEVEL"],
-            SALON_JAIL_MODES=import_config["SALON_JAIL_MODES"] if "SALON_JAIL_MODES" in import_config else 'sS',
+            CONFIG_COLOR=import_config["CONFIG_COLOR"],
-            SALON_LIBERER=import_config["SALON_LIBERER"] if "SALON_LIBERER" in import_config else '#welcome',
+            table_admin='sys_admins',
-
+            table_commande='sys_commandes',
-            CLONE_CHANNEL=import_config["CLONE_CHANNEL"] if "CLONE_CHANNEL" in import_config else '#clones',
+            table_log='sys_logs',
-            CLONE_CMODES=import_config["CLONE_CMODES"] if "CLONE_CMODES" in import_config else '+nts',
+            table_module='sys_modules',
-            CLONE_LOG_HOST_EXEMPT=import_config["CLONE_LOG_HOST_EXEMPT"] if "CLONE_LOG_HOST_EXEMPT" in import_config else [],
-            CLONE_CHANNEL_PASSWORD=import_config["CLONE_CHANNEL_PASSWORD"] if "CLONE_CHANNEL_PASSWORD" in import_config else "clone_Password_1234",
-
-            API_TIMEOUT=import_config["API_TIMEOUT"] if "API_TIMEOUT" in import_config else 2,
-            PORTS_TO_SCAN=import_config["PORTS_TO_SCAN"] if "PORTS_TO_SCAN" in import_config else [],
-            WHITELISTED_IP=import_config["WHITELISTED_IP"] if "WHITELISTED_IP" in import_config else ['127.0.0.1'],
-            GLINE_DURATION=import_config["GLINE_DURATION"] if "GLINE_DURATION" in import_config else '30',
-            DEBUG_LEVEL=import_config["DEBUG_LEVEL"] if "DEBUG_LEVEL" in import_config else 20,
-            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',

mods/mod_clone.py

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

mods/mod_command.py

@@ -1,823 +0,0 @@
-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', 'topic',
-                'wallops', 'globops','gnotice','whois', 'names', 'invite', 'inviteme']
-        }
-
-        # 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:
-
-        service_id = self.Config.SERVICE_ID                 # Defender serveur id
-        dnickname = self.Config.SERVICE_NICKNAME
-        dchanlog = self.Config.SERVICE_CHANLOG
-        red = self.Config.COLORS.red
-        nogc = self.Config.COLORS.nogc
-        cmd = list(data).copy()
-
-        if len(cmd) < 2:
-            return None
-
-        match cmd[1]:
-            # [':irc.deb.biz.st', '403', 'Dev-PyDefender', '#Z', ':No', 'such', 'channel']
-            case '403' | '401':
-                try:
-                    message = ' '.join(cmd[2:])
-                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[{red}ERROR MSG{nogc}] {message}")
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-        return None
-
-    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
-
-        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 'topic':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
-                        return None
-
-                    chan = str(cmd[1])
-                    if not self.Base.Is_Channel(chan):
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The channel must start with #")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
-                        return None
-
-                    topic_msg = ' '.join(cmd[2:]).strip()
-
-                    if topic_msg:
-                        self.Irc.send2socket(f':{dnickname} TOPIC {chan} :{topic_msg}')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the topic")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'wallops':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} WALLOPS THE_WALLOPS_MESSAGE")
-                        return None
-
-                    wallops_msg = ' '.join(cmd[1:]).strip()
-
-                    if wallops_msg:
-                        self.Irc.send2socket(f':{dnickname} WALLOPS {wallops_msg} ({dnickname})')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the wallops message")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'globops':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} GLOBOPS THE_GLOBOPS_MESSAGE")
-                        return None
-
-                    globops_msg = ' '.join(cmd[1:]).strip()
-
-                    if globops_msg:
-                        self.Irc.send2socket(f':{dnickname} GLOBOPS {globops_msg} ({dnickname})')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the globops message")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'gnotice':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} THE_GLOBAL_NOTICE_MESSAGE")
-                        return None
-
-                    gnotice_msg = ' '.join(cmd[1:]).strip()
-
-                    if gnotice_msg:
-                        self.Irc.send2socket(f':{dnickname} NOTICE $*.* :[{self.Config.COLORS.red}GLOBAL NOTICE{self.Config.COLORS.nogc}] {gnotice_msg}')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the global notice message")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'whois':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
-                        return None
-
-                    nickname = str(cmd[1])
-
-                    if self.User.get_nickname(nickname) is None:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :Nickname not found !")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} WHOIS {nickname}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'names':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #CHANNEL")
-                        return None
-
-                    chan = str(cmd[1])
-
-                    if not self.Base.Is_Channel(chan):
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The channel must start with #")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #channel")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} NAMES {chan}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'invite':
-                try:
-                    if len(cmd) < 3:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #CHANNEL NICKNAME")
-                        return None
-
-                    chan = str(cmd[1])
-                    nickname = str(cmd[2])
-
-                    if not self.Base.Is_Channel(chan):
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The channel must start with #")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #channel nickname")
-                        return None
-
-                    if self.User.get_nickname(nickname) is None:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :Nickname not found !")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #channel NICKNAME")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} INVITE {nickname} {chan}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'inviteme':
-                try:
-                    if len(cmd) == 0:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()}")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} INVITE {fromuser} {self.Config.SERVICE_CHANLOG}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case '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_jsonrpc.py

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

mods/mod_test.py

@@ -1,64 +1,53 @@
-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:
 
-        # Module name (Mandatory)
+        # Add Irc Object to the module
-        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)
+        # Add Global Configuration to the module
         self.Config = ircInstance.Config
 
-        # Add Base object to the module (Mandatory)
+        # Add Base object to the module
         self.Base = ircInstance.Base
 
-        # Add logs object to the module (Mandatory)
+        # Add logs object to the module
         self.Logs = ircInstance.Base.logs
 
-        # Add User object to the module (Mandatory)
+        # Add User object to the module
         self.User = ircInstance.User
 
-        # Add Channel object to the module (Mandatory)
+        # Add Channel object to the module
         self.Channel = ircInstance.Channel
 
-        # Create module commands (Mandatory)
+        # Créer les nouvelles commandes du module
         self.commands_level = {
-            0: ['test-command'],
+            0: ['test'],
-            1: ['test_level_1'],
+            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 ...')
+        self.Logs.debug(f'Module {self.__class__.__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:
@@ -95,61 +84,25 @@ class Test():
         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(param_exemple1='param value 1', param_exemple2=1)
-
-            # 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:
+    def _hcmds(self, user:str, 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-command':
+            case 'test':
                 try:
                     
-                    self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} : This is a notice to the sender ...")
+                    self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} : test command ready ...")
-                    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 KeyError as ke:
-                except Exception as err:
+                    self.Logs.error(f"Key Error : {ke}")
-                    self.Logs.error(f"Unknown Error: {err}")

mods/mod_votekick.py

@@ -24,10 +24,6 @@ class Votekick():
     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
 
@@ -48,20 +44,18 @@ class Votekick():
 
         # Créer les nouvelles commandes du module
         self.commands_level = {
-            0: ['vote']
+            0: ['vote_for', 'vote_against'],
+            1: ['activate', 'deactivate', 'submit', 'vote_stat', 'vote_verdict', 'vote_cancel']
         }
 
         # Init the module
         self.__init_module()
 
         # Log the module
-        self.Logs.debug(f'Module {self.module_name} loaded ...')
+        self.Logs.debug(f'Module {self.__class__.__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()
@@ -149,7 +143,7 @@ class Votekick():
         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)
+            self.db_add_vote_channel(ChannelObject.channel_name)
 
         return result
 
@@ -194,9 +188,7 @@ class Votekick():
 
     def join_saved_channels(self) -> None:
 
-        param = {'module_name': self.module_name}
+        result = self.Base.db_execute_query("SELECT id, channel FROM votekick_channel")
-        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()
 
@@ -222,18 +214,15 @@ class Votekick():
 
         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.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll be kicked from the channel')
+                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :The user {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]}  will be kicked from this channel')
                     self.Irc.send2socket(f":{dnickname} KICK {channel} {target_user} Following the vote, you are not welcome in {channel}")
                     self.Channel.delete_user_from_channel(channel, self.User.get_uid(target_user))
                 elif chan.vote_for <= chan.vote_against:
-                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel')
+                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This user will stay on this channel')
 
                 # Init the system
                 if self.init_vote_system(channel):
@@ -252,128 +241,35 @@ class Votekick():
 
         return None
 
-    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
+    def _hcmds(self, user:str, 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
+
+        if len(fullcmd) >= 3:
+            fromchannel = str(fullcmd[2]).lower() if self.Base.Is_Channel(str(fullcmd[2]).lower()) else None
+        else:
+            fromchannel = None
+
+        if len(cmd) >= 2:
+            sentchannel = str(cmd[1]).lower() if self.Base.Is_Channel(str(cmd[1]).lower()) else None
+        else:
+            sentchannel = None
+
+        if not fromchannel is None:
+            channel = fromchannel
+        elif not sentchannel is None:
+            channel = sentchannel
+        else:
+            channel = None
 
         match command:
-            case 'vote':
-                option = str(cmd[1]).lower()
 
-                if len(command) == 1:
+            case 'vote_cancel':
-                    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')
@@ -383,31 +279,79 @@ class Votekick():
                             self.init_vote_system(channel)
                             self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote system re-initiated')
 
-                        except Exception as err:
+                except IndexError as ke:
-                            self.Logs.error(f'{err}')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote_cancel #channel')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option}')
+                    self.Logs.error(f'Index Error: {ke}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option}')
 
-                    case 'status':
+            case 'vote_for':
                 try:
-                            # vote status
+                    # vote_for
+                    channel = str(fullcmd[2]).lower()
+                    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 KeyError as ke:
+                    self.Logs.error(f'Key Error: {ke}')
+                except IndexError as ie:
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote_cancel #channel')
+                    self.Logs.error(f'Index Error: {ie}')
+
+            case 'vote_against':
+                try:
+                    # vote_against
+                    channel = str(fullcmd[2]).lower()
+                    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 KeyError as ke:
+                    self.Logs.error(f'Key Error: {ke}')
+
+            case 'vote_stat':
+                try:
+                    # channel = str(fullcmd[2]).lower()
                     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:
+                except KeyError as ke:
-                            self.Logs.error(f'{err}')
+                    self.Logs.error(f'Key Error: {ke}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option}')
+
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option}')
+            case 'vote_verdict':
+                try:
+                    # channel = str(fullcmd[2]).lower()
+                    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} :The user {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]}  will be kicked from this 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} :This user will stay on this channel')
+                            
+                            # Init the system
+                            if self.init_vote_system(channel):
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :System vote re initiated')
+
+                except KeyError as ke:
+                    self.Logs.error(f'Key Error: {ke}')
 
             case 'submit':
+                # submit nickname
                 try:
-                            # vote submit nickname
+                    nickname_submitted = cmd[1]
-                            if self.Admin.get_Admin(fromuser) is None:
+                    # channel = str(fullcmd[2]).lower()
-                                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)
 
@@ -427,9 +371,6 @@ class Votekick():
 
                     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:
@@ -455,41 +396,46 @@ class Votekick():
                     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:
+                except KeyError as ke:
-                            self.Logs.error(f'{err}')
+                    self.Logs.error(f'Key Error: {ke}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option} nickname')
+                except TypeError as te:
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option} adator')
+                    self.Logs.error(te)
 
-                    case 'verdict':
+            case 'activate':
                 try:
-                            # vote verdict
+                    # activate #channel
-                            if self.Admin.get_Admin(fromuser) is None:
+                    # channel = str(cmd[1]).lower()
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
+
-                                return None
+                    self.insert_vote_channel(
+                        self.VoteChannelModel(
+                            channel_name=channel, 
+                            target_user='',
+                            voter_users=[],
+                            vote_for=0,
+                            vote_against=0
+                            )
+                        )
+
+                    self.Irc.send2socket(f":{dnickname} JOIN {channel}")
+                    self.Irc.send2socket(f":{dnickname} SAMODE {channel} +o {dnickname}")
+                    self.Irc.send2socket(f":{dnickname} PRIVMSG {channel} :You can now use !submit <nickname> to decide if he will stay or not on this channel ")
+
+                except KeyError as ke:
+                    self.Logs.error(f"Key Error : {ke}")
+
+            case 'deactivate':
+                try:
+                    # deactivate #channel
+                    # channel = str(cmd[1]).lower()
+
+                    self.Irc.send2socket(f":{dnickname} SAMODE {channel} -o {dnickname}")
+                    self.Irc.send2socket(f":{dnickname} PART {channel}")
 
                     for chan in self.VOTE_CHANNEL_DB:
                         if chan.channel_name == channel:
-                                    target_user = self.User.get_nickname(chan.target_user)
+                            self.VOTE_CHANNEL_DB.remove(chan)
-                                    if chan.vote_for > chan.vote_against:
+                            self.db_delete_vote_channel(chan.channel_name)
-                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll be kicked from the channel')
-                                        self.Irc.send2socket(f":{dnickname} KICK {channel} {target_user} Following the vote, you are not welcome in {channel}")
-                                    elif chan.vote_for <= chan.vote_against:
-                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel')
 
-                                    # Init the system
+                    self.Logs.debug(f"Test logs ready")
-                                    if self.init_vote_system(channel):
+                except KeyError as ke:
-                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :System vote re initiated')
+                    self.Logs.error(f"Key Error : {ke}")
-                        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

@@ -1,3 +1,3 @@
 {
-    "version": "5.3.2"
+    "version": "5.0.4"
 }