Update vote kick commands

mods/mod_clone.py

@@ -198,7 +198,7 @@ class Clone():
             case 'clone':
                 option = str(cmd[1]).lower()
 
-                if len(option) == 1:
+                if len(command) == 1:
                     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')

mods/mod_votekick.py

@@ -48,7 +48,7 @@ class Votekick():
 
         # Créer les nouvelles commandes du module
         self.commands_level = {
-            0: ['vote_for', 'vote_against'],
+            0: ['vote'],
             1: ['activate', 'deactivate', 'submit', 'vote_stat', 'vote_verdict', 'vote_cancel']
         }
 
@@ -60,6 +60,8 @@ class Votekick():
 
     def __init_module(self) -> None:
 
+        self.Admin = self.Irc.Admin
+
         self.__set_commands(self.commands_level)
         self.__create_tables()
         self.join_saved_channels()
@@ -192,7 +194,9 @@ class Votekick():
 
     def join_saved_channels(self) -> None:
 
-        result = self.Base.db_execute_query("SELECT id, channel FROM votekick_channel")
+        param = {'module_name': self.module_name}
+        result = self.Base.db_execute_query(f"SELECT id, channel_name FROM {self.Config.table_channel} WHERE module_name = :module_name", param)
+
         channels = result.fetchall()
         unixtime = self.Base.get_unixtime()
 
@@ -258,186 +262,213 @@ class Votekick():
         fromchannel = channel
 
         match command:
+            case 'vote':
+                option = str(cmd[1]).lower()
+                match option:
 
-            case 'vote_cancel':
+                    case 'activate':
-                try:
+                        try:
-                    if channel is None:
+                            # vote activate #channel
-                        self.Logs.error(f"The channel is not known, defender can't cancel the vote")
+                            if self.Admin.get_Admin(fromuser) is None:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :You need to specify the channel => /msg {dnickname} vote_cancel #channel')
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
+                                return None
 
-                    for vote in self.VOTE_CHANNEL_DB:
+                            sentchannel = str(cmd[2]).lower() if self.Base.Is_Channel(str(cmd[2]).lower()) else None
-                        if vote.channel_name == channel:
+                            if sentchannel is None:
-                            self.init_vote_system(channel)
+                                self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The correct command is {self.Config.SERVICE_PREFIX}{command} {option} #CHANNEL")
-                            self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote system re-initiated')
 
-                except IndexError as ke:
+                            self.insert_vote_channel(
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote_cancel #channel')
+                                self.VoteChannelModel(
-                    self.Logs.error(f'Index Error: {ke}')
+                                    channel_name=sentchannel,
+                                    target_user='',
+                                    voter_users=[],
+                                    vote_for=0,
+                                    vote_against=0
+                                    )
+                                )
 
-            case 'vote_for':
+                            self.Base.db_query_channel('add', self.module_name, sentchannel)
-                try:
-                    # vote_for
-                    channel = fromchannel
-                    for chan in self.VOTE_CHANNEL_DB:
-                        if chan.channel_name == channel:
-                            if fromuser in chan.voter_users:
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :You already submitted a vote')
-                            else:
-                                chan.vote_for += 1
-                                chan.voter_users.append(fromuser)
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote recorded, thank you')
 
-                except KeyError as ke:
+                            self.Irc.send2socket(f":{dnickname} JOIN {sentchannel}")
-                    self.Logs.error(f'Key Error: {ke}')
+                            self.Irc.send2socket(f":{dnickname} SAMODE {sentchannel} +o {dnickname}")
-                except IndexError as ie:
+                            self.Irc.send2socket(f":{dnickname} PRIVMSG {sentchannel} :You can now use !submit <nickname> to decide if he will stay or not on this channel ")
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote_cancel #channel')
+                        except Exception as err:
-                    self.Logs.error(f'Index Error: {ie}')
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option} #channel')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option} #welcome')
 
