First Version 6

mods/mod_clone.py

@@ -1,9 +1,11 @@
 from dataclasses import dataclass, fields, field
+import copy
 import random, faker, time, logging
 from datetime import datetime
-from typing import Union
-from core.irc import Irc
-from core.connection import Connection
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from core.irc import Irc
 
 class Clone():
 
@@ -11,7 +13,7 @@ class Clone():
     class ModConfModel:
         clone_nicknames: list[str]
 
-    def __init__(self, ircInstance:Irc) -> None:
+    def __init__(self, ircInstance: 'Irc') -> None:
 
         # Module name (Mandatory)
         self.module_name = 'mod_' + str(self.__class__.__name__).lower()
@@ -19,6 +21,9 @@ class Clone():
         # Add Irc Object to the module (Mandatory)
         self.Irc = ircInstance
 
+        # Add Irc Protocol Object to the module (Mandatory)
+        self.Protocol = ircInstance.Protocol
+
         # Add Global Configuration to the module (Mandatory)
         self.Config = ircInstance.Config
 
@@ -34,7 +39,10 @@ class Clone():
         # Add Channel object to the module (Mandatory)
         self.Channel = ircInstance.Channel
 
-        self.Clone = ircInstance.Clones
+        # Add clone object to the module (Optionnal)
+        self.Clone = ircInstance.Clone
+
+        self.Definition = ircInstance.Loader.Definition
 
         # Créer les nouvelles commandes du module
         self.commands_level = {
@@ -55,14 +63,22 @@ class Clone():
         # Créer les tables necessaire a votre module (ce n'es pas obligatoire)
         self.__create_tables()
 
+        self.CloneCopy = [self.Definition.MClone()]
+        self.stop = False
+        logging.getLogger('faker').setLevel(logging.CRITICAL)
+
+        self.fakeEN = faker.Faker('en_GB')
+        self.fakeFR = faker.Faker('fr_FR')
+
         # Load module configuration (Mandatory)
         self.__load_module_configuration()
 
-        self.Base.db_query_channel(action='add', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL)
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} JOIN {self.Config.CLONE_CHANNEL}")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} SAMODE {self.Config.CLONE_CHANNEL} +o {self.Config.SERVICE_NICKNAME}")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} +nts")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} +k {self.Config.CLONE_CHANNEL_PASSWORD}")
+        self.Channel.db_query_channel(action='add', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL)
+        self.Protocol.join(self.Config.SERVICE_NICKNAME, self.Config.CLONE_CHANNEL)
+
+        self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} SAMODE {self.Config.CLONE_CHANNEL} +o {self.Config.SERVICE_NICKNAME}")
+        self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} +nts")
+        self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} +k {self.Config.CLONE_CHANNEL_PASSWORD}")
 
     def __set_commands(self, commands:dict[int, list[str]]) -> None:
         """### Rajoute les commandes du module au programme principal
@@ -96,7 +112,7 @@ class Clone():
             )
         '''
 
-        self.Base.db_execute_query(table_channel)
+        # self.Base.db_execute_query(table_channel)
 
         return None
 
@@ -122,163 +138,215 @@ class Clone():
         rechargement de module
         """
 
