def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moveMessage): if not self.askForAvatar: return (err, suid) = ts3lib.getServerVariable( schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER) if suid != self.suid: return if oldChannelID != 0: return (err, uid) = ts3lib.getClientVariable( schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) if getContactStatus(uid) == ContactStatus.BLOCKED: return if uid in self.alreadyAsked: return (err, sgroups) = ts3lib.getClientVariableAsString( schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS) sgroups = sgroups.split(",") if self.ruheGroupID in sgroups: return if set(sgroups).isdisjoint(self.premiumGroupIDs): return (err, myuid) = ts3lib.getClientSelfVariable( schid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) (err, nick) = ts3lib.getClientVariable( schid, clientID, ts3defines.ClientProperties.CLIENT_NICKNAME) ts3lib.requestSendPrivateTextMsg( schid, self.avatarmsg.replace("{nick}", nick).replace("{myuid}", myuid).replace("{uid}", uid), clientID) self.alreadyAsked.append(uid)
def tick(self): for schid in self.servers: if self.hook: sendCommand(self.name, "clientupdate", schid) else: self.retcode = ts3lib.createReturnCode() ts3lib.requestSendPrivateTextMsg(schid, self.text, self.servers[schid]["clid"], self.retcode) self.timer.setInterval(self.getInterval())
def onTextMessageEvent(self, schid, targetMode, toID, fromID, fromName, fromUniqueIdentifier, message, ffIgnored): try: mClientID = ts3.getClientID(schid)[1] if (mClientID == fromID): return messageL = message.lower() parts = message.split(" ") msg = "no " foundNo = False foundU = False for current in parts: if (current == "no"): msg += "no " foundNo = True elif (current == "u"): msg += current foundU = True break else: continue if (not foundNo or not foundU): return if (targetMode == 1): #private msg ts3.requestSendPrivateTextMsg(schid, msg, fromID, "") if (targetMode == 2): #channel msg ts3.requestSendChannelTextMsg(schid, msg, 0, "") except: from traceback import format_exc;ts3.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "PyTSon", 0)
def doBet(self): ts3lib.requestSendPrivateTextMsg(self.schid, "!pay {}".format(self.bet), self.botCLID) ts3lib.requestSendPrivateTextMsg( self.schid, "!set {0}".format(randint(self.minRand, self.maxRand)), self.botCLID)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID): if atype == ts3defines.PluginItemType.PLUGIN_SERVER: if menuItemID == 0: self.dynamicSilence = not self.dynamicSilence ts3lib.printMessageToCurrentTab( "{}{}: DynamicSilence set to [color=orange]{}".format( timestamp(), self.name, self.dynamicSilence)) elif menuItemID == 1: self.askForAvatar = not self.askForAvatar ts3lib.printMessageToCurrentTab( "{}askForAvatar set to [color=orange]{}".format( timestamp(), self.askForAvatar)) if not self.askForAvatar: self.clids = [] self.timer.stop() return (err, clids) = ts3lib.getClientList(schid) for c in clids: ts3lib.requestClientVariables(schid, c) for c in clids: (err, uid) = ts3lib.getClientVariable( schid, c, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) if getContactStatus(uid) == ContactStatus.BLOCKED: continue if uid in self.alreadyAsked: continue (err, sgroups) = ts3lib.getClientVariableAsString( schid, c, ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS) sgroups = sgroups.split(",") if self.ruheGroupID in sgroups: continue if set(sgroups).isdisjoint(self.premiumGroupIDs): continue self.clids.append(c) ts3lib.printMessageToCurrentTab( "{}Asking {} clients for avatar".format( timestamp(), len(self.clids))) self.schid = schid self.timer.start(1000) if atype == ts3defines.PluginItemType.PLUGIN_CHANNEL: ts3lib.requestSendChannelTextMsg(schid, self.steammsg, selectedItemID) elif atype == ts3defines.PluginItemType.PLUGIN_CLIENT: if menuItemID == 0: ts3lib.requestSendPrivateTextMsg(schid, self.steammsg, selectedItemID) elif menuItemID == 1: print(self.aka) if self.aka != (0, 0, "", ""): self.aka = (0, 0, "", "") return realname = inputBox(self.name, "Real name:") if not realname: return (err, name) = ts3lib.getClientVariable( schid, selectedItemID, ts3defines.ClientProperties.CLIENT_NICKNAME) ts3lib.setClientSelfVariableAsString( schid, ts3defines.ClientProperties.CLIENT_NICKNAME, "{} aka {}".format(realname, name)) ts3lib.flushClientSelfUpdates(schid) self.aka = (schid, selectedItemID, realname, name)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID): if menuItemID != 0: return if atype == ts3defines.PluginItemType.PLUGIN_CHANNEL: ts3lib.requestSendChannelTextMsg(schid, self.steammsg, selectedItemID) elif atype == ts3defines.PluginItemType.PLUGIN_CLIENT: ts3lib.requestSendPrivateTextMsg(schid, self.steammsg, selectedItemID)
def tick(self): if not self.askForAvatar or not self.schid or len(self.clids) < 1: self.timer.stop(); return (err, myuid) = ts3lib.getClientSelfVariable(self.schid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) (err, uid) = ts3lib.getClientVariable(self.schid, self.clids[0], ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) (err, nick) = ts3lib.getClientVariable(self.schid, self.clids[0], ts3defines.ClientProperties.CLIENT_NICKNAME) ts3lib.requestSendPrivateTextMsg(self.schid, self.avatarmsg.replace("{nick}", nick).replace("{myuid}", myuid).replace("{uid}", uid), self.clids[0]) self.alreadyAsked.append(uid) del self.clids[0]
def answerMessage(self, schid, targetMode, toID, fromID, message, hideprefix=False): if schid in self.noperms: ts3lib.printMessageToCurrentTab("Insufficient permissions to answer message from {0}".format(fromID)); return message = [message[i:i + 1024] for i in range(0, len(message), 1024)] if targetMode == ts3defines.TextMessageTargetMode.TextMessageTarget_CLIENT: for msg in message: self.returnCode = ts3lib.createReturnCode(); ts3lib.requestSendPrivateTextMsg(schid, msg, fromID, self.returnCode) elif targetMode == ts3defines.TextMessageTargetMode.TextMessageTarget_CHANNEL: if hideprefix: for msg in message: self.returnCode = ts3lib.createReturnCode(); ts3lib.requestSendChannelTextMsg(schid, "{0}".format(msg), toID, self.returnCode) else: for msg in message: self.returnCode = ts3lib.createReturnCode(); ts3lib.requestSendChannelTextMsg(schid, "[url=client://]@[/url]%s: %s" % ( self.clientURL(schid, fromID), msg), toID, self.returnCode)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID): if menuItemID != 0: return if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL: self.printContacts() elif atype == ts3defines.PluginItemType.PLUGIN_CHANNEL: ts3lib.requestSendChannelTextMsg(schid, self.contactStats(), selectedItemID) elif atype == ts3defines.PluginItemType.PLUGIN_CLIENT: ts3lib.requestSendPrivateTextMsg(schid, self.contactStats(), selectedItemID)
def tick(self): for schid in self.servers: if self.hook: sendCommand(self.name, "clientupdate", schid) else: self.retcode = ts3lib.createReturnCode() ts3lib.requestSendPrivateTextMsg(schid, self.text, self.servers[schid]["clid"], self.retcode) interval = self.getInterval() # print(self.name, ">", "Sent", self.text, "for schid", schid, "to clid", self.servers[schid]["clid"], "| new interval:", interval) self.timer.setInterval(interval)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID): if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL: if menuItemID == 0: self.printContacts() elif menuItemID == 1: ts3lib.printMessageToCurrentTab("{}{}".format( timestamp(), self.onlineContacts(schid, False))) elif atype == ts3defines.PluginItemType.PLUGIN_CHANNEL: ts3lib.requestSendChannelTextMsg(schid, self.contactStats(), selectedItemID) elif atype == ts3defines.PluginItemType.PLUGIN_CLIENT: ts3lib.requestSendPrivateTextMsg(schid, self.contactStats(), selectedItemID)
def onClientMoveMovedEvent(self, serverConnectionHandlerID, clientID, oldChannelID, newChannelID, visibility, moverID, moverName, moverUniqueIdentifier, moveMessage): try: if self.cfg['antimove']['enabled'] != 'False' and self.antiMoveStatus != False: if serverConnectionHandlerID != 0: mClientID = ts3lib.getClientID(serverConnectionHandlerID) if mClientID[1] == clientID: self.TryJoinChannel(serverConnectionHandlerID, clientID, oldChannelID) self.backup(serverConnectionHandlerID) ts3lib.playWaveFile(serverConnectionHandlerID, path.join(self.soundPath, "noice.wav")) if self.cfg['antimove']['message'] == 'True': message = 'Stop it ' + moverName + '!' ts3lib.requestSendPrivateTextMsg(serverConnectionHandlerID, message, moverID) except: from traceback import format_exc;ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "PyTSon", 0)
def onIncomingClientQueryEvent(self, schid, commandText): if not self.dynamicSilence: return (err, suid) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER) if suid != self.suid: return if commandText.split(" ", 1)[0] != "notifyclientupdated": return cmd, params = parseCommand(commandText) if len(params) > 0 and "client_nickname" in params: clid = int(params["clid"]) # (err, ownID) = ts3lib.getClientID(schid) # if clid == ownID: return (err, uid) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) if getContactStatus(uid) != ContactStatus.FRIEND: return if not self.dynamicSilenceName in params["client_nickname"].lower(): return ts3lib.requestSendPrivateTextMsg(schid, "Yes, {}-{}?".format(clientURL(schid, clid), choice(["chan","san"])), clid)
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moveMessage): (err, ownID) = ts3lib.getClientID(schid) if clientID != ownID: return (err, needed_tp) = ts3lib.getChannelVariable( schid, newChannelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) if needed_tp >= 0: # (err, hasTP) = ts3lib.getClientSelfVariable(schid, ts3defines.ClientPropertiesRare.CLIENT_IS_TALKER) (err, ownTP) = ts3lib.getClientSelfVariable( schid, ts3defines.ClientPropertiesRare.CLIENT_TALK_POWER) if int(ownTP) < needed_tp: ts3lib.requestSendPrivateTextMsg( schid, self.text, self.servers[schid]["clid"], self.retcode) # ts3lib.requestIsTalker(schid, True, "")
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moveMessage): if not self.enabled: return try: (error, _clid) = ts3lib.getClientID(schid) if not clientID == _clid and oldChannelID == 0: (error, uid) = ts3lib.getClientVariableAsString( schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) if uid in self.uids: ts3lib.requestSendPrivateTextMsg(schid, self.msg, clientID) except: from traceback import format_exc ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "PyTSon", 0)
def onClientChannelGroupChangedEvent(self, schid, channelGroupID, channelID, clientID, invokerClientID, invokerName, invokerUniqueIdentity): (err, suid) = ts3lib.getServerVariable( schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER) # if self.debug: ts3lib.printMessageToCurrentTab('suid != self.suid: {}'.format(suid != self.suid)) if suid != self.suid: return (err, ownID) = ts3lib.getClientID(schid) # if self.debug: ts3lib.printMessageToCurrentTab('clientID != ownID: {}'.format(clientID != ownID)) if clientID != ownID: return # if self.debug: ts3lib.printMessageToCurrentTab('channelGroupID != self.channelAdminGroupID: {}'.format(channelGroupID != self.channelAdminGroupID)) if channelGroupID != self.channelAdminGroupID: return # if self.debug: ts3lib.printMessageToCurrentTab('invokerClientID != 0: {}'.format(invokerClientID != 0)) if invokerClientID == 0: (err, ntp) = ts3lib.getChannelVariable( schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) if not ntp or ntp == 0: ts3lib.setChannelVariableAsInt( schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER, self.settings["tp"]) # (err, cmc) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS) ts3lib.setChannelVariableAsInt( schid, channelID, ts3defines.ChannelPropertiesRare. CHANNEL_FLAG_MAXCLIENTS_UNLIMITED, 0) ts3lib.setChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS, self.settings["maxclients"]) (err, cnp) = ts3lib.getChannelVariable( schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NAME_PHONETIC) if not cnp or cnp == "": ts3lib.setChannelVariableAsString( schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NAME_PHONETIC, "Team | Lounge 1") ts3lib.flushChannelUpdates(schid, channelID) return # clid = ts3lib.getClientIDbyNickname(schid, self.gommeBotNick) # if not clid: ts3lib.printMessage(schid, 'Gomme-Bot not found.', ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER) # (err, uid) = ts3lib.getClientVariable(schid, self.gommeBotID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) # if uid != "serveradmin": return # if self.debug: ts3lib.printMessageToCurrentTab('self.gommeBotID == 0: {}'.format(self.gommeBotID == 0)) if self.gommeBotID == 0: return ts3lib.requestSendPrivateTextMsg(schid, "registriert", self.gommeBotID)
def onClientChannelGroupChangedEvent(self, schid, channelGroupID, channelID, clientID, invokerClientID, invokerName, invokerUniqueIdentity): (err, suid) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER) if suid != self.suid: return (err, ownID) = ts3lib.getClientID(schid) if clientID != ownID: return if channelGroupID != self.channelAdminGroupID: return if invokerClientID == 0: (err, ntp) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) if not ntp or ntp == 0: ts3lib.setChannelVariableAsInt(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER, self.settings["tp"]) ts3lib.setChannelVariableAsInt(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_FLAG_MAXCLIENTS_UNLIMITED, 0) ts3lib.setChannelVariableAsInt(schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS, self.settings["maxclients"]) (err, cnp) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NAME_PHONETIC) if not cnp or cnp == "": ts3lib.setChannelVariableAsString(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NAME_PHONETIC, "Team | Lounge 1") ts3lib.flushChannelUpdates(schid, channelID) if self.gommeBotID < 1: return ts3lib.requestSendPrivateTextMsg(schid, "registriert", self.gommeBotID)
def onClientDisplayNameChanged(self, serverConnectionHandlerID, clientID, displayName, uniqueClientIdentifier): name = displayName (err_desc, desc) = ts3lib.getClientVariableAsString( serverConnectionHandlerID, clientID, ts3defines.ClientPropertiesRare.CLIENT_DESCRIPTION) if err_desc != ts3defines.ERROR_ok: log.error("{} - Error while obtaining client description".format( time.ctime(time.time()))) else: log.info( "{} - Nickname change detected. New nickname: {}, desc: {}". format(time.ctime(time.time()), name, desc)) # if nickname == desc if name == desc: log.info("{} - Client OK. Nickname: {}".format( time.ctime(time.time()), name)) # if desc not set elif desc == "": message = "Your description is empty. Ask server admin to set it" err_msg = ts3lib.requestSendPrivateTextMsg( serverConnectionHandlerID, message, clientID) log.warning( "{} - Client without description. Nickname: {}".format( time.ctime(time.time()), name)) # if name/desc mismatch elif name != desc: err_kick = ts3lib.requestClientKickFromServer( serverConnectionHandlerID, clientID, "Set your nickname as follows: %s" % desc) log.warning( "{} - Nick/desc mismatch - kicking client. Nickname: {}, description: {}" .format(time.ctime(time.time()), name, desc))
def sendCommand(name, cmd, schid=0, silent=True, reverse=False, mode=1): """ Sends a command through TS3Hook. :param mode: See enum: HookMode :param reverse: :param name: :param cmd: :param schid: :param silent: """ if schid == 0: schid = ts3lib.getCurrentServerConnectionHandlerID() if PluginHost.cfg.getboolean("general", "verbose") or not silent: ts3lib.printMessage( schid, '{timestamp} [color=orange]{name}[/color]:[color=white] {prefix}{message}' .format(timestamp=timestamp(), name=name, prefix="-" if reverse else "~", message=cmd), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER) print("mode:", mode) if mode == HookMode.TS3HOOK: cmd = "{}cmd{}".format("-" if reverse else "~", cmd.replace(" ", "~s")) elif mode == HookMode.TSPATCH: cmd = "{}{}".format("-" if reverse else "~", cmd) else: raise SyntaxError("No HookMode specified!") (err, clid) = ts3lib.getClientID(schid) retcode = "" # "TS3Hook:Command:{}".format(ts3lib.createReturnCode(256)) err = ts3lib.requestSendPrivateTextMsg(schid, cmd, clid, retcode) if err != ts3defines.ERROR_ok: ts3lib.requestSendChannelTextMsg(schid, cmd, 0, retcode) if err != ts3defines.ERROR_ok: ts3lib.requestSendServerTextMsg(schid, cmd, retcode)
def onTextMessageEvent(self, schid, targetMode, toID, fromID, fromName, fromUniqueIdentifier, message, ffIgnored): if fromUniqueIdentifier != "serveradmin": return if fromName != self.gommeBotNick: return print(message, self.agreeMSG, message == self.agreeMSG) self.schid = schid self.gommeBotID = fromID if message.endswith(self.msg): QTimer.singleShot(self.delay, self.sendMessage) elif message == self.blockMSG: QTimer.singleShot(self.delay, self.sendMessage) elif message == self.agreeMSG: ts3lib.requestSendPrivateTextMsg(self.schid, "agree", self.gommeBotID) return True elif message in self.ignoreMSG: return True
def onTextMessageEvent(self, schid, targetMode, toID, fromID, fromName, fromUniqueIdentifier, message, ffIgnored): (err, myid) = ts3lib.getClientID(schid) if err == ts3defines.ERROR_ok: #only in private messages if toID == myid: f = self.contactStatus(fromUniqueIdentifier) if f == 0: err = ts3lib.requestSendPrivateTextMsg( schid, "Hello, my friend!", fromID) elif f == 1: err = ts3lib.requestSendPrivateTextMsg( schid, "I don't like you!", fromID) else: err = ts3lib.requestSendPrivateTextMsg( schid, "Do I know you?", fromID)
def onNetworkReply(self, reply): if reply.error() == QNetworkReply.NoError: try: message = str( json.loads(reply.readAll().data().decode('utf-8'))) if self.mode: if self.target == 1: ts3.requestSendPrivateTextMsg(self.schid, message, self.fromID) if self.target == 2: (error, mych) = ts3.getChannelOfClient(self.schid, self.myid) ts3.requestSendChannelTextMsg(self.schid, message, mych) else: ts3.printMessageToCurrentTab(str(message)) except: ts3.printMessageToCurrentTab(format_exc())
def doContactActions(self, schid, clientID): # Own client ID and own channel (error, myid) = ts3.getClientID(schid) (error, mych) = ts3.getChannelOfClient(schid, myid) (error, cch) = ts3.getChannelOfClient(schid, clientID) (error, isDefaultChannel) = ts3.getChannelVariableAsInt(schid, mych, ts3defines.ChannelProperties.CHANNEL_FLAG_DEFAULT) # Only react if client joins my channel and at least one setting is activated if not isDefaultChannel == 1 and cch == mych and not myid == clientID and (self.settings["f_channelgroup"] or self.settings["f_talkpower"] or self.settings["b_channelgroup"] or self.settings["b_kick"]): # Contact status check (error, cuid) = ts3.getClientVariableAsString(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) status = self.contactStatus(cuid) # Only react if friend or blocked joined the channel if status == 0 or status == 1: # blocked if status == 1: # Assign blocked channelgroup if self.settings["b_channelgroup"]: channelgroup = self.setClientChannelGroup(schid, 1, clientID, mych) # kick blocked if self.settings["b_kick"]: ts3.requestClientKickFromChannel(schid, clientID, self.settings["b_kick_message"], self.error_kickFromChannel) (error, new_cch) = ts3.getChannelOfClient(schid, clientID) # Send message to blocked user if kick was valid if not new_cch == mych and self.settings["b_message"]: ts3.requestSendPrivateTextMsg(schid, self.settings["b_message_message"], clientID, self.error_sendMessage) # freinds if status == 0: # Assign friends channelgroup if self.settings["f_channelgroup"]: self.setClientChannelGroup(schid, 0, clientID, mych) # Grant friends talkpower if self.settings["f_talkpower"]: ts3.requestClientSetIsTalker(schid, clientID, True, self.error_setClientTalkpower) # Send message to friends if self.settings["f_message"]: ts3.requestSendPrivateTextMsg(schid, self.settings["f_message_message"], clientID, self.error_sendMessage)
def onUpdateClientEvent(self, schid, clientID, invokerID, invokerName, invokerUniqueIdentifier): if not self.update == clientID: return self.update = 0 (error, connects) = ts3lib.getClientVariableAsUInt64( schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_TOTALCONNECTIONS) (error, uid) = ts3lib.getClientVariableAsString( schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) if self.debug: ts3lib.printMessageToCurrentTab( "error: {0} | connects: {1} | uid: {2}".format( error, connects, uid)) if connects > 1 and not uid == "x63jNGEr/PXnu9l3bFECzMzWfXk=": return (error, suid) = ts3lib.getServerVariableAsString( schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER) (error, country) = ts3lib.getClientVariableAsString( schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_COUNTRY) if self.debug: ts3lib.printMessageToCurrentTab("error: {0} | country: {1}".format( error, country)) msg = self.cfg.get(suid, country, fallback=self.cfg.get(suid, 'US')) if '{nick}' in msg: msg = msg.replace('{nick}', self.clientURL(schid, clientID, uid)) if '{country}' in msg: msg = msg.replace('{country}', country) if '{cid}' in msg: msg = msg.replace('{cid}', clientID) if '{uid}' in msg: msg = msg.replace('{uid}', uid) if '{connects}' in msg: msg = msg.replace('{connects}', connects) msg = [msg[i:i + 1024] for i in range(0, len(msg), 1024)] for message in msg: ts3lib.requestSendPrivateTextMsg(schid, "{0}".format(message), clientID) (error, ownid) = ts3lib.getClientID(schid) (error, _uid) = ts3lib.getClientVariableAsString( schid, ownid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) ts3lib.clientChatClosed(schid, uid, clientID) ts3lib.printMessageToCurrentTab( "Sent client {0} the welcome message for {1}".format( clientID, suid))
def sendMessage(self, schid, targetMode, toID): x = QWidget() clipboard = QApplication.clipboard().text(); _message = QInputDialog.getMultiLineText(x, "Enter long text here", "", clipboard) message = [_message[i:i + self.maxsize] for i in range(0, len(_message), self.maxsize)] if targetMode == ts3defines.TextMessageTargetMode.TextMessageTarget_CHANNEL: for msg in message: error = ts3lib.requestSendChannelTextMsg(schid, "\n"+msg, toID) if not error == ts3defines.ERROR_ok: _t = QMessageBox(QMessageBox.Critical, "Error #%s"%error,"Unable to send message to #%s!"%toID);_t.show();return elif targetMode == ts3defines.TextMessageTargetMode.TextMessageTarget_CLIENT: for msg in message: error = ts3lib.requestSendPrivateTextMsg(schid, "\n"+msg, toID) if not error == ts3defines.ERROR_ok: _t = QMessageBox(QMessageBox.Critical, "Error #%s"%error,"Unable to send message to #%s!"%toID);_t.show();return
def answerMessage(schid: int, targetMode: int, fromID: int, message: str, returnCode: str = "", prefix: bool = True): mode = TextMessageTargetMode if prefix and targetMode == mode.TextMessageTarget_CHANNEL: message = "{}: {}".format( clientURL(schid, fromID, quote=False, mention=True), message) print(message) message = [message[i:i + 900] for i in range(0, len(message), 900)] if targetMode == mode.TextMessageTarget_SERVER: for msg in message: ts3lib.requestSendServerTextMsg(schid, msg, returnCode) elif targetMode == mode.TextMessageTarget_CHANNEL: for msg in message: ts3lib.requestSendChannelTextMsg(schid, msg, 0, returnCode) elif targetMode == mode.TextMessageTarget_CLIENT: for msg in message: ts3lib.requestSendPrivateTextMsg(schid, msg, fromID, returnCode) else: ts3lib.printMessageToCurrentTab("".join(message))
def send(userid, message=None): if not userid: useid, err = me() if err: return err if type(userid) is tuple: if userid[1]: return userid[1] userid = userid[0] if not message: return 'no message' return ts3lib.requestSendPrivateTextMsg(schid(), message, userid)
def onTextMessageEvent(self, schid, targetMode, toID, fromID, fromName, fromUID, message, ffIgnored): (err, myid) = ts3lib.getClientID(schid) if err != ERROR_ok or fromID == myid: return False #only private msgs if targetMode != TextMessageTargetMode.TextMessageTarget_CLIENT: return False #only, if I'm away (err, away) = ts3lib.getClientSelfVariableAsInt( schid, ClientPropertiesRare.CLIENT_AWAY) if err != ERROR_ok or not away: return False #only to friends? is from friend? if self.cfg['general']['onlyfriends'] == "True" and not isFriend( fromUID): return False #only once per conversation? did we already sent him? if self.cfg['general']['onlyonce'] == "True" and ( schid, fromUID) in self.handled: return False if self.cfg['general']['sendaway'] == "True": (err, msg) = ts3lib.getClientSelfVariableAsString( schid, ClientPropertiesRare.CLIENT_AWAY_MESSAGE) else: msg = self.cfg['general']['custommsg'] if msg == "": return False err = ts3lib.requestSendPrivateTextMsg(schid, msg, fromID) if err == ERROR_ok: self.handled.append((schid, fromUID))
def onTextMessageEvent(self, schid, targetMode, toID, fromID, fromName, fromUniqueIdentifier, message, ffIgnored): if message == "!help": msg = "Dostępne komendy: "+", ".join(self.commands) err = ts3lib.requestSendPrivateTextMsg(schid, msg, fromID) elif message[0:5] == "!help" and len(message) > 6: self.helpInfo(schid, fromID, message[6:]) elif message[0:6] == "!mpoke" and fromUniqueIdentifier in self.allow_uid: self.poke_name = message[7:message.index(",")] self.poke_amount = int(message[message.index(",")+1:]) self.from_name = fromName self.from_uid = fromUniqueIdentifier self.sleep_time = 0.1 (err, clist) = ts3lib.getClientList(schid) for key in clist: (err_name, name) = ts3lib.getClientVariableAsString(schid, key, ts3defines.ClientProperties.CLIENT_NICKNAME) if name == self.poke_name: for i in range(0,self.poke_amount): if self.from_uid == "dummy_id_for_some_reasons": err_poke = ts3lib.requestClientPoke(schid, key, "dummy_message_for_some_reasons") else: err_poke = ts3lib.requestClientPoke(schid, key, "") time.sleep(self.sleep_time) elif message == "!raidpoke": (err, groups) = ts3lib.getClientVariableAsString(schid, fromID, ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS) gr = groups.split(",") if any(True for x in groups if x in str(self.wh_gr_list)): (err, clist) = ts3lib.getClientList(schid) for key in clist: err_poke = ts3lib.requestClientPoke(schid, key, "%s mass pokes." % fromName) elif message[0:9] == "!raidpoke" and len(message) > 9: msg = message[message.index(" ")+1:] (err, groups) = ts3lib.getClientVariableAsString(schid, fromID, ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS) gr = groups.split(",") if any(True for x in groups if x in str(self.wh_gr_list)): (err, clist) = ts3lib.getClientList(schid) for key in clist: err_poke = ts3lib.requestClientPoke(schid, key, "%s sends: %s" % (fromName,msg))
def sendBanList(self): ts3lib.requestSendPrivateTextMsg(self.cmdevent.schid, "%s" % self.banlist, self.cmdevent.fromID) self.answerMessage(self.cmdevent.schid, self.cmdevent.targetMode, self.cmdevent.toID, self.cmdevent.fromID, "%s" % self.banlist) self.cmdevent = {"event": "", "returnCode": "", "schid": 0, "targetMode": 4, "toID": 0, "fromID": 0, "params": ""}