def onClientMoveEvent(self, schid, clid, oldChannelID, newChannelID,
visibility, moveMessage):
(err, ownID) = ts3lib.getClientID(schid)
if clid == ownID:
return #(err, clids) = ts3lib.getChannelClientList(schid, newChannelID)
(err, ownCID) = ts3lib.getChannelOfClient(schid, ownID)
if newChannelID == 0:
if clid in self.clients: del self.clients[clid]
if ownCID != newChannelID: return
(err, owncgid) = ts3lib.getClientVariable(
schid, ownID,
ts3defines.ClientPropertiesRare.CLIENT_CHANNEL_GROUP_ID)
if owncgid in self.modcgids: return
(err, cgid) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientPropertiesRare.CLIENT_CHANNEL_GROUP_ID)
(err, dcgid) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_CHANNEL_GROUP)
if cgid != dcgid: return
if clid in self.clients:
violations = self.clients[clid]
if len(violations) > self.maxviolations:
if len(violations) > self.maxviolations + 3:
del self.clients[clid][0]
if violations[-1] < violations[-3] + 3:
(err, dbid) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
ts3lib.requestSetClientChannelGroup(
schid, [self.bancgid], [ownCID], [dbid])
return
self.clients[clid].append(time())
else:
self.clients[clid] = []
def clientURL(self,
schid=None,
clid=0,
uid=None,
nickname=None,
encodednick=None):
if schid == None:
try:
schid = ts3lib.getCurrentServerConnectionHandlerID()
except:
pass
if uid == None:
try:
(error, uid) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
except:
pass
if nickname == None:
try:
(error, nickname) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
except:
nickname = uid
if encodednick == None:
try:
encodednick = urlencode(nickname)
except:
pass
return "[url=client://{0}/{1}~{2}]{3}[/url]".format(
clid, uid, encodednick, nickname)
def clientURL(schid=0, clid=0, uid="", nickname="", nickname_encoded=""):
"""
:param schid:
:param clid:
:param uid:
:param nickname:
:param nickname_encoded:
:return:
"""
if not schid:
try:
schid = ts3lib.getCurrentServerConnectionHandlerID()
except:
pass
if not uid:
try:
(error, uid) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
except:
pass
if not nickname:
try:
(error, nickname) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
except:
nickname = uid
if not nickname_encoded:
try:
nickname_encoded = quote_plus(nickname)
except:
nickname_encoded = uid
return '[url=client://{0}/{1}~{2}]"{3}"[/url]'.format(
clid, uid, nickname_encoded, nickname)
def onUpdateClientEvent(self, schid, clid, invokerID, invokerName,
invokerUniqueIdentifier):
(err, ownID) = ts3lib.getClientID(schid)
(err, cid) = ts3lib.getChannelOfClient(schid, clid)
(err, ownCID) = ts3lib.getChannelOfClient(schid, ownID)
(err, talker) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientPropertiesRare.CLIENT_IS_TALKER)
if cid == ownCID and talker: self.last_talk_power = clid
if clid == self.requested:
self.requested = 0
if talker == 1: self.revokeTalkPower(schid, clid, True)
# else: self.revokeTalkPower(schid, clid, False)
(err, cldbid) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
(err, sgids) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS)
loc_sgids = intList(self.cfg.get("restrict", "sgids"))
if set(loc_sgids).issubset(sgids):
for sgid in loc_sgids:
ts3lib.requestServerGroupDelClient(schid, sgid, cldbid)
else:
for sgid in loc_sgids:
ts3lib.requestServerGroupAddClient(schid, sgid, cldbid)
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus != ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
return
if not self.nick_enabled: return
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
(err, name) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME)
_name = choice(self.nicknames)
if "{" in _name:
(err, ownID) = ts3lib.getClientID(schid)
if "{ver}" in _name:
(err, ver) = ts3lib.getClientVariable(
schid, ownID, ts3defines.ClientProperties.CLIENT_VERSION)
_name = _name.replace("{ver}", ver.split(" ")[0])
if "{os}" in _name:
(err, os) = ts3lib.getClientVariable(
schid, ownID, ts3defines.ClientProperties.CLIENT_PLATFORM)
_name = _name.replace("{os}", os)
if "{con}" in _name:
# ts3lib.requestClientVariables(schid, ownID)
(err, os) = ts3lib.getClientVariable(
schid, ownID,
ts3defines.ClientPropertiesRare.CLIENT_TOTALCONNECTIONS)
_name = _name.replace("{con}", str(os))
if _name == name: return
ts3lib.setClientSelfVariableAsString(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME, _name)
ts3lib.flushClientSelfUpdates(schid)
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 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 fakeClient(self, schid, clientID):
(error, _clid) = ts3lib.getClientID(schid)
(error, tnick) = ts3lib.getClientVariable(
schid, clientID, ts3defines.ClientProperties.CLIENT_NICKNAME)
(error, tnickp) = ts3lib.getClientVariable(
schid, clientID,
ts3defines.ClientPropertiesRare.CLIENT_NICKNAME_PHONETIC)
ts3lib.flushClientSelfUpdates(schid)
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 onClientMoveMovedEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moverID, moverName, moverUniqueIdentifier, moveMessage):
(err, ownID) = ts3lib.getClientID(schid)
if clientID != ownID or moverID == ownID: return
(err, sgids) = ts3lib.getClientVariable(schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS)
if set(sgids).isdisjoint(self.whitelistSGIDs): return
(err, uid) = ts3lib.getClientVariable(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if uid in self.whitelistUIDs: return
self.schid=schid;self.clid=ownID;self.cid=oldChannelID
if self.delay >= 0: QTimer.singleShot(self.delay, self.moveBack)
else: self.moveBack()
def clientURL(schid=None, clid=0, uid=None, nickname=None):
if schid == None:
try: schid = ts3lib.getCurrentServerConnectionHandlerID()
except: pass
if uid == None:
try: (error, uid) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
except: pass
if nickname == None:
try: (error, nickname) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
except: nickname = uid
return '[url=client://{0}/{1}]{2}[/url]'.format(clid, uid, nickname)
def onClientMoveMovedEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moverID, moverName, moverUniqueIdentifier, moveMessage):
if moverID == 0 or self.backup is None: return
(err, ownID) = ts3lib.getClientID(schid)
if clientID != ownID or moverID == ownID or moverID == 0: return
(err, sgids) = ts3lib.getClientVariable(schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS)
if not set(sgids).isdisjoint(self.whitelistSGIDs): return
(err, uid) = ts3lib.getClientVariable(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if uid in self.whitelistUIDs: return
self.backup = {"schid": schid, "cid": oldChannelID}
delay = randint(self.delay[0], self.delay[1])
ts3lib.printMessageToCurrentTab("{} {}: Switching back to channel {} in {}ms".format(timestamp(),self.name,channelURL(schid, self.backup["cid"]), delay))# clientURL(schid, self.backup["schid"]),
QTimer.singleShot(delay, self.moveBack)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
try:
url = ""
if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT:
if menuItemID == 1: # Nickname (TSViewer)
url = "http://www.tsviewer.com/index.php?page=search&action=ausgabe_user&nickname=%%CLIENT_NAME_PERCENT_ENCODED%%"
elif menuItemID == 2: # Nickname (GameTracker)
url = "http://www.gametracker.com/search/?search_by=online_offline_player&query=%%CLIENT_NAME_PERCENT_ENCODED%%"
elif menuItemID == 3: # Nickname (TS3Index)
url = "http://ts3index.com/?page=searchclient&nickname=%%CLIENT_NAME_PERCENT_ENCODED%%"
elif menuItemID == 4: # Nickname (Google)
url = "https://www.google.com/search?q=%%CLIENT_NAME_PERCENT_ENCODED%%"
elif menuItemID == 5: # Profil (GameTracker)
url = "http://www.gametracker.com/search/?search_by=profile_username&query=%%CLIENT_NAME_PERCENT_ENCODED%%"
elif menuItemID == 6: # UID (TS3Index)
url = "http://ts3index.com/?page=searchclient&uid=%%CLIENT_UNIQUE_ID%%"
elif menuItemID == 7: # UID (Google)
url = "https://www.google.com/search?q=%%CLIENT_UNIQUE_ID%%"
elif menuItemID == 8: # Besitzer (TSViewer)
url = "http://www.tsviewer.com/index.php?page=search&action=ausgabe&suchbereich=ansprechpartner&suchinhalt=%%CLIENT_NAME_PERCENT_ENCODED%%"
elif menuItemID == 9: # Badges (TS3Index)
url = "https://ts3index.com/?page=searchclient&badges=%%CLIENT_BADGES%%"
else:
return
# payload = {'username':'******', 'password':'******'}
# nickname_encoded = urlencode(nickname, quote_via=quote_plus)
# nickname_encoded = nickname_encoded.replace("+", "%2B").replace("/", "%2F").replace("=", "%3D")
if "%%CLIENT_NAME_PERCENT_ENCODED%%" in url:
(err, nickname) = ts3lib.getClientVariable(
schid, selectedItemID,
ts3defines.ClientProperties.CLIENT_NICKNAME)
url = url.replace("%%CLIENT_NAME_PERCENT_ENCODED%%",
quote_plus(nickname))
if "%%CLIENT_UNIQUE_ID%%" in url:
(err, uid) = ts3lib.getClientVariable(
schid, selectedItemID,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
url = url.replace("%%CLIENT_UNIQUE_ID%%", quote_plus(uid))
if "%%CLIENT_BADGES%%" in url:
(err, badges) = ts3lib.getClientVariable(
schid, selectedItemID,
ts3defines.ClientPropertiesRare.CLIENT_BADGES)
url = url.replace("%%CLIENT_BADGES%%", badges)
else:
return
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"Opening URL: \"{}\"".format(url))
QDesktopServices.openUrl(QUrl(url))
except:
ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR,
"pyTSon", 0)
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID,
visibility, moveMessage):
if not self.enabled: return
if self.schid != schid: return
if not self.mychan: return
(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 clientID in self.waiting and (newChannelID == 0
or newChannelID == self.mychan):
# if newChannelID == self.mychan:
# (err, dbid) = ts3lib.getClientVariable(schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
ts3lib.printMessage(
schid, "{}: [color=orange]Removing channel mod from {}".format(
self.name, self.waiting[clientID]
if newChannelID == 0 else clientURL(schid, clientID)),
ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
ts3lib.requestSetClientChannelGroup(schid, [self.sgid_guest],
[self.mychan],
[self.waiting[clientID]])
del self.waiting[clientID]
return
if newChannelID == 0 or oldChannelID != 0: return
(err, sgids) = ts3lib.getClientVariableAsString(
schid, clientID,
ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS)
if not self.sgid_guest in intList(sgids): return
# TODO Any way to get the cgid in another channel?
(err, uid) = ts3lib.getClientVariable(
schid, clientID,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if getContactStatus(uid) == ContactStatus.BLOCKED:
ts3lib.printMessage(
schid,
"{}: [color=red]Not allowing blocked user {} in your channel.".
format(self.name, clientURL(schid, clientID)),
ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
return
(err, dbid) = ts3lib.getClientVariable(
schid, clientID,
ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
self.waiting[clientID] = dbid
ts3lib.printMessage(
schid,
"{}: [color=green]Found new guest {} giving him channel mod until he's here ;)"
.format(self.name, clientURL(schid, clientID)),
ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
ts3lib.requestSetClientChannelGroup(schid, [self.cgid_mod],
[self.mychan], [dbid])
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype != ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT or menuItemID != 0: return
(err, uid) = ts3lib.getClientVariable(schid, selectedItemID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if err != ts3defines.ERROR_ok: uid = ""
(err, name) = ts3lib.getClientVariable(schid, selectedItemID, ts3defines.ClientProperties.CLIENT_NICKNAME)
if err != ts3defines.ERROR_ok: name = ""
(err, ip) = ts3lib.getConnectionVariable(schid, selectedItemID, ts3defines.ConnectionProperties.CONNECTION_CLIENT_IP)
self.clid = selectedItemID
if err or not ip: ip = "";ts3lib.requestConnectionInfo(schid, selectedItemID); print("requested for", selectedItemID, "on", schid) #TODO: Check
if not self.dlg: self.dlg = BanDialog(self, schid, selectedItemID, uid, name, ip)
else: self.dlg.setup(self, schid, selectedItemID, uid, name, ip)
self.dlg.show()
self.dlg.raise_()
self.dlg.activateWindow()
def clientURL(schid=0, clid=0, uid="", nickname="", nickname_encoded=""):
if schid == 0:
try: schid = ts3lib.getCurrentServerConnectionHandlerID()
except: pass
if uid == "":
try: (error, uid) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
except: pass
if nickname == "":
try: (error, nickname) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
except: nickname = uid
if nickname_encoded == "":
try: (err, nickname_encoded) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
except: nickname_encoded = uid
return '[url=client://{0}/{1}~]"{2}"[/url]'.format(clid, uid, quote_plus(nickname_encoded), nickname)
def checkVars(self, schid, clid):
(err, ownID) = ts3lib.getClientID(schid)
(err, uid) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if ownID == clid:
(err, uid) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if err != ts3defines.ERROR_ok or not uid: uid = False
(err, mytsid) = ts3lib.getClientVariable(schid, clid, 61)
if ownID == clid: (err, mytsid) = ts3lib.getClientList(schid, 61)
if err != ts3defines.ERROR_ok or not mytsid: mytsid = False
(err, ip) = ts3lib.getConnectionVariable(
schid, clid, ts3defines.ConnectionProperties.CONNECTION_CLIENT_IP)
if err != ts3defines.ERROR_ok or not ip: ip = False
return uid, mytsid, ip
def onConnectionInfoEvent(self, schid, clid):
if clid == self.requestedIP:
self.requestedIP = 0
(err, uid) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
(err, ip) = ts3lib.getConnectionVariable(
schid, clid,
ts3defines.ConnectionProperties.CONNECTION_CLIENT_IP)
self.banIP(schid, ip)
self.banUID(schid, uid)
if self.cfg.getint("ban", "duration") != 0:
(err, name) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
self.banName(schid, clid, name)
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID,
visibility, moveMessage):
if self.mychan == 0: return
(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 clientID in self.waiting and (newChannelID == 0
or newChannelID == self.mychan):
ts3lib.printMessageToCurrentTab(
"{} > Removing {} from self.waiting".format(
self.name, clientID))
ts3lib.requestSetClientChannelGroup(schid, [10], [self.mychan],
[self.waiting[clientID]])
del self.waiting[clientID]
return
if newChannelID == 0: return
(err, sgroups) = ts3lib.getClientVariableAsString(
schid, clientID,
ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS)
# (err2, errmsg) = ts3lib.getErrorMessage(err)
if oldChannelID != 0: return
if "10" in sgroups.split(','):
(err, dbid) = ts3lib.getClientVariable(
schid, clientID,
ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
self.waiting[clientID] = dbid
ts3lib.printMessageToCurrentTab(
"{} > #{} Found new guest {} ({}) giving him channel mod until he's here ;)"
.format(self.name, schid, clientURL(schid, clientID), dbid))
ts3lib.requestSetClientChannelGroup(schid, [14], [self.mychan],
[dbid])
return
def getInfo(self, schid, selectedItemID, lists):
i = []
for lst in lists:
for name, var in getItems(lst):
(name, var) = self.preProcessVar(schid, selectedItemID, name,
var, lst)
if var is None: continue
if lst in [
VirtualServerProperties, VirtualServerPropertiesRare
]:
(err, var) = ts3.getServerVariable(schid, var)
elif lst in [ChannelProperties, ChannelPropertiesRare]:
(err,
var) = ts3.getChannelVariable(schid, selectedItemID, var)
elif lst in [ConnectionProperties, ConnectionPropertiesRare]:
(err,
var) = ts3.getConnectionVariable(schid, selectedItemID,
var)
else:
(err, var) = ts3.getClientVariable(schid, selectedItemID,
var)
if err != ERROR_ok or var == "" or var == 0: continue
if isinstance(var, map): var = ", ".join(map(str, var))
if name in ["VIRTUALSERVER_IP", "CONNECTION_CLIENT_IP"]:
i.extend(self.ipInfo(var))
(name, var) = self.postProcessVar(schid, selectedItemID, name,
var, lst)
i.append('{0}: {1}'.format(name, var))
return i
def onClientMoveMovedEvent(self, serverConnectionHandlerID, clientID,
oldChannelID, newChannelID, visibility, moverID,
moverName, moverUID, moveMessage):
(err, myid) = ts3lib.getClientID(serverConnectionHandlerID)
if err != ts3defines.ERROR_ok:
self.log(LogLevel.LogLevel_DEBUG,
"error getting clientid : %s" % err)
(err,
myChannelID) = ts3lib.getChannelOfClient(serverConnectionHandlerID,
myid)
if self.debug:
ts3lib.printMessageToCurrentTab("%s" % clientID)
ts3lib.printMessageToCurrentTab("%s" % myid)
ts3lib.printMessageToCurrentTab("%s" % newChannelID)
ts3lib.printMessageToCurrentTab("%s" % myChannelID)
if ((newChannelID in self.channels or self.enabled)
and newChannelID == myChannelID and clientID != myid
and moverID != myid):
ts3lib.printMessageToCurrentTab("%s" % clientID)
(err, movedUID) = ts3lib.getClientVariable(
serverConnectionHandlerID, clientID,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
ts3lib.printMessageToCurrentTab("%s" % movedUID)
if err != ts3defines.ERROR_ok:
ts3lib.printMessageToCurrentTab("error getting uid: %s" % err)
if ((moverUID in self.uidsMover) or (movedUID in self.uids)):
return 0
#err = ts3lib.requestClientMove(serverConnectionHandlerID, clientID, oldChannelID, "")
if err != ts3defines.ERROR_ok:
ts3lib.printMessageToCurrentTab("error moving: %s" % err)
def onUserLoggingMessageEvent(self, logMessage, logLevel, logChannel, schid, logTime, completeLogString):
if logLevel != ts3defines.LogLevel.LogLevel_DEBUG: return
if schid != ts3lib.getCurrentServerConnectionHandlerID(): return
if logChannel != "VolumeLeveler": return
clid, level = parseMessage(logMessage)
if not clid in self.clients: return
# date = parseTime(logTime)
if self.clients[clid] > self.maxviolations:
self.clients[clid] = 0
client = self.ts3host.getUser(schid, clid)
if not client.server.me.getChannelGroupId() in [self.tabs[schid]["channelModGroup"], client.server.defaultChannelAdminGroup]:
client.mute()
return
(err, country) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientPropertiesRare.CLIENT_COUNTRY)
msg = "[color=red]You exceeded the volume limit {violations} times, your talk power has been revoked!"
if country in ["DE", "AT", "CH"]: msg = "[color=red]Du hast {violations} mal das Lautstaerkelimit von {limit} ueberschritten, deine Talk Power wurde entzogen!"
tp = client.channel.neededTalkPower
if not tp or tp < 1 or tp == "-1":
ts3lib.requestSetClientChannelGroup(schid, [self.tabs[schid]["channelBanGroup"]], [client.channel.channelID], [client.databaseID])
err = ts3lib.requestClientSetIsTalker(schid, clid, False)
if err != ts3defines.ERROR_ok: return
client.sendTextMsg(msg.replace("{violations}",str(self.maxviolations)).replace("{limit}",str(self.maxlevel)))
return
if level > self.maxlevel:
self.clients[clid] += 1
print(clid, level, self.clients[clid])
def getClientCounts(self, schid):
ret = {"total": {}, "visible": {}, "hidden": {}}
visible = self.ts3host.getServer(
schid).users # err, visible = ts3lib.getClientList(schid)
ret["visible"]["users"] = 0
ret["visible"]["queries"] = 0
for user in visible:
(err, ctype) = ts3lib.getClientVariable(
schid, user.clientID,
ts3defines.ClientPropertiesRare.CLIENT_TYPE)
if ctype == ts3defines.ClientType.ClientType_NORMAL:
ret["visible"]["users"] += 1
elif ctype == ts3defines.ClientType.ClientType_SERVERQUERY:
ret["visible"]["queries"] += 1
ret["visible"]["total"] = ret["visible"]["users"] + ret["visible"][
"queries"] # len(visible)
(err, ret["total"]["clients"]) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_CLIENTS_ONLINE)
(err, ret["total"]["queries"]) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_QUERYCLIENTS_ONLINE)
(err, ret["max"]) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_MAXCLIENTS)
ret["hidden"][
"total"] = ret["total"]["clients"] - ret["visible"]["total"]
return ret
def onNewChannelCreatedEvent(self, schid, cid, channelParentID, invokerID, invokerName, invokerUniqueIdentifier):
if not schid in self.targets: return
(err, uid) = ts3lib.getClientVariable(schid, invokerID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if err != ts3defines.ERROR_ok or not uid: return
if PluginHost.cfg.getboolean("general", "verbose"): print(self.name,"onNewChannelCreatedEvent > self.targets[schid]",self.targets[schid],"uid",uid)
if self.targets[schid] != uid: return
self.join(schid, invokerID, cid)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT:
if menuItemID == 0:
(err, uid) = ts3lib.getClientVariable(
schid, selectedItemID,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
ts3lib.banadd(schid, "", "", uid, 0, "")
def onServerGroupClientAddedEvent(self, schid, clid, clientName, clientUniqueIdentity, sgid, invokerClientID, invokerName, invokerUniqueIdentity):
if sgid in self.sgids:
err, description = ts3lib.getClientVariable(schid, clid, ts3defines.ClientPropertiesRare.CLIENT_DESCRIPTION)
print("description:", description)
if re.match(".*\d\d.\d\d \d\d:\d\d:\d\d | .*", description): return
description = "{} {}".format(description, self.description.format(datetime.now(),invokerName=invokerName))
ts3lib.requestClientEditDescription(schid, clid, description)
def setupTable(self):
tbl = self.tbl_variables
tbl.clearContents()
tbl.setRowCount(0)
for i in self.info.getInfoData(self.schid, self.selectedItemID,
self.atype):
k = i.split(': ')[0]
v = i.split(': ')[1]
pos = tbl.rowCount
tbl.insertRow(pos)
tbl.setItem(pos, 0, QTableWidgetItem(k))
tbl.setItem(pos, 1, QTableWidgetItem(v))
name = info.name
if self.atype == PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL:
err, name = ts3lib.getServerVariable(
self.schid, VirtualServerProperties.VIRTUALSERVER_NAME)
elif self.atype == PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL:
err, name = ts3lib.getChannelVariable(
self.schid, self.selectedItemID,
ChannelProperties.CHANNEL_NAME)
elif self.atype == PluginMenuType.PLUGIN_MENU_TYPE_CLIENT:
err, name = ts3lib.getClientVariable(
self.schid, self.selectedItemID,
ClientProperties.CLIENT_NICKNAME)
tbl.sortItems(0)
self.setWindowTitle("{}'s Variables".format(name))
def getClientIDByUID(schid, uid):
(err, clids) = ts3lib.getClientList(schid)
for clid in clids:
(err, _uid) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if uid == _uid: return clid
return False
def onUpdateClientEvent(self, schid, clid, invokerID, invokerName, invokerUniqueIdentifier):
if schid != self.aka[0]: return
if clid != self.aka[1]: return
(err, name) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
if name == self.aka[3]: return
ts3lib.setClientSelfVariableAsString(schid, ts3defines.ClientProperties.CLIENT_NICKNAME, "{} aka {}".format(self.aka[2], name))
ts3lib.flushClientSelfUpdates(schid)
def onUpdateChannelEditedEvent(self, schid, channelID, invokerID, invokerName, invokerUniqueIdentifier):
(err, suid) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
(err, ownID) = ts3lib.getClientID(schid)
if invokerID == ownID:
(err, self.settings["maxclients"]) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS)
(err, self.settings["tp"]) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER)
(err, ownChannel) = ts3lib.getChannelOfClient(schid, ownID)
if channelID != ownChannel: return
(err, invokerChannel) = ts3lib.getChannelOfClient(schid, invokerID)
if invokerChannel == channelID: return
_needed = False
(err, ntp) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER)
if ntp != self.settings["tp"]:
_needed = True
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)
if cmc != self.settings["maxclients"]:
_needed = True
ts3lib.setChannelVariableAsInt(schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS, self.settings["maxclients"])
if _needed:
ts3lib.flushChannelUpdates(schid, channelID)
self.violations[invokerUniqueIdentifier] += 1
if self.violations[invokerUniqueIdentifier] > 2:
(err, dbid) = ts3lib.getClientVariable(schid, ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
ts3lib.requestSetClientChannelGroup(schid, [9], [channelID], [dbid])
del self.violations[invokerUniqueIdentifier]
