Merge pull request #67 from adator85/V6.X.X

V6.0.2

core/classes/channel.py

@@ -2,8 +2,6 @@ from re import findall
 from typing import Union, Literal, TYPE_CHECKING
 from dataclasses import asdict
 
-from core.classes import user
-
 if TYPE_CHECKING:
     from core.definition import MChannel
     from core.base import Base
@@ -33,10 +31,6 @@ class Channel:
         result = False
         exist = False
 
-        if not self.Is_Channel(newChan.name):
-            self.Logs.error(f"The channel {newChan.name} is not valid, channel must start with #")
-            return False
-
         for record in self.UID_CHANNEL_DB:
             if record.name.lower() == newChan.name.lower():
                 # If the channel exist, update the user list and do not go further
@@ -135,29 +129,6 @@ class Channel:
         except Exception as err:
             self.Logs.error(f'{err}')
 
-    def is_user_present_in_channel(self, channel_name: str, uid: str) -> bool:
-        """Check if a user is present in the channel
-
-        Args:
-            channel_name (str): The channel to check
-            uid (str): The UID
-
-        Returns:
-            bool: True if the user is present in the channel
-        """
-        user_found = False
-        chan = self.get_Channel(channel_name=channel_name)
-        if chan is None:
-            return user_found
-
-        clean_uid = self.Base.clean_uid(uid=uid)
-        for chan_uid in chan.uids:
-            if self.Base.clean_uid(chan_uid) == clean_uid:
-                user_found = True
-                break
-
-        return user_found
-
     def clean_channel(self) -> None:
         """Remove Channels if empty
         """

core/classes/protocols/unreal6.py

@@ -1,7 +1,10 @@
-from re import match, findall, search
+from re import match, findall
 from datetime import datetime
 from typing import TYPE_CHECKING, Union
 from ssl import SSLEOFError, SSLError
+from dataclasses import dataclass
+
+from websockets import serve
 
 if TYPE_CHECKING:
     from core.irc import Irc
@@ -473,17 +476,6 @@ class Unrealircd6:
         except Exception as err:
             self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
-    def on_mode(self, serverMsg: list[str]) -> None:
-        """Handle mode coming from a server
-
-        Args:
-            serverMsg (list[str]): Original server message
-        """
-        #['@msgid=d0ySx56Yd0nc35oHts2SkC-/J9mVUA1hfM6...', ':001', 'MODE', '#a', '+nt', '1723207536']
-        #['@unrealircd.org/userhost=adator@localhost;...', ':001LQ0L0C', 'MODE', '#services', '-l']
-
-        return None
-
     def on_umode2(self, serverMsg: list[str]) -> None:
         """Handle umode2 coming from a server
 
@@ -630,11 +622,8 @@ class Unrealircd6:
             # ':001T6VU3F', '001JGWB2K', '@11ZAAAAAB', 
             # '001F16WGR', '001X9YMGQ', '*+001DYPFGP', '@00BAAAAAJ', '001AAGOG9', '001FMFVG8', '001DAEEG7', 
             # '&~G:unknown-users', '"~G:websocket-users', '"~G:known-users', '"~G:webirc-users']
-            # [':00B', 'SJOIN', '1731872579', '#services', '+', ':00BAAAAAB']
             serverMsg_copy = serverMsg.copy()
-            if serverMsg_copy[0].startswith('@'):
             serverMsg_copy.pop(0)
-
             channel = str(serverMsg_copy[3]).lower()
             len_cmd = len(serverMsg_copy)
             list_users:list = []
@@ -691,105 +680,6 @@ class Unrealircd6:
         except Exception as err:
             self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
-    def on_eos(self, serverMsg: list[str]) -> None:
-        """Handle EOS coming from a server
-
-        Args:
-            serverMsg (list[str]): Original server message
-        """
-        try:
-            # [':001', 'EOS']
-            server_msg_copy = serverMsg.copy()
-            hsid = str(server_msg_copy[0]).replace(':','')
-            if hsid == self.__Config.HSID:
-                if self.__Config.DEFENDER_INIT == 1:
-                    current_version = self.__Config.CURRENT_VERSION
-                    latest_version = self.__Config.LATEST_VERSION
-                    if self.__Base.check_for_new_version(False):
-                        version = f'{current_version} >>> {latest_version}'
-                    else:
-                        version = f'{current_version}'
-
-                    print(f"################### DEFENDER ###################")
-                    print(f"#               SERVICE CONNECTE                ")
-                    print(f"# SERVEUR  :    {self.__Config.SERVEUR_IP}        ")
-                    print(f"# PORT     :    {self.__Config.SERVEUR_PORT}      ")
-                    print(f"# SSL      :    {self.__Config.SERVEUR_SSL}       ")
-                    print(f"# SSL VER  :    {self.__Config.SSL_VERSION}       ")
-                    print(f"# NICKNAME :    {self.__Config.SERVICE_NICKNAME}  ")
-                    print(f"# CHANNEL  :    {self.__Config.SERVICE_CHANLOG}   ")
-                    print(f"# VERSION  :    {version}                       ")
-                    print(f"################################################")
-
-                    self.__Base.logs.info(f"################### DEFENDER ###################")
-                    self.__Base.logs.info(f"#               SERVICE CONNECTE                ")
-                    self.__Base.logs.info(f"# SERVEUR  :    {self.__Config.SERVEUR_IP}        ")
-                    self.__Base.logs.info(f"# PORT     :    {self.__Config.SERVEUR_PORT}      ")
-                    self.__Base.logs.info(f"# SSL      :    {self.__Config.SERVEUR_SSL}       ")
-                    self.__Base.logs.info(f"# SSL VER  :    {self.__Config.SSL_VERSION}       ")
-                    self.__Base.logs.info(f"# NICKNAME :    {self.__Config.SERVICE_NICKNAME}  ")
-                    self.__Base.logs.info(f"# CHANNEL  :    {self.__Config.SERVICE_CHANLOG}   ")
-                    self.__Base.logs.info(f"# VERSION  :    {version}                       ")
-                    self.__Base.logs.info(f"################################################")
-
-                    if self.__Base.check_for_new_version(False):
-                        self.send_priv_msg(
-                            nick_from=self.__Config.SERVICE_NICKNAME,
-                            msg=f" New Version available {version}",
-                            channel=self.__Config.SERVICE_CHANLOG
-                        )
-
-                # Initialisation terminé aprés le premier PING
-                self.send_priv_msg(
-                    nick_from=self.__Config.SERVICE_NICKNAME,
-                    msg=f"[{self.__Config.COLORS.green}INFORMATION{self.__Config.COLORS.nogc}] >> Defender is ready",
-                    channel=self.__Config.SERVICE_CHANLOG
-                )
-                self.__Config.DEFENDER_INIT = 0
-
-                # Send EOF to other modules
-                for classe_name, classe_object in self.__Irc.loaded_classes.items():
-                    classe_object.cmd(server_msg_copy)
-
-                return None
-        except IndexError as ie:
-            self.__Base.logs.error(f"{__name__} - Key Error: {ie}")
-        except KeyError as ke:
-            self.__Base.logs.error(f"{__name__} - Key Error: {ke}")
-        except Exception as err:
-            self.__Base.logs.error(f"{__name__} - General Error: {err}")
-
-    def on_reputation(self, serverMsg: list[str]) -> None:
-        """Handle REPUTATION coming from a server
-
-        Args:
-            serverMsg (list[str]): Original server message
-        """
-        try:
-            # :001 REPUTATION 127.0.0.1 118
-            server_msg_copy = serverMsg.copy()
-            self.__Irc.first_connexion_ip = server_msg_copy[2]
-            self.__Irc.first_score = 0
-
-            if str(server_msg_copy[3]).find('*') != -1:
-                # If * available, it means that an ircop changed the repurtation score
-                # means also that the user exist will try to update all users with same IP
-                self.__Irc.first_score = int(str(server_msg_copy[3]).replace('*',''))
-                for user in self.__Irc.User.UID_DB:
-                    if user.remote_ip == self.__Irc.first_connexion_ip:
-                        user.score_connexion = self.first_score
-            else:
-                self.__Irc.first_score = int(server_msg_copy[3])
-
-            # Possibilité de déclancher les bans a ce niveau.
-        except IndexError as ie:
-            self.Logs.error(f'Index Error {__name__}: {ie}')
-        except ValueError as ve:
-            self.__Irc.first_score = 0
-            self.Logs.error(f'Value Error {__name__}: {ve}')
-        except Exception as err:
-            self.__Base.logs.error(f"{__name__} - General Error: {err}")
-
     def on_uid(self, serverMsg: list[str]) -> None:
         """Handle uid message coming from the server
 
@@ -853,101 +743,6 @@ class Unrealircd6:
         except Exception as err:
             self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
-    def on_privmsg(self, serverMsg: list[str]) -> None:
-        """Handle PRIVMSG message coming from the server
-
-        Args:
-            serverMsg (list[str]): Original server message
-        """
-        try:
-            srv_msg = serverMsg.copy()
-
-            cmd = serverMsg.copy()
-            # Supprimer la premiere valeur si MTAGS activé
-            if cmd[0].startswith('@'):
-                cmd.pop(0)
-
-            # Hide auth logs
-            if len(cmd) == 7:
-                if cmd[2] == 'PRIVMSG' and cmd[4] == ':auth':
-                    data_copy = cmd.copy()
-                    data_copy[6] = '**********'
-                    self.__Base.logs.debug(f">> {data_copy}")
-                else:
-                    self.__Base.logs.debug(f">> {cmd}")
-            else:
-                self.__Base.logs.debug(f">> {cmd}")
-
-            get_uid_or_nickname = str(cmd[0].replace(':',''))
-            user_trigger = self.__Irc.User.get_nickname(get_uid_or_nickname)
-            dnickname = self.__Config.SERVICE_NICKNAME
-
-            pattern = fr'(:\{self.__Config.SERVICE_PREFIX})(.*)$'
-            hcmds = search(pattern, ' '.join(cmd)) # va matcher avec tout les caractéres aprés le .
-
-            if hcmds: # Commande qui commencent par le point
-                liste_des_commandes = list(hcmds.groups())
-                convert_to_string = ' '.join(liste_des_commandes)
-                arg = convert_to_string.split()
-                arg.remove(f':{self.__Config.SERVICE_PREFIX}')
-                if not arg[0].lower() in self.__Irc.commands:
-                    self.__Base.logs.debug(f"This command {arg[0]} is not available")
-                    self.send_notice(
-                        nick_from=self.__Config.SERVICE_NICKNAME,
-                        nick_to=user_trigger,
-                        msg=f"This command [{self.__Config.COLORS.bold}{arg[0]}{self.__Config.COLORS.bold}] is not available"
-                    )
-                    return None
-
-                cmd_to_send = convert_to_string.replace(':','')
-                self.__Base.log_cmd(user_trigger, cmd_to_send)
-
-                fromchannel = str(cmd[2]).lower() if self.__Irc.Channel.Is_Channel(cmd[2]) else None
-                self.__Irc.hcmds(user_trigger, fromchannel, arg, cmd)
-
-            if cmd[2] == self.__Config.SERVICE_ID:
-                pattern = fr'^:.*?:(.*)$'
-                hcmds = search(pattern, ' '.join(cmd))
-
-                if hcmds: # par /msg defender [commande]
-                    liste_des_commandes = list(hcmds.groups())
-                    convert_to_string = ' '.join(liste_des_commandes)
-                    arg = convert_to_string.split()
-
-                    # Réponse a un CTCP VERSION
-                    if arg[0] == '\x01VERSION\x01':
-                        self.on_version(srv_msg)
-                        return False
-
-                    # Réponse a un TIME
-                    if arg[0] == '\x01TIME\x01':
-                        self.on_time(srv_msg)
-                        return False
-
-                    # Réponse a un PING
-                    if arg[0] == '\x01PING':
-                        self.on_ping(srv_msg)
-                        return False
-
-                    if not arg[0].lower() in self.__Irc.commands:
-                        self.__Base.logs.debug(f"This command {arg[0]} sent by {user_trigger} is not available")
-                        return False
-
-                    cmd_to_send = convert_to_string.replace(':','')
-                    self.__Base.log_cmd(user_trigger, cmd_to_send)
-
-                    fromchannel = None
-                    if len(arg) >= 2:
-                        fromchannel = str(arg[1]).lower() if self.__Irc.Channel.Is_Channel(arg[1]) else None
-
-                    self.__Irc.hcmds(user_trigger, fromchannel, arg, cmd)
-            return None
-
-        except KeyError as ke:
-            self.__Base.logs.error(f"Key Error: {ke}")
-        except Exception as err:
-            self.__Base.logs.error(f"General Error: {err}")
-
     def on_server_ping(self, serverMsg: list[str]) -> None:
         """Send a PONG message to the server
 

core/irc.py

@@ -11,8 +11,6 @@ import traceback
 from ssl import SSLSocket
 from datetime import datetime, timedelta
 from typing import Union
-
-from websockets import serve
 from core.loader import Loader
 from core.classes.protocol import Protocol
 
@@ -746,6 +744,255 @@ class Irc:
                 self.Logs.warning(f'Size ({str(len(original_response))}) - {original_response}')
                 return False
 
+            parsed_protocol = self.Protocol.parse_server_msg(original_response.copy())
+
+            match parsed_protocol:
+
+                case 'PING':
+                    self.Protocol.on_server_ping(serverMsg=original_response)
+                    # print(f"** handle {parsed_protocol}")
+                    return None
+
+                case 'SJOIN':
+                    self.Protocol.on_sjoin(serverMsg=original_response)
+                    # print(f"** handle {parsed_protocol}")
+
+                case 'EOS': # TODO
+                    hsid = str(original_response[0]).replace(':','')
+                    if hsid == self.Config.HSID:
+                        if self.Config.DEFENDER_INIT == 1:
+                            current_version = self.Config.CURRENT_VERSION
+                            latest_version = self.Config.LATEST_VERSION
+                            if self.Base.check_for_new_version(False):
+                                version = f'{current_version} >>> {latest_version}'
+                            else:
+                                version = f'{current_version}'
+
+                            print(f"################### DEFENDER ###################")
+                            print(f"#               SERVICE CONNECTE                ")
+                            print(f"# SERVEUR  :    {self.Config.SERVEUR_IP}        ")
+                            print(f"# PORT     :    {self.Config.SERVEUR_PORT}      ")
+                            print(f"# SSL      :    {self.Config.SERVEUR_SSL}       ")
+                            print(f"# SSL VER  :    {self.Config.SSL_VERSION}       ")
+                            print(f"# NICKNAME :    {self.Config.SERVICE_NICKNAME}  ")
+                            print(f"# CHANNEL  :    {self.Config.SERVICE_CHANLOG}   ")
+                            print(f"# VERSION  :    {version}                       ")
+                            print(f"################################################")
+
+                            self.Logs.info(f"################### DEFENDER ###################")
+                            self.Logs.info(f"#               SERVICE CONNECTE                ")
+                            self.Logs.info(f"# SERVEUR  :    {self.Config.SERVEUR_IP}        ")
+                            self.Logs.info(f"# PORT     :    {self.Config.SERVEUR_PORT}      ")
+                            self.Logs.info(f"# SSL      :    {self.Config.SERVEUR_SSL}       ")
+                            self.Logs.info(f"# SSL VER  :    {self.Config.SSL_VERSION}       ")
+                            self.Logs.info(f"# NICKNAME :    {self.Config.SERVICE_NICKNAME}  ")
+                            self.Logs.info(f"# CHANNEL  :    {self.Config.SERVICE_CHANLOG}   ")
+                            self.Logs.info(f"# VERSION  :    {version}                       ")
+                            self.Logs.info(f"################################################")
+
+                            if self.Base.check_for_new_version(False):
+                                self.Protocol.send_priv_msg(
+                                    nick_from=self.Config.SERVICE_NICKNAME,
+                                    msg=f" New Version available {version}",
+                                    channel=self.Config.SERVICE_CHANLOG
+                                )
+
+                        # Initialisation terminé aprés le premier PING
+                        self.Protocol.send_priv_msg(
+                            nick_from=self.Config.SERVICE_NICKNAME,
+                            msg=f"[{self.Config.COLORS.green}INFORMATION{self.Config.COLORS.nogc}] >> Defender is ready",
+                            channel=self.Config.SERVICE_CHANLOG
+                        )
+                        self.Config.DEFENDER_INIT = 0
+
+                        # Send EOF to other modules
+                        for classe_name, classe_object in self.loaded_classes.items():
+                            classe_object.cmd(original_response)
+
+                        # Stop here When EOS
+                        # print(f"** handle {parsed_protocol}")
+                        return None
+
+                case 'UID':
+                    try:
+                        self.Protocol.on_uid(serverMsg=original_response)
+
+                        for classe_name, classe_object in self.loaded_classes.items():
+                            classe_object.cmd(original_response)
+
+                        # print(f"** handle {parsed_protocol}")
+
+                    except Exception as err:
+                        self.Logs.error(f'General Error: {err}')
+
+                case 'QUIT':
+                    self.Protocol.on_quit(serverMsg=original_response)
+                    # print(f"** handle {parsed_protocol}")
+
+                case 'PROTOCTL':
+                    self.Protocol.on_protoctl(serverMsg=original_response)
+                    # print(f"** handle {parsed_protocol}")
+
+                case 'SVS2MODE':
+                    # >> [':00BAAAAAG', 'SVS2MODE', '001U01R03', '-r']
+                    self.Protocol.on_svs2mode(serverMsg=original_response)
+                    # print(f"** handle {parsed_protocol}")
+
+                case 'SQUIT':
+                    self.Protocol.on_squit(serverMsg=original_response)
+                    # print(f"** handle {parsed_protocol}")
+
+                case 'PART':
+                    self.Protocol.on_part(serverMsg=parsed_protocol)
+                    # print(f"** handle {parsed_protocol}")
+
+                case 'VERSION':
+                    self.Protocol.on_version_msg(serverMsg=original_response)
+                    # print(f"** handle {parsed_protocol}")
+
+                case 'UMODE2':
+                    # [':adator_', 'UMODE2', '-i']
+                    self.Protocol.on_umode2(serverMsg=original_response)
+                    # print(f"** handle {parsed_protocol}")
+
+                case 'NICK':
+                    self.Protocol.on_nick(serverMsg=original_response)
+                    # print(f"** handle {parsed_protocol}")
+
+                case 'REPUTATION': # TODO
+                    # :001 REPUTATION 127.0.0.1 118
+                    try:
+                        self.first_connexion_ip = original_response[2]
+                        self.first_score = 0
+
+                        if str(original_response[3]).find('*') != -1:
+                            # If * available, it means that an ircop changed the repurtation score
+                            # means also that the user exist will try to update all users with same IP
+                            self.first_score = int(str(original_response[3]).replace('*',''))
+                            for user in self.User.UID_DB:
+                                if user.remote_ip == self.first_connexion_ip:
+                                    user.score_connexion = self.first_score
+                        else:
+                            self.first_score = int(original_response[3])
+
+                        # print(f"** handle {parsed_protocol}")
+                        # Possibilité de déclancher les bans a ce niveau.
+                    except IndexError as ie:
+                        self.Logs.error(f'{ie}')
+                    except ValueError as ve:
+                        self.first_score = 0
+                        self.Logs.error(f'Impossible to convert first_score: {ve}')
+
+                case 'SLOG': # TODO
+                    print(f"** handle {parsed_protocol}")
+
+                case 'MD': # TODO
+                    print(f"** handle {parsed_protocol}")
+
+                case 'PRIVMSG': # TODO
+                    try:
+                        # Supprimer la premiere valeur
+                        cmd = interm_response.copy()
+
+                        get_uid_or_nickname = str(cmd[0].replace(':',''))
+                        user_trigger = self.User.get_nickname(get_uid_or_nickname)
+                        dnickname = self.Config.SERVICE_NICKNAME
+
+                        if len(cmd) == 6:
+                            if cmd[1] == 'PRIVMSG' and str(cmd[3]).replace(self.Config.SERVICE_PREFIX,'') == ':auth':
+                                cmd_copy = cmd.copy()
+                                cmd_copy[5] = '**********'
+                                self.Logs.info(f'>> {cmd_copy}')
+                            else:
+                                self.Logs.info(f'>> {cmd}')
+                        else:
+                            self.Logs.info(f'>> {cmd}')
+
+                        pattern = fr'(:\{self.Config.SERVICE_PREFIX})(.*)$'
+                        hcmds = re.search(pattern, ' '.join(cmd)) # va matcher avec tout les caractéres aprés le .
+
+                        if hcmds: # Commande qui commencent par le point
+                            liste_des_commandes = list(hcmds.groups())
+                            convert_to_string = ' '.join(liste_des_commandes)
+                            arg = convert_to_string.split()
+                            arg.remove(f':{self.Config.SERVICE_PREFIX}')
+                            if not arg[0].lower() in self.commands:
+                                self.Logs.debug(f"This command {arg[0]} is not available")
+                                self.Protocol.send_notice(
+                                    nick_from=self.Config.SERVICE_NICKNAME,
+                                    nick_to=user_trigger,
+                                    msg=f"This command [{self.Config.COLORS.bold}{arg[0]}{self.Config.COLORS.bold}] is not available"
+                                )
+                                return None
+
+                            cmd_to_send = convert_to_string.replace(':','')
+                            self.Base.log_cmd(user_trigger, cmd_to_send)
+
+                            fromchannel = str(cmd[2]).lower() if self.Channel.Is_Channel(cmd[2]) else None
+                            self.hcmds(user_trigger, fromchannel, arg, cmd)
+
+                        if cmd[2] == self.Config.SERVICE_ID:
+                            pattern = fr'^:.*?:(.*)$'
+
+                            hcmds = re.search(pattern, ' '.join(cmd))
+
+                            if hcmds: # par /msg defender [commande]
+                                liste_des_commandes = list(hcmds.groups())
+                                convert_to_string = ' '.join(liste_des_commandes)
+                                arg = convert_to_string.split()
+
+                                # Réponse a un CTCP VERSION
+                                if arg[0] == '\x01VERSION\x01':
+                                    self.Protocol.on_version(original_response)
+                                    return False
+
+                                # Réponse a un TIME
+                                if arg[0] == '\x01TIME\x01':
+                                    self.Protocol.on_time(original_response)
+                                    return False
+
+                                # Réponse a un PING
+                                if arg[0] == '\x01PING':
+                                    self.Protocol.on_ping(original_response)
+                                    return False
+
+                                if not arg[0].lower() in self.commands:
+                                    self.Logs.debug(f"This command {arg[0]} sent by {user_trigger} is not available")
+                                    return False
+
+                                cmd_to_send = convert_to_string.replace(':','')
+                                self.Base.log_cmd(user_trigger, cmd_to_send)
+
+                                fromchannel = None
+                                if len(arg) >= 2:
+                                    fromchannel = str(arg[1]).lower() if self.Channel.Is_Channel(arg[1]) else None
+
+                                self.hcmds(user_trigger, fromchannel, arg, cmd)
+                        # print(f"** handle {parsed_protocol}")
+
+                    except IndexError as io:
+                        self.Logs.error(f'{io}')
+
+                case 'PONG': # TODO
+                    print(f"** handle {parsed_protocol}")
+
+                case 'MODE': # TODO
+                    #['@msgid=d0ySx56Yd0nc35oHts2SkC-/J9mVUA1hfM6+Z4494xWUg;time=2024-08-09T12:45:36.651Z', 
+                    # ':001', 'MODE', '#a', '+nt', '1723207536']
+                    # [':adator_', 'UMODE2', '-i']
+                    print(f"** handle {parsed_protocol}")
+
+                case '320': # TODO
+                    #:irc.deb.biz.st 320 PyDefender IRCParis07 :is in security-groups: known-users,webirc-users,tls-and-known-users,tls-users
+                    print(f"** handle {parsed_protocol}")
+
+                case '318': # TODO
+                    #:irc.deb.biz.st 318 PyDefender IRCParis93 :End of /WHOIS list.
+                    print(f"** handle {parsed_protocol}")
+
+                case None:
+                    print(f"** TO BE HANDLE {original_response}")
+
             if len(original_response) == 7:
                 if original_response[2] == 'PRIVMSG' and original_response[4] == ':auth':
                     data_copy = original_response.copy()
@@ -756,103 +1003,6 @@ class Irc:
             else:
                 self.Logs.debug(f">> {original_response}")
 
-            parsed_protocol = self.Protocol.parse_server_msg(original_response.copy())
-
-            match parsed_protocol:
-
-                case 'PING':
-                    self.Protocol.on_server_ping(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-                    return None
-
-                case 'SJOIN':
-                    self.Protocol.on_sjoin(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'EOS':
-                    self.Protocol.on_eos(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'UID':
-                    try:
-                        self.Protocol.on_uid(serverMsg=original_response)
-
-                        for classe_name, classe_object in self.loaded_classes.items():
-                            classe_object.cmd(original_response)
-
-                        self.Logs.debug(f"** handle {parsed_protocol}")
-
-                    except Exception as err:
-                        self.Logs.error(f'General Error: {err}')
-
-                case 'QUIT':
-                    self.Protocol.on_quit(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'PROTOCTL':
-                    self.Protocol.on_protoctl(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'SVS2MODE':
-                    # >> [':00BAAAAAG', 'SVS2MODE', '001U01R03', '-r']
-                    self.Protocol.on_svs2mode(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'SQUIT':
-                    self.Protocol.on_squit(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'PART':
-                    self.Protocol.on_part(serverMsg=parsed_protocol)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'VERSION':
-                    self.Protocol.on_version_msg(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'UMODE2':
-                    # [':adator_', 'UMODE2', '-i']
-                    self.Protocol.on_umode2(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'NICK':
-                    self.Protocol.on_nick(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'REPUTATION':
-                    self.Protocol.on_reputation(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'SLOG': # TODO
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'MD': # TODO
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'PRIVMSG':
-                    self.Protocol.on_privmsg(serverMsg=original_response)
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'PONG': # TODO
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case 'MODE': # TODO
-                    #['@msgid=d0ySx56Yd0nc35oHts2SkC-/J9mVUA1hfM6...', ':001', 'MODE', '#a', '+nt', '1723207536']
-                    #['@unrealircd.org/userhost=adator@localhost;...', ':001LQ0L0C', 'MODE', '#services', '-l']
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case '320': # TODO
-                    #:irc.deb.biz.st 320 PyDefender IRCParis07 :is in security-groups: known-users,webirc-users,tls-and-known-users,tls-users
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case '318': # TODO
-                    #:irc.deb.biz.st 318 PyDefender IRCParis93 :End of /WHOIS list.
-                    self.Logs.debug(f"** handle {parsed_protocol}")
-
-                case None:
-                    self.Logs.debug(f"** TO BE HANDLE {original_response}")
-
-            if len(original_response) > 2:
             if original_response[2] != 'UID':
                 # Envoyer la commande aux classes dynamiquement chargées
                 for classe_name, classe_object in self.loaded_classes.items():
@@ -1456,7 +1606,7 @@ class Irc:
                     self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
-                        msg=f'{key} = {value}'
+                        msg=f'{key} > {value}'
                         )
 
             case 'uptime':

mods/mod_command.py

@@ -252,7 +252,7 @@ class Command:
                         if userObj is None:
                             return None
 
-                        if 'r' not in userObj.umodes and 'o' not in userObj.umodes:
+                        if 'r' not in userObj.umodes:
                             return None
 
                         db_data: dict[str, str] = {"nickname": userObj.nickname, "channel": channel_name}
@@ -285,13 +285,12 @@ class Command:
                     option: str = str(cmd[1]).lower()
                     match option:
                         case 'set':
-                            allowed_modes: list[str] = self.Base.Settings.PROTOCTL_PREFIX # ['q','a','o','h','v']
-
                             if len(cmd) < 5:
                                 self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} [nickname] [+/-mode] [#channel]")
                                 self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"AutoModes available: {' / '.join(allowed_modes)}")
                                 return None
 
+                            allowed_modes: list[str] = self.Base.Settings.PROTOCTL_PREFIX # ['q','a','o','h','v']
                             # userObj: MUser = self.User.get_User(str(cmd[2]))
                             nickname = str(cmd[2])
                             mode = str(cmd[3])
@@ -343,7 +342,6 @@ class Command:
 
                                 if db_query.rowcount > 0:
                                     self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Automode {mode} applied to {nickname} in {chan}")
-                                    if self.Channel.is_user_present_in_channel(chan, self.User.get_uid(nickname)):
                                     self.Protocol.send2socket(f":{service_id} MODE {chan} {mode} {nickname}")
                             else:
                                 self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"AUTOMODE {mode} cannot be added to {nickname} in {chan} because it doesn't exist")

mods/mod_defender.py

@@ -1281,10 +1281,6 @@ class Defender():
                 try:
                     # autolimit on
                     # autolimit set [amount] [interval]
-                    if len(cmd) < 2:
-                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON")
-                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]")
-                        return None
 
                     arg = str(cmd[1]).lower()
 
@@ -1318,12 +1314,12 @@ class Defender():
                                 )
 
                         case _:
-                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON")
+                            self.Protocol.send_notice(nick_from=dnickname, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON", nickname=fromuser)
-                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]")
+                            self.Protocol.send_notice(nick_from=dnickname, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]", nickname=fromuser)
 
                 except Exception as err:
-                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON")
+                    self.Protocol.send_notice(nick_from=dnickname, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON", nickname=fromuser)
-                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]")
+                    self.Protocol.send_notice(nick_from=dnickname, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]", nickname=fromuser)
                     self.Logs.error(f"Value Error -> {err}")
 
             case 'reputation':

version.json

@@ -1,5 +1,5 @@
 {
-    "version": "6.0.5",
+    "version": "6.0.1",
 
     "requests": "2.32.3",
     "psutil": "6.0.0",