-            case 'vote_against':
+                    case 'deactivate':
-                try:
+                        try:
-                    # vote_against
+                            # vote deactivate #channel
-                    channel = fromchannel
+                            if self.Admin.get_Admin(fromuser) is None:
-                    for chan in self.VOTE_CHANNEL_DB:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
-                        if chan.channel_name == channel:
+                                return None
-                            if fromuser in chan.voter_users:
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :You already submitted a vote')
-                            else:
-                                chan.vote_against += 1
-                                chan.voter_users.append(fromuser)
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote recorded, thank you')
 
-                except KeyError as ke:
+                            sentchannel = str(cmd[2]).lower() if self.Base.Is_Channel(str(cmd[2]).lower()) else None
-                    self.Logs.error(f'Key Error: {ke}')
+                            if sentchannel is None:
+                                self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The correct command is {self.Config.SERVICE_PREFIX}{command} {option} #CHANNEL")
 
-            case 'vote_stat':
+                            self.Irc.send2socket(f":{dnickname} SAMODE {sentchannel} -o {dnickname}")
-                try:
+                            self.Irc.send2socket(f":{dnickname} PART {sentchannel}")
-                    # channel = str(fullcmd[2]).lower()
-                    for chan in self.VOTE_CHANNEL_DB:
-                        if chan.channel_name == channel:
-                            self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Channel: {chan.channel_name} | Target: {self.User.get_nickname(chan.target_user)} | For: {chan.vote_for} | Against: {chan.vote_against} | Number of voters: {str(len(chan.voter_users))}')
 
-                except KeyError as ke:
+                            for chan in self.VOTE_CHANNEL_DB:
-                    self.Logs.error(f'Key Error: {ke}')
+                                if chan.channel_name == sentchannel:
+                                    self.VOTE_CHANNEL_DB.remove(chan)
+                                    self.Base.db_query_channel('del', self.module_name, chan.channel_name)
 
-            case 'vote_verdict':
+                            self.Logs.debug(f"The Channel {sentchannel} has been deactivated from the vote system")
-                try:
+                        except Exception as err:
-                    # channel = str(fullcmd[2]).lower()
+                            self.Logs.error(f'{err}')
-                    for chan in self.VOTE_CHANNEL_DB:
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option} #channel')
-                        if chan.channel_name == channel:
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option} #welcome')
-                            target_user = self.User.get_nickname(chan.target_user)
-                            if chan.vote_for > chan.vote_against:
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll be kicked from the channel')
-                                self.Irc.send2socket(f":{dnickname} KICK {channel} {target_user} Following the vote, you are not welcome in {channel}")
-                            elif chan.vote_for <= chan.vote_against:
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel')
 
-                            # Init the system
+                    case '+':
-                            if self.init_vote_system(channel):
+                        try:
-                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :System vote re initiated')
+                            # vote +
+                            channel = fromchannel
+                            for chan in self.VOTE_CHANNEL_DB:
+                                if chan.channel_name == channel:
+                                    if fromuser in chan.voter_users:
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :You already submitted a vote')
+                                    else:
+                                        chan.vote_for += 1
+                                        chan.voter_users.append(fromuser)
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote recorded, thank you')
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option}')
 
-                except KeyError as ke:
+                    case '-':
-                    self.Logs.error(f'Key Error: {ke}')
+                        try:
+                            # vote -
+                            channel = fromchannel
+                            for chan in self.VOTE_CHANNEL_DB:
+                                if chan.channel_name == channel:
+                                    if fromuser in chan.voter_users:
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :You already submitted a vote')
+                                    else:
+                                        chan.vote_against += 1
+                                        chan.voter_users.append(fromuser)
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote recorded, thank you')
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option}')
 
-            case 'submit':
+                    case 'cancel':
-                # submit nickname
+                        try:
-                try:
+                            # vote cancel
-                    nickname_submitted = cmd[1]
+                            if self.Admin.get_Admin(fromuser) is None:
-                    # channel = str(fullcmd[2]).lower()
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
-                    uid_submitted = self.User.get_uid(nickname_submitted)
+                                return None
-                    user_submitted = self.User.get_User(nickname_submitted)
 