-        # kill all clones before unload
-        for clone in self.ModConfig.clone_nicknames:
-            self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone} :KILL')
-
-        self.Base.db_query_channel(action='del', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL)
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -nts")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -k {self.Config.CLONE_CHANNEL_PASSWORD}")
-        self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} PART {self.Config.CLONE_CHANNEL}")
-        return None
-
-    def thread_clone_clean_up(self, wait: float):
-
-        activated = True
-
-        while activated:
-            clone_to_kill: list[str] = []
-
-            for clone in self.Clone.UID_CLONE_DB:
-                if not clone.connected and clone.alive and not clone.init:
-                    clone_to_kill.append(clone.nickname)
-                    clone.alive = False
-
-            for clone_nickname in clone_to_kill:
-                if self.Clone.delete(clone_nickname):
-                    self.Logs.debug(f'<<{clone_nickname}>> object has been deleted')
-
-            del clone_to_kill
-
-            # If no more clones then stop this thread
-            if not self.Clone.UID_CLONE_DB:
-                break
-
-            time.sleep(wait)
-
-    def thread_change_hostname(self):
-
-        fake = faker.Faker('en_GB')
-        for clone in self.Clone.UID_CLONE_DB:
-            if not clone.vhost is None:
-                continue
-
-            rand_1 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
-            rand_2 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
-            rand_3 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
-
-            rand_ip = ''.join(rand_1) + '.' + ''.join(rand_2) + '.' + ''.join(rand_3) + '.IP'
-            found = False
-
-            while not found:
-                if clone.connected:
-                    self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} CHGHOST {clone.nickname} {rand_ip}')
-                    found = True
-                    clone.vhost = rand_ip
-                    break
-                if not clone in self.Clone.UID_CLONE_DB:
-                    found = True
-                    break
-
-    def thread_create_clones_with_interval(self, number_of_clones:int, channels: list, connection_interval: float):
-
-        for i in range(number_of_clones):
-            nickname, username, realname = self.generate_names()
-            self.Base.create_thread(
-                self.thread_create_clones,
-                (nickname, username, realname, channels, 6697, True)
-                )
-            time.sleep(connection_interval)
-
-        self.Base.create_thread(
-            self.thread_change_hostname
-        )
-
-        # self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :{str(number_of_clones)} clones joined the network')
-
-        self.Base.create_thread(self.thread_clone_clean_up, (5, ), run_once=True)
-
-    def thread_create_clones(self, nickname: str, username: str, realname: str, channels: list, server_port: int, ssl: bool) -> None:
-
-        Connection(server_port=server_port, nickname=nickname, username=username, realname=realname, channels=channels, CloneObject=self.Clone, ssl=ssl)
+        self.Channel.db_query_channel(action='del', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL)
+        self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -nts")
+        self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -k {self.Config.CLONE_CHANNEL_PASSWORD}")
+        self.Protocol.part(self.Config.SERVICE_NICKNAME, self.Config.CLONE_CHANNEL)
 
         return None
 
-    def thread_join_channels(self, channel_name: str, wait: float, clone_name:str = None):
-        self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Clones start to join {channel_name} with {wait} secondes frequency')
-        if clone_name is None:
-            for clone in self.Clone.UID_CLONE_DB:
-                if not channel_name in clone.channels:
-                    time.sleep(wait)
-                    self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
-                    clone.channels.append(channel_name)
-        else:
-            for clone in self.Clone.UID_CLONE_DB:
-                if clone_name == clone.nickname:
-                    if not channel_name in clone.channels:
-                        time.sleep(wait)
-                        self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
-                        clone.channels.append(channel_name)
+    def generate_vhost(self) -> str:
 
-    def generate_names(self) -> tuple[str, str, str]:
+        fake = self.fakeEN
+
+        rand_1 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
+        rand_2 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
+        rand_3 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
+
+        vhost = ''.join(rand_1) + '.' + ''.join(rand_2) + '.' + ''.join(rand_3) + '.IP'
+        return vhost
+
+    def generate_clones(self, group: str = 'Default') -> None:
         try:
-            logging.getLogger('faker').setLevel(logging.CRITICAL)
-            fake = faker.Faker('en_GB')
-            # nickname = fake.first_name()
-            # username = fake.last_name()
+            # :5TC UID Q 1 1727473203 qb4u localhost 5TC00000Q * Sdiop  network/service/test * AAAAAAAAAAAAAAAAAAAAAQ== :qbot4u
+
+            fakeEN = self.fakeEN
+            fakeFR = self.fakeFR
+            unixtime = self.Base.get_unixtime()
+
+            chaine = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+            generate_uid = fakeEN.random_sample(chaine, 6)
+            uid = self.Config.SERVEUR_ID + ''.join(generate_uid)
 
             # Generate Username
             chaine = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
