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