-                    # check if there is an ongoing vote
+                            if channel is None:
-                    if self.is_vote_ongoing(channel):
+                                self.Logs.error(f"The channel is not known, defender can't cancel the vote")
-                        for vote in self.VOTE_CHANNEL_DB:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :You need to specify the channel => /msg {dnickname} vote_cancel #channel')
-                            if vote.channel_name == channel:
-                                ongoing_user = self.User.get_nickname(vote.target_user)
 
-                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :There is an ongoing vote on {ongoing_user}')
+                            for vote in self.VOTE_CHANNEL_DB:
-                        return False
+                                if vote.channel_name == channel:
+                                    self.init_vote_system(channel)
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Vote system re-initiated')
 
-                    # check if the user exist
+                        except Exception as err:
-                    if user_submitted is None:
+                            self.Logs.error(f'{err}')
-                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This nickname <{nickname_submitted}> do not exist')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option}')
-                        return False
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option}')
 
-                    uid_cleaned = self.Base.clean_uid(uid_submitted)
+                    case 'status':
-                    ChannelInfo = self.Channel.get_Channel(channel)
+                        try:
-                    if ChannelInfo is None:
+                            # vote status
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :This channel [{channel}] do not exist in the Channel Object')
+                            for chan in self.VOTE_CHANNEL_DB:
-                        return False
+                                if chan.channel_name == channel:
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :Channel: {chan.channel_name} | Target: {self.User.get_nickname(chan.target_user)} | For: {chan.vote_for} | Against: {chan.vote_against} | Number of voters: {str(len(chan.voter_users))}')
 
-                    clean_uids_in_channel: list = []
+                        except Exception as err:
-                    for uid in ChannelInfo.uids:
+                            self.Logs.error(f'{err}')
-                        clean_uids_in_channel.append(self.Base.clean_uid(uid))
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option}')
 
-                    if not uid_cleaned in clean_uids_in_channel:
+                    case 'submit':
-                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This nickname <{nickname_submitted}> is not available in this channel')
+                        try:
-                        return False
+                            # vote submit nickname
+                            if self.Admin.get_Admin(fromuser) is None:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
+                                return None
 
-                    # check if Ircop or Service or Bot
+                            nickname_submitted = cmd[2]
-                    pattern = fr'[o|B|S]'
+                            uid_submitted = self.User.get_uid(nickname_submitted)
-                    operator_user = re.findall(pattern, user_submitted.umodes)
+                            user_submitted = self.User.get_User(nickname_submitted)
-                    if operator_user:
-                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :You cant vote for this user ! he/she is protected')
-                        return False
 
-                    for chan in self.VOTE_CHANNEL_DB:
+                            # check if there is an ongoing vote
-                        if chan.channel_name == channel:
+                            if self.is_vote_ongoing(channel):
-                            chan.target_user = self.User.get_uid(nickname_submitted)
+                                for vote in self.VOTE_CHANNEL_DB:
+                                    if vote.channel_name == channel:
+                                        ongoing_user = self.User.get_nickname(vote.target_user)
 
-                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :{nickname_submitted} has been targeted for a vote')
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :There is an ongoing vote on {ongoing_user}')
+                                return False
 
-                    self.Base.create_timer(60, self.timer_vote_verdict, (channel, ))
+                            # check if the user exist
-                    self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This vote will end after 60 secondes')
+                            if user_submitted is None:
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This nickname <{nickname_submitted}> do not exist')
+                                return False
 
-                except KeyError as ke:
+                            uid_cleaned = self.Base.clean_uid(uid_submitted)
-                    self.Logs.error(f'Key Error: {ke}')
+                            ChannelInfo = self.Channel.get_Channel(channel)
-                except TypeError as te:
+                            if ChannelInfo is None:
-                    self.Logs.error(te)
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :This channel [{channel}] do not exist in the Channel Object')
+                                return False
 
-            case 'activate':
+                            clean_uids_in_channel: list = []
-                try:
+                            for uid in ChannelInfo.uids:
-                    # activate #channel
+                                clean_uids_in_channel.append(self.Base.clean_uid(uid))
-                    sentchannel = str(cmd[1]).lower() if self.Base.Is_Channel(str(cmd[1]).lower()) else None
-                    if sentchannel is None:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The correct command is {self.Config.SERVICE_PREFIX}ACTIVATE #CHANNEL")
 
-                    self.insert_vote_channel(
+                            if not uid_cleaned in clean_uids_in_channel:
-                        self.VoteChannelModel(
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This nickname <{nickname_submitted}> is not available in this channel')
-                            channel_name=sentchannel,
+                                return False
-                            target_user='',
-                            voter_users=[],
-                            vote_for=0,
-                            vote_against=0
-                            )
-                        )
 
-                    self.Base.db_query_channel('add', self.module_name, sentchannel)
+                            # check if Ircop or Service or Bot
+                            pattern = fr'[o|B|S]'
+                            operator_user = re.findall(pattern, user_submitted.umodes)
+                            if operator_user:
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :You cant vote for this user ! he/she is protected')
+                                return False
 
-                    self.Irc.send2socket(f":{dnickname} JOIN {sentchannel}")
+                            for chan in self.VOTE_CHANNEL_DB:
-                    self.Irc.send2socket(f":{dnickname} SAMODE {sentchannel} +o {dnickname}")
+                                if chan.channel_name == channel:
-                    self.Irc.send2socket(f":{dnickname} PRIVMSG {sentchannel} :You can now use !submit <nickname> to decide if he will stay or not on this channel ")
+                                    chan.target_user = self.User.get_uid(nickname_submitted)
 
-                except KeyError as ke:
+                            self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :{nickname_submitted} has been targeted for a vote')
-                    self.Logs.error(f"Key Error : {ke}")
 
-            case 'deactivate':
+                            self.Base.create_timer(60, self.timer_vote_verdict, (channel, ))
-                try:
+                            self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :This vote will end after 60 secondes')
-                    # deactivate #channel
-                    sentchannel = str(cmd[1]).lower() if self.Base.Is_Channel(str(cmd[1]).lower()) else None
-                    if sentchannel is None:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The correct command is {self.Config.SERVICE_PREFIX}DEACTIVATE #CHANNEL")
 
-                    self.Irc.send2socket(f":{dnickname} SAMODE {sentchannel} -o {dnickname}")
+                        except Exception as err:
-                    self.Irc.send2socket(f":{dnickname} PART {sentchannel}")
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option} nickname')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option} adator')
 
-                    for chan in self.VOTE_CHANNEL_DB:
+                    case 'verdict':
-                        if chan.channel_name == sentchannel:
+                        try:
-                            self.VOTE_CHANNEL_DB.remove(chan)
+                            # vote verdict
-                            self.Base.db_query_channel('del', self.module_name, chan.channel_name)
+                            if self.Admin.get_Admin(fromuser) is None:
-                            # self.db_delete_vote_channel(chan.channel_name)
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Your are not allowed to execute this command')
+                                return None
 
-                    self.Logs.debug(f"The Channel {sentchannel} has been deactivated from the vote system")
+                            for chan in self.VOTE_CHANNEL_DB:
+                                if chan.channel_name == channel:
+                                    target_user = self.User.get_nickname(chan.target_user)
+                                    if chan.vote_for > chan.vote_against:
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll be kicked from the channel')
+                                        self.Irc.send2socket(f":{dnickname} KICK {channel} {target_user} Following the vote, you are not welcome in {channel}")
+                                    elif chan.vote_for <= chan.vote_against:
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :User {self.Config.CONFIG_COLOR["gras"]}{target_user}{self.Config.CONFIG_COLOR["nogc"]} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel')
                                     
-                except KeyError as ke:
+                                    # Init the system
-                    self.Logs.error(f"Key Error : {ke}")
+                                    if self.init_vote_system(channel):
+                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {channel} :System vote re initiated')
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option}')