-            new_username = fake.random_sample(chaine, 9)
+            new_username = fakeEN.random_sample(chaine, 9)
             username = ''.join(new_username)
 
             # Create realname XX F|M Department
-            gender = fake.random_choices(['F','M'], 1)
+            gender = fakeEN.random_choices(['F','M'], 1)
             gender = ''.join(gender)
-            
+
             if gender == 'F':
-                nickname = fake.first_name_female()
+                nickname = fakeEN.first_name_female()
             elif gender == 'M':
-                nickname = fake.first_name_male()
+                nickname = fakeEN.first_name_male()
             else:
-                nickname = fake.first_name()
+                nickname = fakeEN.first_name()
 
             age = random.randint(20, 60)
-            fake_fr = faker.Faker(['fr_FR', 'en_GB'])
-            department = fake_fr.department_name()
+            department = fakeFR.department_name()
             realname = f'{age} {gender} {department}'
 
-            if self.Clone.exists(nickname=nickname):
+            ip = self.Base.encode_ip(fakeEN.ipv4_private())
+
+            vhost = self.generate_vhost()
+
+            checkNickname = self.Clone.exists(nickname=nickname)
+            checkUid = self.Clone.uid_exists(uid=uid)
+
+            while checkNickname:
                 caracteres = '0123456789'
                 randomize = ''.join(random.choice(caracteres) for _ in range(2))
                 nickname = nickname + str(randomize)
-                self.Clone.insert(
-                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username, realname=realname, channels=[])
-                    )
-            else:
-                self.Clone.insert(
-                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username, realname=realname, channels=[])
-                    )
+                checkNickname = self.Clone.exists(nickname=nickname)
 
-            return (nickname, username, realname)
+            while checkUid:
+                chaine = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+                generate_uid = fakeEN.random_sample(chaine, 6)
+                uid = self.Config.SERVEUR_ID + ''.join(generate_uid)
+                checkUid = self.Clone.uid_exists(uid=uid)
+
+            clone = self.Definition.MClone(
+                        connected=False, 
+                        nickname=nickname, 
+                        username=username, 
+                        realname=realname, 
+                        uid=uid, 
+                        remote_ip=ip, 
+                        vhost=vhost, 
+                        group=group, 
+                        channels=[]
+                        )
+
+            self.Clone.insert(clone)
+            self.CloneCopy.append(clone)
+
+            return None
 
         except AttributeError as ae:
             self.Logs.error(f'Attribute Error : {ae}')
         except Exception as err:
-            self.Logs.error(err)
+            self.Logs.error(f"General Error: {err}")
+
+    def thread_connect_clones(self, number_of_clones:int , group: str, interval: float = 0.2) -> None:
+
+        for i in range(0, number_of_clones):
+            self.generate_clones(group=group)
+
+        for clone in self.Clone.UID_CLONE_DB:
+
+            if self.stop:
+                print(f"Stop creating clones ...")
+                self.stop = False
+                break
+
+            if not clone.connected:
+                cloneObj_asdict = self.Clone.get_Clone_AsDict(clone.uid)
+
+                for key in ['connected','group','channels']:
+                    cloneObj_asdict.pop(key, None)
+
+                self.User.insert(
+                    self.Definition.MUser(**cloneObj_asdict)
+                )
+
+                self.Protocol.send2socket(f":{self.Config.SERVEUR_ID} UID {clone.nickname} 1 {self.Base.get_unixtime()} {clone.username} {clone.hostname} {clone.uid} * +ixwz  {clone.vhost} * {clone.remote_ip} :{clone.realname}", False)
+                self.Protocol.join(uidornickname=clone.uid, channel=self.Config.CLONE_CHANNEL, password=self.Config.CLONE_CHANNEL_PASSWORD, print_log=False)
+                self.Irc.Channel.insert(self.Irc.Loader.Definition.MChannel(name=self.Config.CLONE_CHANNEL, uids=[clone.uid]))
+
+            time.sleep(interval)
+            clone.connected = True
+
+    def thread_kill_clones(self, fromuser: str) -> None:
+
+        clone_to_kill: list[str] = []
+        for clone in self.Clone.UID_CLONE_DB:
+            self.Protocol.send2socket(f':{clone.uid} QUIT :Goood bye', False)
+            clone_to_kill.append(clone.uid)
+
+        for clone_uid in clone_to_kill:
+            self.Irc.Channel.delete_user_from_all_channel(clone_uid)
+            self.Clone.delete(clone_uid)
+            self.User.delete(clone_uid)
+
+        del clone_to_kill
+
+        self.clean_clones(fromuser)
+
+        return None
+
+    def clean_clones(self, fromuser: str) -> None:
+
+        connected = 0
+        for c in self.CloneCopy:
+            if c.connected:
+                connected += 1
+
+        self.Protocol.sendNotice(nick_from=self.Config.SERVICE_NICKNAME, nick_to=fromuser, msg=f"Clean in progress | Total Clones in memory {len(self.CloneCopy) - 1} - {connected} / {len(self.CloneCopy) - 1} Connected ...")
+        clone_to_kill: list[str] = []
+
+        # clean from Channels
+        for clone in self.CloneCopy:
+            self.Irc.Channel.delete_user_from_all_channel(clone.uid)
+
+        # clean from users
+        for clone in self.CloneCopy:
+            self.Protocol.send2socket(f':{clone.uid} QUIT :Goood bye', False)
+            clone_to_kill.append(clone.uid)
+
+        # clean original clone object
+        for clone_uid in clone_to_kill:
+            self.User.delete(clone_uid)
+            self.Clone.delete(clone_uid)
+
+        self.CloneCopy = [self.Definition.MClone()]
+        self.Protocol.sendNotice(nick_from=self.Config.SERVICE_NICKNAME, nick_to=fromuser, 
+                                 msg="Clone cleaning done!")
+        return None
 
     def cmd(self, data:list) -> None:
+        try:
+            service_id = self.Config.SERVICE_ID                 # Defender serveur id
+            cmd = list(data).copy()
 
-        service_id = self.Config.SERVICE_ID                 # Defender serveur id
-        cmd = list(data).copy()
+            if len(cmd) < 2:
+                return None
 
-        if len(cmd) < 2:
-            return None
+            match cmd[1]:
 
-        match cmd[1]:
+                case 'REPUTATION':
+                    pass
 
-            case 'REPUTATION':
-                pass
+            if len(cmd) < 3:
+                return None
+
+            match cmd[2]:
+                case 'PRIVMSG':
+                    # print(cmd)
+                    uid_sender = self.User.clean_uid(cmd[1])
+                    senderObj = self.User.get_User(uid_sender)
+
+                    if senderObj.hostname in self.Config.CLONE_LOG_HOST_EXEMPT:
+                        return None
+
+                    if not senderObj is None:
+                        senderMsg = ' '.join(cmd[4:])
+                        getClone = self.Clone.get_Clone(cmd[3])
+
+                        if getClone is None:
+                            return None
+
+                        if getClone.uid != self.Config.SERVICE_ID:
+                            final_message = f"{senderObj.nickname}!{senderObj.username}@{senderObj.hostname} > {senderMsg.lstrip(':')}"
+                            self.Protocol.sendPrivMsg(
+                                nick_from=senderObj.uid,
+                                msg=final_message,
+                                channel=self.Config.CLONE_CHANNEL
+                            )
+
+        except Exception as err:
+            self.Base.logs.error(f'General Error: {err}')
 
     def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
 
@@ -293,10 +361,11 @@ class Clone():
                 case 'clone':
 
                     if len(cmd) == 1:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect 6 2.5')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill [all | nickname]')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join [all | nickname] #channel')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone list')
