def commandToggleRecord(self, schid, targetMode, toID, fromID, params=""):
(error, clid) = ts3lib.getClientID(schid)
(error, recording) = ts3lib.getClientVariableAsInt(schid, clid, ts3defines.ClientProperties.CLIENT_IS_RECORDING)
if not recording:
ts3lib.startVoiceRecording(schid)
elif recording:
ts3lib.stopVoiceRecording(schid)
def onUpdateClientEvent(self, schid, clientID, invokerID, invokerName, invokerUniqueIdentifier):
return
if self.check and self.toggle:
(error, _clid) = ts3lib.getClientID(schid)
if not clientID == _clid:
(error, _tcid) = ts3lib.getChannelOfClient(schid, clientID)
if _tcid in self.ownchannels:
(error, _cgid) = ts3lib.getClientVariableAsInt(schid, _clid, ts3defines.ClientPropertiesRare.CLIENT_CHANNEL_GROUP_ID)
if _cgid in [self.smgroup, self.sagroup]:
if self.checkRecording:
(error, clientRecStatus) = ts3lib.getClientVariableAsInt(schid, clientID, ts3defines.ClientProperties.CLIENT_IS_RECORDING)
if clientRecStatus == 1:
self.reason == "Recording"
_schid = ts3lib.getCurrentschid()
self.requestedC.extend([1])
_dbid = ts3lib.requestClientDBIDfromUID(_schid, invokerUniqueIdentifier)
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 dbInsert(self,
schid,
cid,
clid,
cgid,
dbid=None,
invokerName="",
invokerUID=""):
if PluginHost.cfg.getboolean("general", "verbose"):
print("got clid:", clid)
for v in [schid, cid, clid, cgid]:
if v is None: return
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
uuid = "{}|{}".format(suid, cid)
self.execSQL(
"CREATE TABLE IF NOT EXISTS `{}` (`TIMESTAMP` NUMERIC, `NAME` TEXT, `UID` TEXT, `DBID` NUMERIC UNIQUE, `CGID` NUMERIC, `INVOKERNAME` TEXT, `INVOKERUID` TEXT);"
.format(uuid))
(err, name) = ts3lib.getClientVariableAsString(
schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
(err, uid) = ts3lib.getClientVariableAsString(
schid, clid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if dbid is None:
(err, dbid) = ts3lib.getClientVariableAsInt(
schid, clid,
ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
q = "INSERT OR REPLACE INTO '{}' (TIMESTAMP, NAME, UID, DBID, CGID, INVOKERNAME, INVOKERUID) VALUES ({}, '{}', '{}', {}, {}, '{}', '{}')".format(
uuid, int(time.time()), name, uid, dbid, cgid, invokerName,
invokerUID)
self.execSQL(q)
def isAway(self):
(err, iawa) = ts3lib.getClientVariableAsInt(
self.schid, self.clientID, ts3defines.ClientProperties.CLIENT_AWAY)
if err != ts3defines.ERROR_ok:
raise ts3Error("Error getting client away status: (%s, %s)" %
(err, ts3lib.getErrorMessage(err)[1]))
return iawa
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 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 isTalker(self):
(err, italk) = ts3lib.getClientVariableAsInt(
self.schid, self.clientID,
ts3defines.ClientPropertiesRare.CLIENT_IS_TALKER)
if err != ts3defines.ERROR_ok:
raise ts3Error("Error getting client talker status: (%s, %s)" %
(err, ts3lib.getErrorMessage(err)[1]))
return italk
def isRecording(self):
(err, irec) = ts3lib.getClientVariableAsInt(
self.schid, self.clientID,
ts3defines.ClientProperties.CLIENT_IS_RECORDING)
if err != ts3defines.ERROR_ok:
raise ts3Error("Error getting client recording status: (%s, %s)" %
(err, ts3lib.getErrorMessage(err)[1]))
return irec
def isInputMuted(self):
(err, imute) = ts3lib.getClientVariableAsInt(
self.schid, self.clientID,
ts3defines.ClientProperties.CLIENT_INPUT_MUTED)
if err != ts3defines.ERROR_ok:
raise ts3Error("Error getting client input mute status: (%s, %s)" %
(err, ts3lib.getErrorMessage(err)[1]))
return imute
def talkPower(self):
(err, tpow) = ts3lib.getClientVariableAsInt(
self.schid, self.clientID,
ts3defines.ClientPropertiesRare.CLIENT_TALK_POWER)
if err != ts3defines.ERROR_ok:
self.printLogMessage("Error getting client talkPower: (%s, %s)" %
(err, ts3lib.getErrorMessage(err)[1]))
return tpow
def commandOP(self, schid, targetMode, toID, fromID, params=""):
target = int(params)
(error, dbid) = ts3lib.getClientVariableAsInt(schid, target, ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
(error, chan) = ts3lib.getChannelOfClient(schid, target)
(error, name) = ts3lib.getChannelVariableAsString(schid, chan, ts3defines.ChannelProperties.CHANNEL_NAME)
error = ts3lib.requestSetClientChannelGroup(schid, [11], [chan], [dbid])
if error == ts3defines.ERROR_ok:
_t = "You have been made operator of the channel [url=channelid://{0}]{1}[/url].".format(chan,name)
self.answerMessage(schid, ts3defines.TextMessageTargetMode.TextMessageTarget_CLIENT, toID, target, _t)
def isChannelCommander(self):
(err, iccmd) = ts3lib.getClientVariableAsInt(
self.schid, self.clientID,
ts3defines.ClientPropertiesRare.CLIENT_IS_CHANNEL_COMMANDER)
if err != ts3defines.ERROR_ok:
raise ts3Error(
"Error getting client channel commander status: (%s, %s)" %
(err, ts3lib.getErrorMessage(err)[1]))
return iccmd
def isOutputOnlyMuted(self):
(err, imute) = ts3lib.getClientVariableAsInt(
self.schid, self.clientID,
ts3defines.ClientPropertiesRare.CLIENT_OUTPUTONLY_MUTED)
if err != ts3defines.ERROR_ok:
raise ts3Error(
"Error getting client output only mute status: (%s, %s)" %
(err, ts3lib.getErrorMessage(err)[1]))
return imute
def commandChannelBanMe(self, schid, targetMode, toID, fromID, params=""):
(error, ownID) = ts3lib.getClientID(schid)
if self.cfg.getboolean('general', 'customprefix'): prefix = self.cfg.get('general', 'prefix')
else: prefix = self.clientURL(schid, ownID)
(error, nickname) = ts3lib.getClientVariableAsString(schid, fromID, ts3defines.ClientProperties.CLIENT_NICKNAME)
(error, dbid) = ts3lib.getClientVariableAsInt(schid, fromID, ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
(error, chan) = ts3lib.getChannelOfClient(schid, ownID)
if params == "": params = "Command %scbanme used by %s" % (prefix, nickname)
ts3lib.requestSetClientChannelGroup(schid, [12], [chan], [dbid])
ts3lib.requestClientKickFromChannel(schid, fromID, params)
def onClientKickFromChannelEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, kickerID, kickerName, kickerUniqueIdentifier, kickMessage):
if not self.autoBanOnKick: return False
if self.toggle:
(error, _clid) = ts3lib.getClientID(schid)
if not clientID == _clid:
(error, _cgid) = ts3lib.getClientVariableAsInt(schid, _clid, ts3defines.ClientPropertiesRare.CLIENT_CHANNEL_GROUP_ID)
if _cgid == self.smgroup or _cgid == self.sagroup:
(error, _cid) = ts3lib.getChannelOfClient(schid, _clid)
(error, uid) = ts3lib.getClientVariableAsString(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if oldChannelID == _cid and kickMessage == "": self.checkcurrent = uid;ts3lib.requestClientDBIDfromUID(schid, uid)
def isTalking(self):
if self.server.talkingUsers:
if self in self.server.talkingUsers: return True
else: return False
(err, italk) = ts3lib.getClientVariableAsInt(
self.schid, self.clientID,
ts3defines.ClientProperties.CLIENT_FLAG_TALKING)
if err != ts3defines.ERROR_ok:
raise ts3Error("Error getting client talk status: (%s, %s)" %
(err, ts3lib.getErrorMessage(err)[1]))
return italk
def infoData(self, schid, id, atype):
try:
if atype == ts3defines.PluginItemType.PLUGIN_CHANNEL:
(error, clist) = ts3lib.getChannelClientList(schid, id)
i = []
for c in clist:
(error, clienttype) = ts3lib.getClientVariableAsInt(schid, c, ts3defines.ClientPropertiesRare.CLIENT_TYPE)
if clienttype == ts3defines.ClientType.ClientType_SERVERQUERY:
i.append(self.clientURL(schid,c))
if len(i) < 1: return
else: return i
except: return
def isAway(self):
if "isAway" in self.cache:
return self.cache["isAway"]
err, a = ts3lib.getClientVariableAsInt(
self.schid, self.clid, ts3defines.ClientPropertiesRare.CLIENT_AWAY)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client isaway flag", err, self.schid,
self.clid)
return False
else:
self.cache["isAway"] = a == 1
return a == 1
def onUpdateClientEvent(self, schid, clientID, invokerID, invokerName,
invokerUniqueIdentifier):
if not self.toggle or schid != self.schid: return
(error, cID) = ts3lib.getClientID(self.schid)
if not cID == clientID: return
(error, ownid) = ts3lib.getClientID(schid)
(error, talker) = ts3lib.getClientVariableAsInt(
schid, ownid, ts3defines.ClientPropertiesRare.CLIENT_IS_TALKER)
if self.debug:
ts3lib.printMessageToCurrentTab(
'onUpdateClientEvent talker: {}'.format(talker))
if self.talker(): self.active = False
else: self.active = True
def isRequestingTalkPower(self):
if "isRequestingTalkPower" in self.cache:
return self.cache["isRequestingTalkPower"]
err, r = ts3lib.getClientVariableAsInt(self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_TALK_REQUEST)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client isrequestingtalkpower flag", err,
self.schid, self.clid)
return False
else:
self.cache["isRequestingTalkPower"] = r == 1
return r == 1
def isPrioritySpeaker(self):
if "isPrioritySpeaker" in self.cache:
return self.cache["isPrioritySpeaker"]
err, p = ts3lib.getClientVariableAsInt(self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_IS_PRIORITY_SPEAKER)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client ispriorityspeaker flag", err,
self.schid, self.clid)
return False
else:
self.cache["isPrioritySpeaker"] = p == 1
return p == 1
def isAway(self):
if "isAway" in self.cache:
return self.cache["isAway"]
err, a = ts3lib.getClientVariableAsInt(self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_AWAY)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client isaway flag", err, self.schid,
self.clid)
return False
else:
self.cache["isAway"] = a == 1
return a == 1
def isChannelCommander(self):
if "isChannelCommander" in self.cache:
return self.cache["isChannelCommander"]
err, cc = ts3lib.getClientVariableAsInt(self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_IS_CHANNEL_COMMANDER)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client channelcommander flag", err,
self.schid, self.clid)
return False
else:
self.cache["isChannelCommander"] = cc == 1
return cc == 1
def isRecording(self):
if "isRecording" in self.cache:
return self.cache["isRecording"]
err, rec = ts3lib.getClientVariableAsInt(self.schid, self.clid,
ts3defines.ClientProperties.CLIENT_IS_RECORDING)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client isrecording flag", err, self.schid,
self.clid)
return False
else:
self.cache["isRecording"] = rec == 1
return rec == 1
def talkPower(self):
if "talkPower" in self.cache:
return self.cache["talkPower"]
err, p = ts3lib.getClientVariableAsInt(self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_TALK_POWER)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client talkpower", err, self.schid,
self.clid)
return 0
else:
self.cache["talkPower"] = p
return p
def isTalker(self):
if "isTalker" in self.cache:
return self.cache["isTalker"]
err, t = ts3lib.getClientVariableAsInt(self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_IS_TALKER)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client istalker flag", err, self.schid,
self.clid)
return False
else:
self.cache["isTalker"] = t == 1
return t == 1
def hardwareOutputMuted(self):
if "hardwareOutputMuted" in self.cache:
return self.cache["hardwareOutputMuted"]
err, o = ts3lib.getClientVariableAsInt(self.schid, self.clid,
ts3defines.ClientProperties.CLIENT_OUTPUT_HARDWARE)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client hardwareoutputmuted flag", err,
self.schid, self.clid)
return False
else:
self.cache["hardwareOutputMuted"] = o == 0
return o == 0
def onClientMoveMovedEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moverID, moverName, moverUniqueIdentifier, moveMessage):
try:
(error, ownid) = ts3lib.getClientID(schid)
(error, ownchan) = ts3lib.getChannelOfClient(schid, ownid)
(error, afk) = ts3lib.getClientVariableAsInt(schid, ownid, ts3defines.ClientPropertiesRare.CLIENT_AWAY)
if self.debug: ts3lib.printMessageToCurrentTab("onClientMoveMovedEvent: 1 | insupport: {0} | cursupchan: {1} | oldchan: {2}".format(self.insupport,self.cursupchan, self.oldchan))
if self.debug: ts3lib.printMessageToCurrentTab("{0} {1} {2}".format(ownchan, self.afkchan, afk))
if self.insupport == 0 and moverUniqueIdentifier == self.supbot and newChannelID == self.supchanmain and not ownchan == self.afkchan and not afk:
for c in self.supchans:
(error, clients) = ts3lib.getChannelClientList(schid, c)
if len(clients) > 0: continue
else:
# ts3lib.sendPluginCommand(schid, "S3NDuZ3r", ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER, targetIDs, returnCode)
for ch in self.supchans:
(error, clients) = ts3lib.getChannelClientList(schid, ch)
if clientID in clients: return
ts3lib.requestClientMove(schid, clientID, c, "")
ts3lib.requestClientMove(schid, ownid, c, "")
(error, muted) = ts3lib.getClientVariableAsInt(schid, ownid, ts3defines.ClientProperties.CLIENT_OUTPUT_MUTED)
self.wasmuted = muted
ts3lib.setClientSelfVariableAsInt(schid, ts3defines.ClientProperties.CLIENT_OUTPUT_MUTED, 0);ts3lib.flushClientSelfUpdates(schid)
self.insupport = clientID;self.cursupchan = c;self.oldchan = ownchan
if self.debug: ts3lib.printMessageToCurrentTab("Now in support with client #{0} in channel #{1}".format(clientID, c))
return
ts3lib.printMessageToCurrentTab("No free support channel found for client #{0}! Please try manually.".format(clientID))
elif self.insupport == clientID and oldChannelID == self.cursupchan and moverID == ownid:
if self.wasmuted: ts3lib.setClientSelfVariableAsInt(schid, ts3defines.ClientProperties.CLIENT_OUTPUT_MUTED, 1);ts3lib.flushClientSelfUpdates(schid)
ts3lib.requestClientMove(schid, ownid, self.oldchan, "")
ts3lib.printMessageToCurrentTab("Not longer in support with client #{0} in channel #{1}".format(self.insupport, self.cursupchan))
self.insupport = 0;self.cursupchan = 0;self.oldchan = 0
if self.debug: ts3lib.printMessageToCurrentTab("onClientMoveMovedEvent: 2 | insupport: {0} | cursupchan: {1} | oldchan: {2}".format(self.insupport,self.cursupchan, self.oldchan))
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 inputDeactivated(self):
if "inputDeactivated" in self.cache:
return self.cache["inputDeactivated"]
err, i = ts3lib.getClientVariableAsInt(self.schid, self.clid,
ts3defines.ClientProperties.CLIENT_INPUT_DEACTIVATED)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client inputdeactivated flag", err,
self.schid, self.clid)
return False
else:
self.cache["hardwareOutputMuted"] = i == 1
return i == 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 isRecording(self):
if "isRecording" in self.cache:
return self.cache["isRecording"]
err, rec = ts3lib.getClientVariableAsInt(
self.schid, self.clid,
ts3defines.ClientProperties.CLIENT_IS_RECORDING)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client isrecording flag", err, self.schid,
self.clid)
return False
else:
self.cache["isRecording"] = rec == 1
return rec == 1
def isChannelCommander(self):
if "isChannelCommander" in self.cache:
return self.cache["isChannelCommander"]
err, cc = ts3lib.getClientVariableAsInt(
self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_IS_CHANNEL_COMMANDER)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client channelcommander flag", err,
self.schid, self.clid)
return False
else:
self.cache["isChannelCommander"] = cc == 1
return cc == 1
def isPrioritySpeaker(self):
if "isPrioritySpeaker" in self.cache:
return self.cache["isPrioritySpeaker"]
err, p = ts3lib.getClientVariableAsInt(
self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_IS_PRIORITY_SPEAKER)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client ispriorityspeaker flag", err,
self.schid, self.clid)
return False
else:
self.cache["isPrioritySpeaker"] = p == 1
return p == 1
def isRequestingTalkPower(self):
if "isRequestingTalkPower" in self.cache:
return self.cache["isRequestingTalkPower"]
err, r = ts3lib.getClientVariableAsInt(
self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_TALK_REQUEST)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client isrequestingtalkpower flag", err,
self.schid, self.clid)
return False
else:
self.cache["isRequestingTalkPower"] = r == 1
return r == 1
def onChannelGroupListFinishedEvent(self, schid):
try:
id = self.idByName(self.tmpcgroups,self.cmdevent["params"])
if not id: self.answerMessage(schid, self.cmdevent["targetMode"], self.cmdevent["toID"], self.cmdevent["fromID"], "Failed to find a channelgroup like \"%s\""%self.cmdevent["params"]);return
(error, dbid) = ts3lib.getClientVariableAsInt(schid, self.cmdevent["fromID"], ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
(error, own) = ts3lib.getClientID(schid)
(error, chan) = ts3lib.getChannelOfClient(schid, own)
if self.cfg.getboolean("general", "debug"): ts3lib.printMessageToCurrentTab("dbid: {0} | own: {1} | chan: {2} | id: {3}".format(dbid,own,chan,id))
error = ts3lib.requestSetClientChannelGroup(schid, [id], [chan], [dbid])
if error == ts3defines.ERROR_ok: _t = "Successfully set your channelgroup to #{0}".format(id)
else: _t = "Setting your channelgroup #{0} failed!".format(id)
self.answerMessage(schid, self.cmdevent["targetMode"], self.cmdevent["toID"], self.cmdevent["fromID"], _t)
except: from traceback import format_exc;ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "PyTSon", 0)
self.cmdevent = {"event": "", "returnCode": "", "schid": 0, "targetMode": 4, "toID": 0, "fromID": 0, "params": ""}
def isTalker(self):
if "isTalker" in self.cache:
return self.cache["isTalker"]
err, t = ts3lib.getClientVariableAsInt(
self.schid, self.clid,
ts3defines.ClientPropertiesRare.CLIENT_IS_TALKER)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client istalker flag", err, self.schid,
self.clid)
return False
else:
self.cache["isTalker"] = t == 1
return t == 1
def hardwareOutputMuted(self):
if "hardwareOutputMuted" in self.cache:
return self.cache["hardwareOutputMuted"]
err, o = ts3lib.getClientVariableAsInt(
self.schid, self.clid,
ts3defines.ClientProperties.CLIENT_OUTPUT_HARDWARE)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client hardwareoutputmuted flag", err,
self.schid, self.clid)
return False
else:
self.cache["hardwareOutputMuted"] = o == 0
return o == 0
def inputDeactivated(self):
if "inputDeactivated" in self.cache:
return self.cache["inputDeactivated"]
err, i = ts3lib.getClientVariableAsInt(
self.schid, self.clid,
ts3defines.ClientProperties.CLIENT_INPUT_DEACTIVATED)
if err != ts3defines.ERROR_ok:
_errprint("Error getting client inputdeactivated flag", err,
self.schid, self.clid)
return False
else:
self.cache["hardwareOutputMuted"] = i == 1
return i == 1
