Merge pull request #76 from adator85/upgrade-mod-jsonrpc

Moving rpc module to rpc package v2

core/base.py

@@ -769,6 +769,26 @@ class Base:
         except ValueError:
             return False
 
+    def is_valid_email(self, email_to_control: str) -> bool:
+        """Check if the email is valid
+
+        Args:
+            email_to_control (str): email to control
+
+        Returns:
+            bool: True is the email is correct
+        """
+        try:
+            pattern = '^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
+            if re.match(pattern, email_to_control):
+                return True
+            else:
+                return False
+
+        except Exception as err:
+            self.logs.error(f'General Error: {err}')
+            return False
+
     def decode_ip(self, ip_b64encoded: str) -> Union[str, None]:
 
         binary_ip = b64decode(ip_b64encoded)

core/classes/admin.py

@@ -46,7 +46,7 @@ class Admin:
                 return result
 
         if not result:
-            self.Logs.critical(f'The new nickname {newNickname} was not updated, uid = {uid}')
+            self.Logs.debug(f'The new nickname {newNickname} was not updated, uid = {uid} - The Client is not an admin')
 
         return result
 
@@ -63,7 +63,7 @@ class Admin:
                 return result
 
         if not result:
-            self.Logs.critical(f'The new level {newLevel} was not updated, nickname = {nickname}')
+            self.Logs.debug(f'The new level {newLevel} was not updated, nickname = {nickname} - The Client is not an admin')
 
         return result
 

core/classes/client.py

@@ -37,7 +37,7 @@ class Client:
 
         return True
 
-    def update(self, uid: str, newNickname: str) -> bool:
+    def update_nickname(self, uid: str, newNickname: str) -> bool:
         """Update the nickname starting from the UID
 
         Args:

core/classes/protocols/inspircd.py

@@ -401,7 +401,9 @@ class Inspircd:
 
             uid = str(serverMsg[1]).lstrip(':')
             newnickname = serverMsg[3]
-            self.__Irc.User.update(uid, newnickname)
+            self.__Irc.User.update_nickname(uid, newnickname)
+            self.__Irc.Client.update_nickname(uid, newnickname)
+            self.__Irc.Admin.update_nickname(uid, newnickname)
 
             return None
 

core/classes/protocols/unreal6.py

@@ -10,6 +10,7 @@ class Unrealircd6:
 
     def  __init__(self, ircInstance: 'Irc'):
         self.name = 'UnrealIRCD-6'
+        self.protocol_version = 6100
 
         self.__Irc = ircInstance
         self.__Config = ircInstance.Config
@@ -158,6 +159,7 @@ class Unrealircd6:
         umodes = self.__Config.SERVICE_UMODES
         host = self.__Config.SERVICE_HOST
         service_name = self.__Config.SERVICE_NAME
+        protocolversion = self.protocol_version
 
         password = self.__Config.SERVEUR_PASSWORD
         link = self.__Config.SERVEUR_LINK
@@ -169,16 +171,15 @@ class Unrealircd6:
 
         self.send2socket(f":{server_id} PASS :{password}", print_log=False)
         self.send2socket(f":{server_id} PROTOCTL SID NOQUIT NICKv2 SJOIN SJ3 NICKIP TKLEXT2 NEXTBANS CLK EXTSWHOIS MLOCK MTAGS")
-        # self.__Irc.send2socket(f":{sid} PROTOCTL NICKv2 VHP UMODE2 NICKIP SJOIN SJOIN2 SJ3 NOQUIT TKLEXT MLOCK SID MTAGS")
+        self.send2socket(f":{server_id} PROTOCTL EAUTH={link},{protocolversion},,{service_name}-v{version}")
-        self.send2socket(f":{server_id} PROTOCTL EAUTH={link},,,{service_name}-v{version}")
         self.send2socket(f":{server_id} PROTOCTL SID={server_id}")
+        self.send2socket(f":{server_id} PROTOCTL BOOTED={unixtime}")
         self.send2socket(f":{server_id} SERVER {link} 1 :{info}")
         self.send2socket(f":{server_id} {nickname} :Reserved for services")
         self.send2socket(f":{server_id} UID {nickname} 1 {unixtime} {username} {host} {service_id} * {smodes} * * fwAAAQ== :{realname}")
         self.sjoin(chan)
         self.send2socket(f":{server_id} TKL + Q * {nickname} {host} 0 {unixtime} :Reserved for services")
         self.send2socket(f":{service_id} MODE {chan} {cmodes}")
-        # self.send2socket(f":{service_id} MODE {chan} {umodes} {service_id}")
 
         self.__Base.logs.debug(f'>> {__name__} Link information sent to the server')
 
@@ -198,7 +199,7 @@ class Unrealircd6:
         self.send2socket(f":{self.__Config.SERVICE_NICKNAME} NICK {newnickname}")
 
         userObj = self.__Irc.User.get_User(self.__Config.SERVICE_NICKNAME)
-        self.__Irc.User.update(userObj.uid, newnickname)
+        self.__Irc.User.update_nickname(userObj.uid, newnickname)
         return None
 
     def squit(self, server_id: str, server_link: str, reason: str) -> None:
@@ -459,6 +460,16 @@ class Unrealircd6:
         self.__Irc.Channel.delete_user_from_channel(channel, userObj.uid)
         return None
 
+    def send_mode_chan(self, channel_name: str, channel_mode: str) -> None:
+
+        channel = self.__Irc.Channel.Is_Channel(channelToCheck=channel_name)
+        if not channel:
+            self.__Base.logs.error(f'The channel [{channel_name}] is not correct')
+            return None
+
+        self.send2socket(f":{self.__Config.SERVICE_NICKNAME} MODE {channel_name} {channel_mode}")
+        return None
+
     def send_raw(self, raw_command: str) -> None:
 
         self.send2socket(f":{self.__Config.SERVICE_NICKNAME} {raw_command}")
@@ -631,8 +642,9 @@ class Unrealircd6:
 
             uid = str(serverMsg[1]).lstrip(':')
             newnickname = serverMsg[3]
-            self.__Irc.User.update(uid, newnickname)
+            self.__Irc.User.update_nickname(uid, newnickname)
-            self.__Irc.Client.update(uid, newnickname)
+            self.__Irc.Client.update_nickname(uid, newnickname)
+            self.__Irc.Admin.update_nickname(uid, newnickname)
 
             return None
 

core/classes/user.py

@@ -37,7 +37,7 @@ class User:
 
         return True
 
-    def update(self, uid: str, newNickname: str) -> bool:
+    def update_nickname(self, uid: str, newNickname: str) -> bool:
         """Update the nickname starting from the UID
 
         Args:

core/irc.py

@@ -98,6 +98,7 @@ class Irc:
         self.build_command(0, 'core', 'firstauth', 'First authentication of the Service')
         self.build_command(0, 'core', 'register', f'Register your nickname /msg {self.Config.SERVICE_NICKNAME} REGISTER <password> <email>')
         self.build_command(0, 'core', 'identify', f'Identify yourself with your password /msg {self.Config.SERVICE_NICKNAME} IDENTIFY <account> <password>')
+        self.build_command(0, 'core', 'logout', 'Reverse the effect of the identify command')
         self.build_command(1, 'core', 'load', 'Load an existing module')
         self.build_command(1, 'core', 'unload', 'Unload a module')
         self.build_command(1, 'core', 'reload', 'Reload a module')
@@ -136,6 +137,7 @@ class Irc:
             ircInstance (Irc): Instance of Irc object.
         """
         try:
+            self.init_service_user()
             self.__create_socket()
             self.__connect_to_irc(ircInstance)
         except AssertionError as ae:
@@ -1233,8 +1235,27 @@ class Irc:
 
             case 'register':
                 # Register PASSWORD EMAIL
+                try:
+
+                    if len(cmd) < 3:
+                        self.Protocol.send_notice(
+                            nick_from=dnickname,
+                            nick_to=fromuser,
+                            msg=f'/msg {self.Config.SERVICE_NICKNAME} {command.upper()} <PASSWORD> <EMAIL>'
+                        )
+                        return None
+
                     password = cmd[1]
                     email = cmd[2]
+
+                    if not self.Base.is_valid_email(email_to_control=email):
+                        self.Protocol.send_notice(
+                            nick_from=dnickname,
+                            nick_to=fromuser,
+                            msg='The email is not valid. You must provide a valid email address (first.name@email.extension)'
+                        )
+                        return None
+
                     user_obj = self.User.get_User(fromuser)
 
                     if user_obj is None:
@@ -1273,19 +1294,32 @@ class Irc:
 
                     return None
 
+                except ValueError as ve:
+                    self.Logs.error(f"Value Error : {ve}")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" {self.Config.SERVICE_PREFIX}{command.upper()} <PASSWORD> <EMAIL>")
+
             case 'identify':
-                # Identify NICKNAME password
+                # Identify ACCOUNT PASSWORD
-                nickname = str(cmd[1])
+                try:
+                    if len(cmd) < 3:
+                        self.Protocol.send_notice(
+                            nick_from=dnickname,
+                            nick_to=fromuser,
+                            msg=f'/msg {self.Config.SERVICE_NICKNAME} {command.upper()} <ACCOUNT> <PASSWORD>'
+                        )
+                        return None
+
+                    account = str(cmd[1]) # account
                     encrypted_password = self.Base.crypt_password(cmd[2])
-                client_obj = self.Client.get_Client(nickname)
                     user_obj = self.User.get_User(fromuser)
+                    client_obj = self.Client.get_Client(user_obj.uid)
 
                     if client_obj is not None:
                         self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"You are already logged in")
                         return None
 
-                db_query = f"SELECT account FROM {self.Config.TABLE_CLIENT} WHERE nickname = :nickname AND password = :password"
+                    db_query = f"SELECT account FROM {self.Config.TABLE_CLIENT} WHERE account = :account AND password = :password"
-                db_param = {'nickname': nickname, 'password': encrypted_password}
+                    db_param = {'account': account, 'password': encrypted_password}
                     exec_query = self.Base.db_execute_query(
                         db_query,
                         db_param
@@ -1295,18 +1329,58 @@ class Irc:
                         account = result_query[0]
                         self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"You are now logged in")
                         client = self.Loader.Definition.MClient(
-                        uid=user_obj.uid, account=account, nickname=nickname,
+                            uid=user_obj.uid, account=account, nickname=fromuser,
                             username=user_obj.username, realname=user_obj.realname, hostname=user_obj.hostname, umodes=user_obj.umodes, vhost=user_obj.vhost,
                             isWebirc=user_obj.isWebirc, isWebsocket=user_obj.isWebsocket, remote_ip=user_obj.remote_ip, score_connexion=user_obj.score_connexion,
                             geoip=user_obj.geoip, connexion_datetime=user_obj.connexion_datetime
                         )
                         self.Client.insert(client)
-                    self.Protocol.send_svs_mode(nickname=nickname, user_mode='+r')
+                        self.Protocol.send_svs_mode(nickname=fromuser, user_mode='+r')
                     else:
                         self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Wrong password or account")
 
                     return None
 
+                except ValueError as ve:
+                    self.Logs.error(f"Value Error: {ve}")
+                    self.Protocol.send_notice(
+                            nick_from=dnickname,
+                            nick_to=fromuser,
+                            msg=f'/msg {self.Config.SERVICE_NICKNAME} {command.upper()} <ACCOUNT> <PASSWORD>'
+                        )
+
+                except Exception as err:
+                    self.Logs.error(f"General Error: {err}")
+
+            case 'logout':
+                try:
+                    # LOGOUT <account>
+                    if len(cmd) < 2:
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} <account>")
+                        return None
+
+                    user_obj = self.User.get_User(fromuser)
+                    if user_obj is None:
+                        self.Logs.error(f"The User [{fromuser}] is not available in the database")
+                        return None
+
+                    client_obj = self.Client.get_Client(user_obj.uid)
+
+                    if client_obj is None:
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="Nothing to logout. please login first")
+                        return None
+
+                    self.Protocol.send_svs_mode(nickname=fromuser, user_mode='-r')
+                    self.Client.delete(user_obj.uid)
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"You have been logged out successfully")
+
+                except ValueError as ve:
+                    self.Logs.error(f"Value Error: {ve}")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} <account>")
+                except Exception as err:
+                    self.Logs.error(f"General Error: {err}")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} <account>")
+
             case 'help':
 
                 self.generate_help_menu(nickname=fromuser)
@@ -1352,6 +1426,9 @@ class Irc:
                     self.Base.shutdown()
                     self.Base.execute_periodic_action()
 
+                    for chan_name in self.Channel.UID_CHANNEL_DB:
+                        self.Protocol.send_mode_chan(chan_name.name, '-l')
+
                     self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
@@ -1403,7 +1480,7 @@ class Irc:
                 current_version = self.Config.CURRENT_VERSION
                 latest_version = self.Config.LATEST_VERSION
 
-                mods = ["core.config", "core.base", "core.classes.protocols.unreal6", "core.classes.protocol"]
+                mods = ["core.definition", "core.config", "core.base", "core.classes.protocols.unreal6", "core.classes.protocol"]
 
                 mod_unreal6 = sys.modules['core.classes.protocols.unreal6']
                 mod_protocol = sys.modules['core.classes.protocol']
@@ -1426,7 +1503,7 @@ class Irc:
                 config_dict: dict = self.Config.__dict__
 
                 for key, value in conf_bkp_dict.items():
-                    if config_dict[key] != value:
+                    if config_dict[key] != value and key != 'COLORS':
                         self.Protocol.send_priv_msg(
                             nick_from=self.Config.SERVICE_NICKNAME,
                             msg=f'[{key}]: {value} ==> {config_dict[key]}', 

mods/mod_command.py

@@ -1127,18 +1127,19 @@ class Command:
             case 'sapart':
                 try:
                     # .sapart nickname #channel
-                    nickname = str(cmd[1])
-                    channel = str(cmd[2])
                     if len(cmd) < 3:
                         self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
                         return None
 
+                    nickname = str(cmd[1])
+                    channel = str(cmd[2])
+
                     self.Protocol.send_sapart(nick_to_sapart=nickname, channel_name=channel)
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
                     self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
+                    self.Logs.error(f'Unknown Error: {str(err)}')
 
             case 'svsnick':
                 try:

mods/mod_defender.py

@@ -1000,11 +1000,18 @@ class Defender():
 
                 case 'MODE':
                     # ['...', ':001XSCU0Q', 'MODE', '#jail', '+b', '~security-group:unknown-users']
+                    # ['@unrealircd.org/...', ':001C0MF01', 'MODE', '#services', '+l', '1']
+
                     channel = str(cmd[3])
                     mode = str(cmd[4])
                     group_to_check = str(cmd[5:])
                     group_to_unban = '~security-group:unknown-users'
 
+                    if self.ModConfig.autolimit == 1:
+                        if mode == '+l' or mode == '-l':
+                            chan = self.Channel.get_Channel(channel)
+                            self.Protocol.send2socket(f":{self.Config.SERVICE_ID} MODE {chan.name} +l {len(chan.uids) + self.ModConfig.autolimit_amount}")
+
                     if self.Config.SALON_JAIL == channel:
                         if mode == '+b' and group_to_unban in group_to_check:
                             self.Protocol.send2socket(f":{service_id} MODE {self.Config.SALON_JAIL} -b ~security-group:unknown-users")
@@ -1709,6 +1716,9 @@ class Defender():
                     self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.abuseipdb_scan == 1 else color_red}abuseipdb_scan{nogc}             ==> {self.ModConfig.abuseipdb_scan}')
                     self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.freeipapi_scan == 1 else color_red}freeipapi_scan{nogc}             ==> {self.ModConfig.freeipapi_scan}')
                     self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.cloudfilt_scan == 1 else color_red}cloudfilt_scan{nogc}             ==> {self.ModConfig.cloudfilt_scan}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' [{color_green if self.ModConfig.autolimit == 1 else color_red}Autolimit{nogc}]                            ==> {self.ModConfig.autolimit}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.autolimit == 1 else color_red}Autolimit Amount{nogc}           ==> {self.ModConfig.autolimit_amount}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.autolimit == 1 else color_red}Autolimit Interval{nogc}         ==> {self.ModConfig.autolimit_interval}')
                     self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' [{color_green if self.ModConfig.flood == 1 else color_red}Flood{nogc}]                                ==> {self.ModConfig.flood}')
                     self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg='      flood_action                      ==> Coming soon')
                     self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'      flood_message                     ==> {self.ModConfig.flood_message}')

mods/mod_jsonrpc.py

@@ -1,7 +1,7 @@
 import logging
 from typing import TYPE_CHECKING
 from dataclasses import dataclass
-from unrealircd_rpc_py.Live import Live
+from unrealircd_rpc_py.Live import LiveWebsocket
 from unrealircd_rpc_py.Loader import Loader
 
 if TYPE_CHECKING:
@@ -63,15 +63,23 @@ class Jsonrpc():
         self.__load_module_configuration()
         # End of mandatory methods you can start your customization #
 
-        self.UnrealIrcdRpcLive: Live = Live(
+        self.UnrealIrcdRpcLive: LiveWebsocket = LiveWebsocket(
-                    req_method='websocket',
                     url=self.Config.JSONRPC_URL,
                     username=self.Config.JSONRPC_USER,
                     password=self.Config.JSONRPC_PASSWORD,
                     callback_object_instance=self,
-                    callback_method_name='callback_sent_to_irc'
+                    callback_method_or_function_name='callback_sent_to_irc'
                     )
         
+        if self.UnrealIrcdRpcLive.get_error.code != 0:
+            self.Logs.error(self.UnrealIrcdRpcLive.get_error.code, self.UnrealIrcdRpcLive.get_error.message)
+            self.Protocol.send_priv_msg(
+                    nick_from=self.Config.SERVICE_NICKNAME,
+                    msg=f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.UnrealIrcdRpcLive.get_error.message}", 
+                    channel=self.Config.SERVICE_CHANLOG
+                )
+            return
+
         self.Rpc: Loader = Loader(
             req_method=self.Config.JSONRPC_METHOD,
             url=self.Config.JSONRPC_URL,
@@ -79,22 +87,16 @@ class Jsonrpc():
             password=self.Config.JSONRPC_PASSWORD
         )
 
+        if self.Rpc.get_error.code != 0:
+            self.Logs.error(self.Rpc.get_error.code, self.Rpc.get_error.message)
+            self.Protocol.send_priv_msg(
+                nick_from=self.Config.SERVICE_NICKNAME,
+                msg=f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.Rpc.get_error.message}",
+                channel=self.Config.SERVICE_CHANLOG
+                )
+
         self.subscribed = False
 
-        if self.Rpc.Error.code != 0:
-            self.Protocol.send_priv_msg(
-                nick_from=self.Config.SERVICE_NICKNAME,
-                msg=f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.Rpc.Error.message}", 
-                channel=self.Config.SERVICE_CHANLOG
-                )
-
-        if self.UnrealIrcdRpcLive.Error.code != 0:
-            self.Protocol.send_priv_msg(
-                    nick_from=self.Config.SERVICE_NICKNAME,
-                    msg=f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.UnrealIrcdRpcLive.Error.message}", 
-                    channel=self.Config.SERVICE_CHANLOG
-                )
-
         if self.ModConfig.jsonrpc == 1:
             self.Base.create_thread(self.thread_start_jsonrpc, run_once=True)
 
@@ -120,7 +122,7 @@ class Jsonrpc():
         self.Base.db_execute_query(table_logs)
         return None
 
-    def callback_sent_to_irc(self, json_response: str):
+    def callback_sent_to_irc(self, response):
 
         dnickname = self.Config.SERVICE_NICKNAME
         dchanlog = self.Config.SERVICE_CHANLOG
@@ -129,32 +131,37 @@ class Jsonrpc():
         bold = self.Config.COLORS.bold
         red = self.Config.COLORS.red
 
-        if json_response.result == True:
+        if hasattr(response, 'result'):
+            if isinstance(response.result, bool) and response.result:
                 self.Protocol.send_priv_msg(
                     nick_from=self.Config.SERVICE_NICKNAME,
                     msg=f"[{bold}{green}JSONRPC{nogc}{bold}] Event activated", 
                     channel=dchanlog)
                 return None
 
-        level = json_response.result.level
+        level = response.result.level if hasattr(response.result, 'level') else ''
-        subsystem = json_response.result.subsystem
+        subsystem = response.result.subsystem if hasattr(response.result, 'subsystem') else ''
-        event_id = json_response.result.event_id
+        event_id = response.result.event_id if hasattr(response.result, 'event_id') else ''
-        log_source = json_response.result.log_source
+        log_source = response.result.log_source if hasattr(response.result, 'log_source') else ''
-        msg = json_response.result.msg
+        msg = response.result.msg if hasattr(response.result, 'msg') else ''
 
         build_msg = f"{green}{log_source}{nogc}: [{bold}{level}{bold}] {subsystem}.{event_id} - {msg}"
 
+        # Check if there is an error
+        if self.UnrealIrcdRpcLive.get_error.code != 0:
+            self.Logs.error(f"RpcLiveError: {self.UnrealIrcdRpcLive.get_error.message}")
+
         self.Protocol.send_priv_msg(nick_from=dnickname, msg=build_msg, channel=dchanlog)
 
     def thread_start_jsonrpc(self):
 
-        if self.UnrealIrcdRpcLive.Error.code == 0:
+        if self.UnrealIrcdRpcLive.get_error.code == 0:
             self.UnrealIrcdRpcLive.subscribe(["all"])
             self.subscribed = True
         else:
             self.Protocol.send_priv_msg(
                     nick_from=self.Config.SERVICE_NICKNAME,
-                    msg=f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.UnrealIrcdRpcLive.Error.message}", 
+                    msg=f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.UnrealIrcdRpcLive.get_error.message}", 
                     channel=self.Config.SERVICE_CHANLOG
                 )
 
@@ -218,17 +225,17 @@ class Jsonrpc():
                             #         self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"{logger_name} - {logger.level}")
 
                             for thread in self.Base.running_threads:
-                                if thread.getName() == 'thread_start_jsonrpc':
+                                if thread.name == 'thread_start_jsonrpc':
                                     if thread.is_alive():
                                         self.Protocol.send_priv_msg(
                                             nick_from=self.Config.SERVICE_NICKNAME,
-                                            msg=f"Thread {thread.getName()} is running",
+                                            msg=f"Thread {thread.name} is running",
                                             channel=dchannel
                                             )
                                     else:
                                         self.Protocol.send_priv_msg(
                                             nick_from=self.Config.SERVICE_NICKNAME,
-                                            msg=f"Thread {thread.getName()} is not running, wait untill the process will be cleaned up",
+                                            msg=f"Thread {thread.name} is not running, wait untill the process will be cleaned up",
                                             channel=dchannel
                                             )
 
@@ -260,8 +267,8 @@ class Jsonrpc():
                             rpc = self.Rpc
 
                             UserInfo = rpc.User.get(uid_to_get)
-                            if rpc.Error.code != 0:
+                            if rpc.get_error.code != 0:
-                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'{rpc.Error.message}')
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'{rpc.get_error.message}')
                                 return None
 
                             chan_list = []

version.json

@@ -1,9 +1,9 @@
 {
-    "version": "6.1.0",
+    "version": "6.1.3",
 
     "requests": "2.32.3",
     "psutil": "6.0.0",
-    "unrealircd_rpc_py": "1.0.7",
+    "unrealircd_rpc_py": "2.0.0",
     "sqlalchemy": "2.0.35",
     "faker": "30.1.0"
 }