+                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone connect NUMBER GROUP_NAME INTERVAL")
+                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill [all | nickname]")
+                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join [all | nickname] #channel")
+                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part [all | nickname] #channel")
+                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone list")
 
                     option = str(cmd[1]).lower()
 
@@ -304,46 +373,47 @@ class Clone():
 
                         case 'connect':
                             try:
-                                # clone connect 5
+                                # clone connect 5 Group 3
+                                self.stop = False
                                 number_of_clones = int(cmd[2])
-                                connection_interval = int(cmd[3]) if len(cmd) == 4 else 0.5
+                                group = str(cmd[3]).lower()
+                                connection_interval = int(cmd[4]) if len(cmd) == 5 else 0.5
+
                                 self.Base.create_thread(
-                                    self.thread_create_clones_with_interval,
-                                    (number_of_clones, [], connection_interval)
-                                    )
+                                    func=self.thread_connect_clones,
+                                    func_args=(number_of_clones, group, connection_interval)
+                                )
 
                             except Exception as err:
                                 self.Logs.error(f'{err}')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect [number of clone you want to connect] [Connection Interval]')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} clone connect 6 2.5')
+                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone connect [number of clone you want to connect] [Group]")
+                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Exemple /msg {dnickname} clone connect 6 Ambiance")
 
                         case 'kill':
                             try:
                                 # clone kill [all | nickname]
+                                self.stop = True
                                 clone_name = str(cmd[2])
                                 clone_to_kill: list[str] = []
 
                                 if clone_name.lower() == 'all':
-                                    for clone in self.Clone.UID_CLONE_DB:
-                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {clone.nickname} :KILL')
-                                        clone_to_kill.append(clone.nickname)
-                                        clone.alive = False
-
-                                    for clone_nickname in clone_to_kill:
-                                        self.Clone.delete(clone_nickname)
-
-                                    del clone_to_kill
+                                    self.Base.create_thread(func=self.thread_kill_clones, func_args=(fromuser, ))
 
                                 else:
                                     if self.Clone.exists(clone_name):
-                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {clone_name} :KILL')
-                                        self.Clone.kill(clone_name)
-                                        self.Clone.delete(clone_name)
+
+                                        self.Protocol.send2socket(f':{clone_name} QUIT :Goood bye')
+
+                                        clone_uid = self.Clone.get_uid(clone_name)
+                                        if not clone_uid is None:
+                                            self.Irc.Channel.delete_user_from_all_channel(clone_uid)
+                                            self.Clone.delete(clone_name)
+                                            self.User.delete(clone_uid)
 
                             except Exception as err:
                                 self.Logs.error(f'{err}')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill all')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill clone_nickname')
+                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill all")
+                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill clone_nickname")
 
                         case 'join':
                             try:
@@ -352,21 +422,53 @@ class Clone():
                                 clone_channel_to_join = str(cmd[3])
 
                                 if clone_name.lower() == 'all':
-                                    self.Base.create_thread(self.thread_join_channels, (clone_channel_to_join, 2))
+
+                                    for clone in self.Clone.UID_CLONE_DB:
+                                        self.Protocol.join(uidornickname=clone.uid, channel=clone_channel_to_join, print_log=False)
+                                        self.Irc.Channel.insert(self.Irc.Loader.Definition.MChannel(name=clone_channel_to_join, uids=[clone.uid]))
+
                                 else:
-                                    self.Base.create_thread(self.thread_join_channels, (clone_channel_to_join, 2, clone_name))
+                                    if self.Clone.exists(clone_name):
+                                        if not self.Clone.get_uid(clone_name) is None:
+                                            self.Protocol.join(uidornickname=clone_name, channel=clone_channel_to_join, print_log=False)
+                                            self.Irc.Channel.insert(self.Irc.Loader.Definition.MChannel(name=clone_channel_to_join, uids=[self.Clone.get_uid(clone_name)]))
 
                             except Exception as err:
                                 self.Logs.error(f'{err}')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join all #channel')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join clone_nickname #channel')
