V5.3.2 additional commands

.gitignore

@@ -2,7 +2,6 @@
 db/
 logs/
 __pycache__/
-mods/mod_jsonrpc.py
 configuration.json
 *.log
 test.py

README.md

@@ -32,30 +32,34 @@ Il permet aux opérateurs de gérer efficacement un canal, tout en offrant aux u
         - Système d'exploitation Linux (Windows non supporté)
         - Un server UnrealIRCD corréctement configuré
         - Python version 3.10 ou supérieure
-
-    Bash:
+```bash
+        # Bash
         $ git clone https://github.com/adator85/IRC_DEFENDER_MODULES.git
-        - Renommer le fichier exemple_configuration.json en configuration.json
-        - Configurer le fichier configuration.json
+        # Renommer le fichier exemple_configuration.json en configuration.json
+        # Configurer le fichier configuration.json
         $ python3 main.py
-
+```
 Si votre configuration est bonne, votre service est censé etre connecté a votre réseau IRC
 Pour Les prochains lancement de defender vous devez utiliser la commande suivante:
 
-    Bash:
-        $ systemctl --user [start | stop | restart | status] defender
-
+```bash
+    # Bash
+    $ systemctl --user [start | stop | restart | status] defender
+```
 # Installation manuelle:
-    Bash:
-        $ git clone https://github.com/adator85/IRC_DEFENDER_MODULES.git
-        $ cd IRC_DEFENDER_MODULES
-        $ python3 -m venv .pyenv
-        $ source .pyenv/bin/activate
-        (pyenv)$ pip install sqlalchemy, psutil, requests, faker
-        - Créer un service nommé "defender.service" pour votre service et placer le dans "/PATH/TO/USER/.config/systemd/user/"
-        - Si le dossier n'existe pas il faut les créer
-        $ sudo systemctl --user start defender
+```bash
+    # Bash
+    $ git clone https://github.com/adator85/IRC_DEFENDER_MODULES.git
+    $ cd IRC_DEFENDER_MODULES
+    $ python3 -m venv .pyenv
+    $ source .pyenv/bin/activate
+    (pyenv)$ pip install sqlalchemy, psutil, requests, faker, unrealircd_rpc_py
 
+    # Créer un service nommé "defender.service" 
+    # pour votre service et placer le dans "/PATH/TO/USER/.config/systemd/user/"
+    # Si le dossier n'existe pas il faut les créer
+    $ sudo systemctl --user start defender
+```
 # Configuration
 ```
     SERVEUR (Serveur)
@@ -157,6 +161,12 @@ Pour Les prochains lancement de defender vous devez utiliser la commande suivant
     "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",

core/base.py

@@ -1,8 +1,21 @@
-import time, threading, os, random, socket, hashlib, ipaddress, logging, requests, json, re, ast
+import os
+import re
+import json
+import time
+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
+from datetime import datetime, timedelta, timezone
 from sqlalchemy import create_engine, Engine, Connection, CursorResult
 from sqlalchemy.sql import text
 from core.loadConf import ConfigDataModel
@@ -106,7 +119,11 @@ 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:

core/connection.py

@@ -2,10 +2,10 @@ 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
-from typing import Union
 
 class Connection:
 

core/exemple_configuration.json

@@ -22,6 +22,12 @@
     "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",

core/installation.py

@@ -1,8 +1,8 @@
+import os
+from sys import exit
 from dataclasses import dataclass
 from subprocess import check_call, run, CalledProcessError, PIPE
 from platform import python_version, python_version_tuple
-from sys import exit
-import os
 
 class Install:
 
@@ -64,7 +64,7 @@ class Install:
                 defender_install_folder=defender_install_folder,
                 venv_folder=venv_folder,
                 venv_cmd_installation=['python3', '-m', 'venv', venv_folder],
-                venv_cmd_requirements=['sqlalchemy','psutil','requests','faker'],
+                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'
             )

core/irc.py

@@ -1,10 +1,17 @@
-import ssl, re, importlib, sys, time, threading, socket, traceback
+import sys
+import socket
+import threading
+import ssl
+import re
+import importlib
+import time
+import traceback
 from ssl import SSLSocket
 from datetime import datetime, timedelta
-from typing import Union, Literal
+from typing import Union
 from core.loadConf import Config
-from core.Model import User, Admin, Channel, Clones
 from core.base import Base
+from core.Model import User, Admin, Channel, Clones
 
 class Irc:
 
@@ -492,6 +499,39 @@ class Irc:
             self.Base.logs.error(f"Something went wrong with a module you want to load : {e}")
             self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.COLORS.red}ERROR{self.Config.COLORS.black} ]: {e}")
 
+    def unload_module(self, mod_name: str) -> bool:
+        """Unload a module
+
+        Args:
+            mod_name (str): Module name ex mod_defender
+
+        Returns:
+            bool: True if success
+        """
+        try:
+            module_name = mod_name.lower()                              # Le nom du module. exemple: mod_defender
+            class_name = module_name.split('_')[1].capitalize()            # Nom de la class. exemple: Defender
+
+            if class_name in self.loaded_classes:
+                self.loaded_classes[class_name].unload()
+                for level, command in self.loaded_classes[class_name].commands_level.items():
+                    # Supprimer la commande de la variable commands
+                    for c in self.loaded_classes[class_name].commands_level[level]:
+                        self.commands.remove(c)
+                        self.commands_level[level].remove(c)
+
+                del self.loaded_classes[class_name]
+
+                # Supprimer le module de la base de données
+                self.Base.db_delete_module(module_name)
+
+                self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} supprimé")
+                return True
+
+        except Exception as err:
+            self.Base.logs.error(f"General Error: {err}")
+            return False
+
     def insert_db_admin(self, uid:str, level:int) -> None:
 
         if self.User.get_User(uid) is None:
@@ -786,7 +826,7 @@ class Irc:
                                 self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} : New Version available {version}")
 
                         # Initialisation terminé aprés le premier PING
-                        self.sendPrivMsg(msg=f'[{self.Config.COLORS.green}INFORMATION{self.Config.COLORS.nogc}] >> Defender is ready', channel='#devservices')
+                        self.sendPrivMsg(msg=f'[{self.Config.COLORS.green}INFORMATION{self.Config.COLORS.nogc}] >> Defender is ready', channel=self.Config.SERVICE_CHANLOG)
                         self.INIT = 0
 
                 case _:
@@ -997,7 +1037,9 @@ class Irc:
                                     recieved_unixtime = int(arg[1].replace('\x01',''))
                                     current_unixtime = self.Base.get_unixtime()
                                     ping_response = current_unixtime - recieved_unixtime
-                                    self.send2socket(f':{dnickname} NOTICE {user_trigger} :\x01PING {str(ping_response)} secs\x01')
+
+                                    self.send2socket(f'PONG :{recieved_unixtime}')
+                                    self.send2socket(f':{dnickname} NOTICE {user_trigger} :\x01PING {recieved_unixtime} secs\x01')
                                     return False
 
                                 if not arg[0].lower() in self.commands:
@@ -1285,7 +1327,6 @@ class Irc:
 
             case 'help':
 
-                help = ''
                 count_level_definition = 0
                 get_admin = self.Admin.get_Admin(uid)
                 if not get_admin is None:
@@ -1300,18 +1341,15 @@ class Irc:
                     if int(user_level) >= int(count_level_definition):
 
                         self.send2socket(f':{dnickname} NOTICE {fromuser} : ***************** {self.Config.COLORS.nogc}[ {self.Config.COLORS.green}LEVEL {str(levDef)} {self.Config.COLORS.nogc}] *****************')
-                        count_commands = 0
-                        help = ''
-                        for comm in self.commands_level[count_level_definition]:
 
-                            help += f"{comm.upper()}"
-                            if int(count_commands) < len(self.commands_level[count_level_definition])-1:
-                                help += ' | '
-                            count_commands += 1
-
-                        self.send2socket(f':{dnickname} NOTICE {fromuser} : {help}')
+                        batch = 7
+                        for i in range(0, len(self.commands_level[count_level_definition]), batch):
+                            groupe = self.commands_level[count_level_definition][i:i + batch]  # Extraire le groupe
+                            batch_commands = ' | '.join(groupe)
+                            self.send2socket(f':{dnickname} NOTICE {fromuser} : {batch_commands}')
 
                     count_level_definition += 1
+                    self.send2socket(f':{dnickname} NOTICE {fromuser} : ')
 
                 self.send2socket(f':{dnickname} NOTICE {fromuser} : ***************** FIN DES COMMANDES *****************')
 
@@ -1320,27 +1358,12 @@ class Irc:
                 self.load_module(fromuser, str(cmd[1]))
 
             case 'unload':
-                # unload mod_dktmb
+                # unload mod_defender
                 try:
                     module_name = str(cmd[1]).lower()                              # Le nom du module. exemple: mod_defender
-                    class_name = module_name.split('_')[1].capitalize()            # Nom de la class. exemple: Defender
-
-                    if class_name in self.loaded_classes:
-                        self.loaded_classes[class_name].unload()
-                        for level, command in self.loaded_classes[class_name].commands_level.items():
-                            # Supprimer la commande de la variable commands
-                            for c in self.loaded_classes[class_name].commands_level[level]:
-                                self.commands.remove(c)
-                                self.commands_level[level].remove(c)
-
-                        del self.loaded_classes[class_name]
-
-                        # Supprimer le module de la base de données
-                        self.Base.db_delete_module(module_name)
-
-                        self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} supprimé")
-                except:
-                    self.Base.logs.error(f"Something went wrong with a module you want to load")
+                    self.unload_module(module_name)
+                except Exception as err:
+                    self.Base.logs.error(f"General Error: {err}")
 
             case 'reload':
                 # reload mod_dktmb

core/loadConf.py

@@ -1,4 +1,5 @@
-import json, sys
+import sys
+import json
 from os import sep
 from typing import Union, Literal
 from dataclasses import dataclass, field
@@ -16,7 +17,7 @@ class ColorModel:
     red: str    = "\x0304"
     yellow: str = "\x0306"
     bold: str   = "\x02"
-    nogc: str = "\x03"
+    nogc: str   = "\x03"
 
 @dataclass
 class ConfigDataModel:
@@ -84,6 +85,21 @@ class ConfigDataModel:
     PASSWORD: str
     """The password of the admin of the service"""
 
+    JSONRPC_URL: str
+    """The RPC url, if local https://127.0.0.1:PORT/api should be fine"""
+
+    JSONRPC_PATH_TO_SOCKET_FILE: str
+    """The full path of the socket file (/PATH/TO/YOUR/UNREALIRCD/SOCKET/FILE.socket)"""
+
+    JSONRPC_METHOD: str
+    """3 methods are available; requests/socket/unixsocket"""
+
+    JSONRPC_USER: str
+    """The RPC User defined in your unrealircd.conf"""
+
+    JSONRPC_PASSWORD: str
+    """The RPC Password defined in your unrealircd.conf"""
+
     SALON_JAIL: str
     """The JAIL channel (ex. #jail)"""
 
@@ -150,7 +166,7 @@ class ConfigDataModel:
     db_path: str
     """The database path"""
 
-    COLORS: ColorModel = ColorModel()
+    COLORS: ColorModel = field(default_factory=ColorModel)
     """Available colors in Defender"""
 
     BATCH_SIZE: int = 400
@@ -208,13 +224,22 @@ class Config:
             SERVICE_PREFIX=import_config["SERVICE_PREFIX"] if "SERVICE_PREFIX" in import_config else '!',
             OWNER=import_config["OWNER"] if "OWNER" in import_config else 'admin',
             PASSWORD=import_config["PASSWORD"] if "PASSWORD" in import_config else 'admin',
+
+            JSONRPC_METHOD=import_config["JSONRPC_METHOD"] if "JSONRPC_METHOD" in import_config else 'socket',
+            JSONRPC_URL=import_config["JSONRPC_URL"] if "JSONRPC_URL" in import_config else None,
+            JSONRPC_PATH_TO_SOCKET_FILE=import_config["JSONRPC_PATH_TO_SOCKET_FILE"] if "JSONRPC_PATH_TO_SOCKET_FILE" in import_config else None,
+            JSONRPC_USER=import_config["JSONRPC_USER"] if "JSONRPC_USER" in import_config else None,
+            JSONRPC_PASSWORD=import_config["JSONRPC_PASSWORD"] if "JSONRPC_PASSWORD" in import_config else None,
+
             SALON_JAIL=import_config["SALON_JAIL"] if "SALON_JAIL" in import_config else '#jail',
             SALON_JAIL_MODES=import_config["SALON_JAIL_MODES"] if "SALON_JAIL_MODES" in import_config else 'sS',
             SALON_LIBERER=import_config["SALON_LIBERER"] if "SALON_LIBERER" in import_config else '#welcome',
+
             CLONE_CHANNEL=import_config["CLONE_CHANNEL"] if "CLONE_CHANNEL" in import_config else '#clones',
             CLONE_CMODES=import_config["CLONE_CMODES"] if "CLONE_CMODES" in import_config else '+nts',
             CLONE_LOG_HOST_EXEMPT=import_config["CLONE_LOG_HOST_EXEMPT"] if "CLONE_LOG_HOST_EXEMPT" in import_config else [],
             CLONE_CHANNEL_PASSWORD=import_config["CLONE_CHANNEL_PASSWORD"] if "CLONE_CHANNEL_PASSWORD" in import_config else "clone_Password_1234",
+
             API_TIMEOUT=import_config["API_TIMEOUT"] if "API_TIMEOUT" in import_config else 2,
             PORTS_TO_SCAN=import_config["PORTS_TO_SCAN"] if "PORTS_TO_SCAN" in import_config else [],
             WHITELISTED_IP=import_config["WHITELISTED_IP"] if "WHITELISTED_IP" in import_config else ['127.0.0.1'],

mods/mod_clone.py

@@ -147,7 +147,7 @@ class Clone():
 
             del clone_to_kill
 
-            # If LIST empty then stop this thread
+            # If no more clones then stop this thread
             if not self.Clone.UID_CLONE_DB:
                 break
 

mods/mod_command.py

@@ -37,7 +37,8 @@ class Command():
             1: ['join', 'part'],
             2: ['owner', 'deowner', 'op', 'deop', 'halfop', 'dehalfop', 'voice', 
                 'devoice', 'opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 
-                'unban','kick', 'kickban', 'umode', 'svsjoin', 'svspart', 'svsnick']
+                'unban','kick', 'kickban', 'umode', 'svsjoin', 'svspart', 'svsnick', 'topic',
+                'wallops', 'globops','gnotice','whois', 'names', 'invite', 'inviteme']
         }
 
         # Init the module
@@ -91,7 +92,7 @@ class Command():
             )
         '''
 
-        self.Base.db_execute_query(table_logs)
+        # self.Base.db_execute_query(table_logs)
         return None
 
     def __load_module_configuration(self) -> None:
@@ -161,6 +162,27 @@ class Command():
 
     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:
@@ -577,6 +599,163 @@ class Command():
                 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

mods/mod_defender.py

@@ -1,7 +1,12 @@
+import socket
+import json
+import time
+import re
+import psutil
+import requests
 from dataclasses import dataclass, fields, field
 from datetime import datetime
 from typing import Union
-import re, socket, psutil, requests, json, time
 from sys import exit
 from core.irc import Irc
 from core.Model import User
@@ -1313,9 +1318,7 @@ class Defender():
                             for chan in self.Channel.UID_CHANNEL_DB:
                                 if chan.name != jail_chan:
                                     self.Irc.send2socket(f":{service_id} MODE {chan.name} -b ~security-group:unknown-users")
-                                    self.Irc.send2socket(f":{service_id} MODE {chan.name} -e ~security-group:webirc-users")
-                                    self.Irc.send2socket(f":{service_id} MODE {chan.name} -e ~security-group:known-users")
-                                    self.Irc.send2socket(f":{service_id} MODE {chan.name} -e ~security-group:websocket-users")
+                                    self.Irc.send2socket(f":{service_id} MODE {chan.name} -eee ~security-group:webirc-users ~security-group:known-users ~security-group:websocket-users")
 
                             self.Base.db_query_channel('del', self.module_name, jail_chan)
 

mods/mod_jsonrpc.py

@@ -0,0 +1,259 @@
+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}")

version.json

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