def maxClients(self): if "maxClients" in self.cache: return self.cache["maxClients"] err, m = ts3lib.getChannelVariableAsInt( self.schid, self.cid, ts3defines.ChannelPropertiesRare.CHANNEL_FLAG_MAXCLIENTS_UNLIMITED) if err != ts3defines.ERROR_ok: _errprint("Error getting channel maxclientsunlimited flag", err, self.schid, self.cid) return 300 else: if m == 1: self.cache["maxClients"] = -1 return -1 err, m = ts3lib.getChannelVariableAsInt( self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS) if err != ts3defines.ERROR_ok: _errprint("Error getting channel maxclients", err, self.schid, self.cid) return 0 else: self.cache["maxClients"] = m return m
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID): if atype != ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL or menuItemID != 0: return err, clientID = ts3lib.getClientID(schid) err, channelID = ts3lib.getChannelOfClient(schid, clientID) # CHANNEL_NAME err, self.CHANNEL_NAME = ts3lib.getChannelVariableAsString( schid, channelID, ts3defines.ChannelProperties.CHANNEL_NAME) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_NAME, self.CHANNEL_NAME + "_") # CHANNEL_NAME_PHONETIC # err, CHANNEL_NAME_PHONETIC = ts3lib.getChannelVariableAsString(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NAME_PHONETIC) # CHANNEL_TOPIC # err, CHANNEL_TOPIC = ts3lib.getChannelVariableAsString(schid, channelID, ts3defines.ChannelProperties.CHANNEL_TOPIC) # ts3lib.setChannelVariableAsString(schid,0,ts3defines.ChannelProperties.CHANNEL_TOPIC,CHANNEL_TOPIC) # CHANNEL_DESCRIPTION # err, CHANNEL_DESCRIPTION = ts3lib.getChannelVariableAsString(schid, channelID, ts3defines.ChannelProperties.CHANNEL_DESCRIPTION) # ts3lib.setChannelVariableAsString(schid,0,ts3defines.ChannelProperties.CHANNEL_DESCRIPTION,CHANNEL_DESCRIPTION) # CHANNEL_CODEC err, CHANNEL_CODEC = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC) ts3lib.setChannelVariableAsInt( schid, 0, ts3defines.ChannelProperties.CHANNEL_CODEC, CHANNEL_CODEC) # CHANNEL_CODEC_QUALITY err, CHANNEL_CODEC_QUALITY = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC_QUALITY) ts3lib.setChannelVariableAsInt( schid, 0, ts3defines.ChannelProperties.CHANNEL_CODEC_QUALITY, CHANNEL_CODEC_QUALITY) # CHANNEL_MAXCLIENTS err, CHANNEL_MAXCLIENTS = ts3lib.getChannelVariableAsUInt64( schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS) ts3lib.setChannelVariableAsUInt64( schid, 0, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS, CHANNEL_MAXCLIENTS) # CHANNEL_MAXFAMILYCLIENTS err, CHANNEL_MAXFAMILYCLIENTS = ts3lib.getChannelVariableAsUInt64( schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXFAMILYCLIENTS) ts3lib.setChannelVariableAsUInt64( schid, 0, ts3defines.ChannelProperties.CHANNEL_MAXFAMILYCLIENTS, CHANNEL_MAXFAMILYCLIENTS) # CHANNEL_NEEDED_TALK_POWER err, CHANNEL_NEEDED_TALK_POWER = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) ts3lib.setChannelVariableAsInt( schid, 0, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER, CHANNEL_NEEDED_TALK_POWER) # self.returncode = ts3lib.createReturnCode() ts3lib.flushChannelCreation(schid, 0) #, self.returncode)
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moveMessage): if not self.toggle: return try: (error, ownid) = ts3lib.getClientID(schid) if ownid == clientID: (error, ntp) = ts3lib.getChannelVariableAsInt( schid, newChannelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) if self.debug: ts3lib.printMessageToCurrentTab( 'error: {0} | ntp: {1}'.format(error, ntp)) if ntp < 1: return (error, tp) = ts3lib.getClientVariableAsInt( schid, ownid, ts3defines.ClientPropertiesRare.CLIENT_IS_TALKER) if self.debug: ts3lib.printMessageToCurrentTab( 'error: {0} | tp: {1}'.format(error, tp)) if tp: return self.nwmc = QNetworkAccessManager() self.nwmc.connect("finished(QNetworkReply*)", self.jokeReply) self.schid = schid self.nwmc.get( QNetworkRequest( QUrl("http://tambal.azurewebsites.net/joke/random"))) 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): if not self.check: return False if self.toggle: (error, _clid) = ts3lib.getClientID(schid) (error, _cid) = ts3lib.getChannelOfClient(schid, _clid) if clientID == _clid: if channelGroupID == self.sagroup: if self.ownchannels.__contains__(channelID): _t = False else: self.ownchannels.append(channelID) elif channelGroupID == self.smgroup: (error, neededTP) = ts3lib.getChannelVariableAsInt(schid, _cid, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) if neededTP > 0: (error, clients) = ts3lib.getChannelClientList(schid, _cid) for client in clients: if client == _clid: continue (error, _cgid) = ts3lib.getClientVariableAsInt(schid, client, ts3defines.ClientPropertiesRare.CLIENT_CHANNEL_GROUP_ID) if _cgid == self.sagroup: continue (error, uid) = ts3lib.getClientVariableAsString(schid, client, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) if self.InContacts(uid) == 0: ts3lib.requestClientSetIsTalker(schid, client, True) elif channelID == _cid and channelGroupID == self.sbgroup: #(error, uid) = ts3lib.getClientVariableAsString(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) (error, _cid) = ts3lib.getChannelOfClient(schid, clientID) if _cid in self.ownchannels: ts3lib.requestClientKickFromChannel(schid, clientID, "You were banned by \"%s\""%invokerName + (" for \"%s\""%invokerName) if self.reason != "" else "")
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moveMessage): if not self.check: return False if self.toggle: (error, _clid) = ts3lib.getClientID(schid) (error, _cid) = ts3lib.getChannelOfClient(schid, _clid) (error, _cgid) = ts3lib.getClientVariableAsInt( schid, _clid, ts3defines.ClientPropertiesRare.CLIENT_CHANNEL_GROUP_ID) if not clientID == _clid: (error, uid) = ts3lib.getClientVariableAsString( schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER) if oldChannelID == 0: self.checkUser( uid ) # and _cgid == self.smgroup or _cgid == self.sagroup if newChannelID == _cid and _cgid == self.smgroup: (error, neededTP) = ts3lib.getChannelVariableAsInt( schid, _cid, ts3defines.ChannelPropertiesRare. CHANNEL_NEEDED_TALK_POWER) if neededTP > 0: if self.InContacts(uid) == 0: ts3lib.requestClientSetIsTalker( schid, clientID, True)
def subscribe(self, schid, channelID): (error, name) = ts3lib.getChannelVariableAsString( schid, channelID, ts3defines.ChannelProperties.CHANNEL_NAME) (error, pw) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_FLAG_PASSWORD) (error, subscribed) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_FLAG_ARE_SUBSCRIBED) (error, codec) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC) #if self.debug: ts3lib.printMessageToCurrentTab("not pw: {0}".format(not pw)) #if self.debug: ts3lib.printMessageToCurrentTab("any(x in name.lower() for x in self.passwords): {0}".format(any(x in name.lower() for x in self.passwords))) #if self.debug: ts3lib.printMessageToCurrentTab("not any(x in name.lower() for x in self.blacklist): {0}".format(not any(x in name.lower() for x in self.blacklist))) #if self.debug: ts3lib.printMessageToCurrentTab("not codec == ts3defines.CodecType.CODEC_OPUS_MUSIC: {0}".format(not codec == ts3defines.CodecType.CODEC_OPUS_MUSIC)) if pw and any(x in name.lower() for x in self.passwords): if not subscribed: ts3lib.requestChannelSubscribe(schid, [channelID]) if self.debug: ts3lib.printMessageToCurrentTab( "Has PW in name: {0}".format( pw and any(x in name.lower() for x in self.passwords))) elif not pw and not any( x in name.lower() for x in self.blacklist ) and not codec == ts3defines.CodecType.CODEC_OPUS_MUSIC: if not subscribed: ts3lib.requestChannelSubscribe(schid, [channelID]) if self.debug: ts3lib.printMessageToCurrentTab( "no pw, no bl, no music: {0}".format( not pw and not any(x in name.lower() for x in self.blacklist) and not codec == ts3defines.CodecType.CODEC_OPUS_MUSIC)) elif (pw and not any(x in name.lower() for x in self.passwords)) or any( x in name.lower() for x in self.blacklist ) or codec == ts3defines.CodecType.CODEC_OPUS_MUSIC: if subscribed: ts3lib.requestChannelUnsubscribe(schid, [channelID]) if self.debug: ts3lib.printMessageToCurrentTab("unsubbed: {0}".format( (pw and not any(x in name.lower() for x in self.passwords)) or any(x in name.lower() for x in self.blacklist) or codec == ts3defines.CodecType.CODEC_OPUS_MUSIC))
def neededTalkPower(self): (err, tp) = ts3lib.getChannelVariableAsInt( self.schid, self.channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) if err != ts3defines.ERROR_ok: raise ts3Error( "Error getting client channel needed talk power: (%s, %s)" % (err, ts3lib.getErrorMessage(err)[1])) return tp
def TryJoinChannel(self, serverConnectionHandlerID, clientID, wantedChannelID): #verifyChannelPassword(serverConnectionHandlerID, channelID, channelPassword, returnCode) channelHasPassword = ts3lib.getChannelVariableAsInt(serverConnectionHandlerID, wantedChannelID, ts3defines.ChannelProperties.CHANNEL_FLAG_PASSWORD)[1] if channelHasPassword == 1: ts3lib.requestClientMove(serverConnectionHandlerID, clientID, wantedChannelID, self.currentChannelPW) else: ts3lib.requestClientMove(serverConnectionHandlerID, clientID, wantedChannelID, "") self.backup(serverConnectionHandlerID) return
def isSubscribed(schid, cid): (error, subscribed) = ts3lib.getChannelVariableAsInt( schid, cid, ts3defines.ChannelPropertiesRare.CHANNEL_FLAG_ARE_SUBSCRIBED) if PluginHost.cfg.getboolean("general", "verbose"): ts3lib.printMessageToCurrentTab("Channel #{} is {}".format( cid, "[color=red]subscribed" if subscribed else "[color=green]not subscribed")) return bool(subscribed)
def codec(self): if "codec" in self.cache: return self.cache["codec"] err, c = ts3lib.getChannelVariableAsInt( self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_CODEC) if err != ts3defines.ERROR_ok: _errprint("Error getting channel codec", err, self.schid, self.cid) return 0 else: self.cache["codec"] = c return c
def codec(self): if "codec" in self.cache: return self.cache["codec"] err, c = ts3lib.getChannelVariableAsInt(self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_CODEC) if err != ts3defines.ERROR_ok: _errprint("Error getting channel codec", err, self.schid, self.cid) return 0 else: self.cache["codec"] = c return c
def subscribeOpen(self, schid): try: (error, clist) = ts3lib.getChannelList(schid) for c in clist: (error, name) = ts3lib.getChannelVariableAsString( schid, c, ts3defines.ChannelProperties.CHANNEL_NAME) (error, pw) = ts3lib.getChannelVariableAsInt( schid, c, ts3defines.ChannelProperties.CHANNEL_FLAG_PASSWORD) (error, permanent) = ts3lib.getChannelVariableAsInt( schid, c, ts3defines.ChannelProperties.CHANNEL_FLAG_PERMANENT) (error, semiperm) = ts3lib.getChannelVariableAsInt( schid, c, ts3defines.ChannelProperties.CHANNEL_FLAG_SEMI_PERMANENT) (error, codec) = ts3lib.getChannelVariableAsInt( schid, c, ts3defines.ChannelProperties.CHANNEL_CODEC) if not pw and not permanent and not semiperm and not codec == ts3defines.CodecType.CODEC_OPUS_MUSIC and not any( x in name.lower() for x in self.blacklist): ts3lib.requestChannelSubscribe(schid, [c]) #clist.remove(c) self.onlyOpen = True # ts3lib.requestChannelSubscribe(schid, clist) except: try: from traceback import format_exc ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "PyTSon", 0) pass except: try: from traceback import format_exc ts3lib.printMessageToCurrentTab(format_exc()) except: try: from traceback import format_exc print(format_exc()) except: print("Unknown Error")
def isDefault(self): if "isDefault" in self.cache: return self.cache["isDefault"] err, d = ts3lib.getChannelVariableAsInt(self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_FLAG_DEFAULT) if err != ts3defines.ERROR_ok: _errprint("Error getting channel isdefault flag", err, self.schid, self.cid) return False else: self.cache["isDefault"] = d == 1 return d == 1
def neededTalkPower(self): if "neededTalkPower" in self.cache: return self.cache["neededTalkPower"] err, p = ts3lib.getChannelVariableAsInt(self.schid, self.cid, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) if err != ts3defines.ERROR_ok: _errprint("Error getting channel neededtalkpower", err, self.schid, self.cid) return 0 else: self.cache["neededTalkPower"] = p return p
def isPasswordProtected(self): if "isPasswordProtected" in self.cache: return self.cache["isPasswordProtected"] err, p = ts3lib.getChannelVariableAsInt(self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_FLAG_PASSWORD) if err != ts3defines.ERROR_ok: _errprint("Error getting channel ispasswordprotected flag", err, self.schid, self.cid) return False else: self.cache["isPasswordProtected"] = p == 1 return p == 1
def isPermanent(self): if "isPermanent" in self.cache: return self.cache["isPermanent"] err, permanent = ts3lib.getChannelVariableAsInt(self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_FLAG_PERMANENT) if err != ts3defines.ERROR_ok: _errprint("Error getting channel ispermanent flag", err, self.schid, self.cid) return True else: self.cache["isPermanent"] = permanent == 1 return permanent == 1
def isSubscribed(self): if "isSubscribed" in self.cache: return self.cache["isSubscribed"] err, sub = ts3lib.getChannelVariableAsInt(self.schid, self.cid, ts3defines.ChannelPropertiesRare.CHANNEL_FLAG_ARE_SUBSCRIBED) if err != ts3defines.ERROR_ok: _errprint("Error getting channel issubscribed flag", err, self.schid, self.cid) return False else: self.cache["isSubscribed"] = sub == 1 return sub == 1
def neededTalkPower(self): if "neededTalkPower" in self.cache: return self.cache["neededTalkPower"] err, p = ts3lib.getChannelVariableAsInt( self.schid, self.cid, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) if err != ts3defines.ERROR_ok: _errprint("Error getting channel neededtalkpower", err, self.schid, self.cid) return 0 else: self.cache["neededTalkPower"] = p return p
def isPermanent(self): if "isPermanent" in self.cache: return self.cache["isPermanent"] err, permanent = ts3lib.getChannelVariableAsInt( self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_FLAG_PERMANENT) if err != ts3defines.ERROR_ok: _errprint("Error getting channel ispermanent flag", err, self.schid, self.cid) return True else: self.cache["isPermanent"] = permanent == 1 return permanent == 1
def talker(self): (err, id) = ts3lib.getClientID(self.schid) (err, cid) = ts3lib.getChannelOfClient(self.schid, id) (err, ntp) = ts3lib.getChannelVariableAsInt( self.schid, cid, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER) (err, talker) = ts3lib.getClientVariableAsInt( self.schid, id, ts3defines.ClientPropertiesRare.CLIENT_IS_TALKER) ret = True if talker or ntp < 1 else False if self.debug: ts3lib.printMessageToCurrentTab( 'talker() ret: {} | talker: {} | ntp: {} | cid: {} | id: {}'. format(ret, talker, ntp, cid, id)) return ret
def isPasswordProtected(self): if "isPasswordProtected" in self.cache: return self.cache["isPasswordProtected"] err, p = ts3lib.getChannelVariableAsInt( self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_FLAG_PASSWORD) if err != ts3defines.ERROR_ok: _errprint("Error getting channel ispasswordprotected flag", err, self.schid, self.cid) return False else: self.cache["isPasswordProtected"] = p == 1 return p == 1
def isDefault(self): if "isDefault" in self.cache: return self.cache["isDefault"] err, d = ts3lib.getChannelVariableAsInt( self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_FLAG_DEFAULT) if err != ts3defines.ERROR_ok: _errprint("Error getting channel isdefault flag", err, self.schid, self.cid) return False else: self.cache["isDefault"] = d == 1 return d == 1
def isSubscribed(self): if "isSubscribed" in self.cache: return self.cache["isSubscribed"] err, sub = ts3lib.getChannelVariableAsInt( self.schid, self.cid, ts3defines.ChannelPropertiesRare.CHANNEL_FLAG_ARE_SUBSCRIBED) if err != ts3defines.ERROR_ok: _errprint("Error getting channel issubscribed flag", err, self.schid, self.cid) return False else: self.cache["isSubscribed"] = sub == 1 return sub == 1
def subscribe(self, schid, cid): (error, subscribed) = ts3lib.getChannelVariableAsInt(schid, cid, ts3defines.ChannelPropertiesRare.CHANNEL_FLAG_ARE_SUBSCRIBED) if self.debug: ts3lib.printMessageToCurrentTab("==== #{0} ====".format(cid)) ts3lib.printMessageToCurrentTab("Passworded: {0}".format(isPassworded(schid, cid))) ts3lib.printMessageToCurrentTab("PWInName: {0}".format(isPWInName(schid, cid))) ts3lib.printMessageToCurrentTab("Blacklisted: {0}".format(isBlacklisted(schid, cid))) ts3lib.printMessageToCurrentTab("MusicChannel: {0}".format(isMusicChannel(schid, cid))) ts3lib.printMessageToCurrentTab("==== #{0} ====".format(cid)) if not subscribed: if (isPassworded(schid, cid) and isPWInName(schid, cid)) or (not isPassworded(schid, cid) and not isBlacklisted(schid, cid) and not isMusicChannel(schid, cid)): return ts3lib.requestChannelSubscribe(schid, [cid]) elif subscribed: if (isPassworded(schid, cid) and not isPWInName(schid, cid)) or isBlacklisted(schid, cid) or isMusicChannel(schid, cid): return ts3lib.requestChannelUnsubscribe(schid, [cid])
def maxClients(self): if "maxClients" in self.cache: return self.cache["maxClients"] err, m = ts3lib.getChannelVariableAsInt(self.schid, self.cid, ts3defines.ChannelPropertiesRare.CHANNEL_FLAG_MAXCLIENTS_UNLIMITED) if err != ts3defines.ERROR_ok: _errprint("Error getting channel maxclientsunlimited flag", err, self.schid, self.cid) return 300 else: if m == 1: self.cache["maxClients"] = -1 return -1 err, m = ts3lib.getChannelVariableAsInt(self.schid, self.cid, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS) if err != ts3defines.ERROR_ok: _errprint("Error getting channel maxclients", err, self.schid, self.cid) return 0 else: self.cache["maxClients"] = m return m
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber): if newStatus == ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED: (error, uid) = ts3lib.getServerVariableAsString(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER) if uid == self.cfg.get("general", "uid"): # ts3lib.getChannelIDFromChannelNames(serverConnectionHandlerID, channelNameArray) (error, clist) = ts3lib.getChannelList(schid) for c in clist: (error, permanent) = ts3lib.getChannelVariableAsInt(schid, c, ts3defines.ChannelProperties.CHANNEL_FLAG_PERMANENT) if permanent: (error, name) = ts3lib.getChannelVariableAsString(schid, c, ts3defines.ChannelProperties.CHANNEL_NAME) if name.startswith("Support "): self.supchans.append(c) elif name.startswith("[cspacer10]● Support"): self.supmain = c self.cfg.set("general", "enabled", "True") else: self.cfg.set("general", "enabled", "False")
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 fakeChannel(self, schid, channelID): (error, nick) = ts3lib.getChannelVariableAsString( schid, channelID, ts3defines.ChannelProperties.CHANNEL_NAME) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_NAME, nick) (error, phonetic) = ts3lib.getChannelVariableAsString( schid, channelID, ts3defines.ChannelProperties.CHANNEL_NAME_PHONETIC) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_NAME, phonetic) (error, pw) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_PASSWORD) if pw: ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_PASSWORD, ".") (error, topic) = ts3lib.getChannelVariableAsString( schid, channelID, ts3defines.ChannelProperties.CHANNEL_TOPIC) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_TOPIC, topic) (error, description) = ts3lib.getChannelVariableAsString( schid, channelID, ts3defines.ChannelProperties.CHANNEL_DESCRIPTION) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_DESCRIPTION, description) (error, neededtp) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_NEEDED_TALK_POWER) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_NEEDED_TALK_POWER, neededtp) (error, codec) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_CODEC, codec) (error, quality) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC_QUALITY) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_CODEC_QUALITY, quality) (error, latency) = ts3lib.getChannelVariableAsString( schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC_LATENCY_FACTOR) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_CODEC_LATENCY_FACTOR, latency) (error, unencrypted) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC_IS_UNENCRYPTED) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_CODEC_IS_UNENCRYPTED, unencrypted) (error, maxclients) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS, maxclients) (error, maxfamilyclients) = ts3lib.getChannelVariableAsInt( schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXFAMILYCLIENTS) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_MAXFAMILYCLIENTS, maxfamilyclients) (error, iconid) = ts3lib.getChannelVariableAsUint64( schid, channelID, ts3defines.ChannelProperties.CHANNEL_ICON_ID) ts3lib.setChannelVariableAsString( schid, 0, ts3defines.ChannelProperties.CHANNEL_ICON_ID, iconid) (error, _clid) = ts3lib.getClientID(schid)
def getDefaultChannel(self, schid): (error, clist) = ts3lib.getChannelList(schid) for c in clist: (error, default) = ts3lib.getChannelVariableAsInt( schid, c, ts3defines.ChannelProperties.CHANNEL_FLAG_DEFAULT) if default: return c