+                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join all #channel")
+                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join clone_nickname #channel")
+
+                        case 'part':
+                            try:
+                                # clone part [all | nickname] #channel
+                                clone_name = str(cmd[2])
+                                clone_channel_to_part = str(cmd[3])
+
+                                if clone_name.lower() == 'all':
+
+                                    for clone in self.Clone.UID_CLONE_DB:
+                                        self.Protocol.part(uidornickname=clone.uid, channel=clone_channel_to_part, print_log=False)
+                                        self.Irc.Channel.delete_user_from_channel(clone_channel_to_part, clone.uid)
+
+                                else:
+                                    if self.Clone.exists(clone_name):
+                                        clone_uid = self.Clone.get_uid(clone_name)
+                                        if not clone_uid is None:
+                                            self.Protocol.part(uidornickname=clone_uid, channel=clone_channel_to_part, print_log=False)
+                                            self.Irc.Channel.delete_user_from_channel(clone_channel_to_part, clone_uid)
+
+                            except Exception as err:
+                                self.Logs.error(f'{err}')
+                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part all #channel")
+                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part clone_nickname #channel")
 
                         case 'list':
                             try:
                                 clone_count = len(self.Clone.UID_CLONE_DB)
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :>> Number of connected clones: {clone_count}')
+                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f">> Number of connected clones: {clone_count}")
                                 for clone_name in self.Clone.UID_CLONE_DB:
-                                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :>> Nickname: {clone_name.nickname} | Username: {clone_name.username} | Realname: {clone_name.realname} | Vhost: {clone_name.vhost} | Init: {clone_name.init} | Live: {clone_name.alive} | Connected: {clone_name.connected}')
+                                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, 
+                                                             msg=f">> Nickname: {clone_name.nickname} | Username: {clone_name.username} | Realname: {clone_name.realname} | Vhost: {clone_name.vhost} | UID: {clone_name.uid} | Group: {clone_name.group} | Connected: {clone_name.connected}")
                             except Exception as err:
                                 self.Logs.error(f'{err}')
 
@@ -374,30 +476,36 @@ class Clone():
                             try:
                                 # clone say clone_nickname #channel message
                                 clone_name = str(cmd[2])
-                                clone_channel = str(cmd[3]) if self.Base.Is_Channel(str(cmd[3])) else None
+                                clone_channel = str(cmd[3]) if self.Channel.Is_Channel(str(cmd[3])) else None
 
-                                message = []
-                                for i in range(4, len(cmd)):
-                                    message.append(cmd[i])
-                                final_message = ' '.join(message)
+                                final_message = ' '.join(cmd[4:])
 
                                 if clone_channel is None or not self.Clone.exists(clone_name):
-                                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel message')
+                                    self.Protocol.sendNotice(
+                                        nick_from=dnickname,
+                                        nick_to=fromuser,
+                                        msg=f"/msg {dnickname} clone say [clone_nickname] #channel message"
+                                    )
                                     return None
-                                
+
                                 if self.Clone.exists(clone_name):
-                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {clone_name} :SAY {clone_channel} {final_message}')
+                                    self.Protocol.sendPrivMsg(nick_from=clone_name, msg=final_message, channel=clone_channel)
 
                             except Exception as err:
                                 self.Logs.error(f'{err}')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel message')
+                                self.Protocol.sendNotice(
+                                        nick_from=dnickname,
+                                        nick_to=fromuser,
+                                        msg=f"/msg {dnickname} clone say [clone_nickname] #channel message"
+                                    )
 
                         case _:
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect 6')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill [all | nickname]')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join [all | nickname] #channel')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel [message]')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone list')
+                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone connect NUMBER GROUP_NAME INTERVAL")
+                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill [all | nickname]")
+                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join [all | nickname] #channel")
+                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part [all | nickname] #channel")
+                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone list")
+
         except IndexError as ie:
             self.Logs.error(f'Index Error: {ie}')
         except Exception as err: