def onServerUpdatedEvent(self, schid):
(err, cmdblock) = ts3lib.getServerVariable(schid, VirtualServerPropertiesRare.VIRTUALSERVER_ANTIFLOOD_POINTS_NEEDED_COMMAND_BLOCK)
(err, ipblock) = ts3lib.getServerVariable(schid, VirtualServerPropertiesRare.VIRTUALSERVER_ANTIFLOOD_POINTS_NEEDED_IP_BLOCK)
(err, afreduce) = ts3lib.getServerVariable(schid, VirtualServerPropertiesRare.VIRTUALSERVER_ANTIFLOOD_POINTS_TICK_REDUCE)
ts3lib.logMessage("schid = {0} | err = {1} | afreduce = {2} | cmdblock = {3} | ipblock = {4} | verify_antiflood_points = {5}".format(schid, err, afreduce, cmdblock, ipblock, self.verify_antiflood_points), LogLevel.LogLevel_INFO, "pyTSon", 0)
self.interval = round(1000/((afreduce/self.verify_antiflood_points)))
ts3lib.logMessage("Set interval to {0}".format(self.interval), LogLevel.LogLevel_INFO, "pyTSon", 0)
def setCustomBadges(self):
# try:
if self.mode == HookMode.NONE: return
overwolf = self.cfg.getboolean('general', 'overwolf')
badges = self.cfg.get('general', 'badges').split(",")
# if len(badges) > 0: badges += ['0c4u2snt-ao1m-7b5a-d0gq-e3s3shceript']
(err, schids) = ts3lib.getServerConnectionHandlerList()
reg = compile('3(?:\.\d+)* \[Build: \d+\]')
for schid in schids:
_badges = badges
err, ver = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_VERSION)
err, platform = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_PLATFORM)
if getServerType(schid, reg) in [
ServerInstanceType.TEASPEAK, ServerInstanceType.UNKNOWN
]:
_badges = [x for x in badges if not x in self.extbadges][:3]
_badges = buildBadges(_badges, overwolf)
sendCommand(name=self.name,
cmd=_badges,
schid=schid,
mode=self.mode)
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 processCommand(self, schid, command):
clients = 1
try:
clients = int(command)
except:
pass
self.clients = []
# (err, clid) = ts3lib.getClientID(schid)
# (err, cid) = ts3lib.getChannelOfClient(schid, clid)
(err, clids) = ts3lib.getClientList(schid)
self.clients.extend(clids)
e, self.sgroup = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_SERVER_GROUP)
e, acg = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_CHANNEL_GROUP)
e, dcg = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_CHANNEL_ADMIN_GROUP)
self.cgroups = [acg, dcg]
timestamp, ret, badges = loadBadges()
self.badges = []
for badge in ret:
self.badges.append(badge)
if clients > 10:
self.i = 1
self.schid = schid
self.c = clients + 1
self.timer.start(2)
else:
for i in range(clients):
self.addClient(schid)
i += 1
return True
def setCustomBadges(self):
try:
overwolf = self.cfg.getboolean('general', 'overwolf')
badges = self.cfg.get('general', 'badges').split(",")
# if len(badges) > 0: badges += ['0c4u2snt-ao1m-7b5a-d0gq-e3s3shceript']
(err, schids) = ts3lib.getServerConnectionHandlerList()
reg = compile('3(?:\.\d+)* \[Build: \d+\]')
for schid in schids:
_badges = badges
err, ver = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_VERSION)
err, platform = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_PLATFORM)
if getServerType(schid, reg) in [
ServerInstanceType.TEASPEAK, ServerInstanceType.UNKNOWN
]:
_badges = [x for x in badges
if not x in self.extbadges][:3]
_badges = buildBadges(_badges, overwolf)
sendCommand(self.name, _badges, schid)
except:
ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR,
"pyTSon", 0)
def updateChannel(self, schid, ownID=0, ownCID=0):
if not ownID: (err, ownID) = ts3lib.getClientID(schid)
if not ownCID: (err, ownCID) = ts3lib.getChannelOfClient(schid, ownID)
(err, cname) = ts3lib.getChannelVariable(
schid, ownCID, ts3defines.ChannelProperties.CHANNEL_NAME)
name = re.sub(r'^\[[crl\*]spacer(.*)?\]',
'',
cname,
flags=re.IGNORECASE | re.UNICODE)
from unidecode import unidecode
self.activity["details"] = unidecode(name)
"""
clients = len(ts3lib.getChannelClientList(schid, ownCID)[1])
# (err, clients) = ts3lib.getChannelVariable(schid, ts3defines.ChannelPropertiesRare.)
(err, cmax) = ts3lib.getChannelVariable(schid, ownCID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS)
if cmax >= clients:
self.activity["party"]["size"] = [clients, cmax]
else:
"""
(err, smax) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_MAXCLIENTS)
(err, clients) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_CLIENTS_ONLINE)
# clients = len(ts3lib.getClientList(schid)[1])
self.activity["party"] = {"size": [clients, smax]}
(err, ip) = ts3lib.getConnectionVariable(
schid, ownID, ts3defines.ConnectionProperties.CONNECTION_SERVER_IP)
(err, port) = ts3lib.getConnectionVariable(
schid, ownID,
ts3defines.ConnectionProperties.CONNECTION_SERVER_PORT)
self.activity["secrets"] = {
"join": "ts3server://{}?port={}&cid={}".format(ip, port, ownCID)
}
self.update = True
def onServerUpdatedEvent(self, schid):
return # TODO: Check
if not self.requestedRVars: return
self.requestedRVars = False
(err, dcgid) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerPropertiesRare.VIRTUALSERVER_DEFAULT_CHANNEL_GROUP)
(err, acgid) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerPropertiesRare.VIRTUALSERVER_DEFAULT_CHANNEL_ADMIN_GROUP)
self.cgroups[schid]["default"] = dcgid;self.cgroups[schid]["admin"] = acgid
if PluginHost.cfg.getboolean("general", "verbose"): print(self.name, ">", "new default channel groups for #", schid, "default:", dcgid, "admin:", acgid)
def onHotkeyOrCommandEvent(self, keyword, schid=0):
if not schid: schid = ts3lib.getCurrentServerConnectionHandlerID()
# (err, status) = ts3lib.getConnectionStatus(schid)
# if status != ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED: return
arguments = []
if keyword == "yatqa_start": pass
elif keyword == "yatqa_connect_current":
(err, ownID) = ts3lib.getClientID(schid)
(err, ip) = ts3lib.getConnectionVariable(
schid, ownID,
ts3defines.ConnectionProperties.CONNECTION_SERVER_IP)
(err, port) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerPropertiesRare.VIRTUALSERVER_PORT)
title = ("{} > {}".format(self.name, ip))
qport = inputInt(title, "Query Port:", 10011, 1, 65535)
name = inputBox(title, "Query Login Name:", "serveradmin")
pw = inputBox(
title, "Query Login Password:"******"")
args = ["-c", ip, qport]
if name and pw: args.extend([name, pw, port])
else: args.append(port)
self.yatqa.setArguments(
args) # IP Query_Port [User Pass] [Voice_Port]
elif keyword == "yatqa_stats_current":
(err, ownID) = ts3lib.getClientID(schid)
(err, ip) = ts3lib.getConnectionVariable(
schid, ownID,
ts3defines.ConnectionProperties.CONNECTION_SERVER_IP)
(err, port) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerPropertiesRare.VIRTUALSERVER_PORT)
self.yatqa.setArguments(["-s", ip, port]) # IP
elif keyword == "yatqa_blacklist_current":
(err, ownID) = ts3lib.getClientID(schid)
(err, ip) = ts3lib.getConnectionVariable(
schid, ownID,
ts3defines.ConnectionProperties.CONNECTION_SERVER_IP)
self.yatqa.setArguments(["-b", ip]) # IP
elif keyword == "yatqa_lookup_dns":
(err, host, port, pw) = ts3lib.getServerConnectInfo(schid)
self.yatqa.setArguments(["-d", host])
elif keyword == "yatqa_browse_icons":
(err, suid) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerProperties.
VIRTUALSERVER_UNIQUE_IDENTIFIER)
self.yatqa.setArguments(["-i", suid])
elif keyword == "yatqa_permission_editor":
self.yatqa.setArguments(["-p"])
elif keyword == "yatqa_connect_default":
self.yatqa.setArguments(["-a"])
else:
return False
if PluginHost.cfg.getboolean("general", "verbose"):
print(self.bin, self.yatqa.arguments())
self.yatqa.start()
return True
def getAntiFloodSettings(schid):
"""
:param schid:
:return:
"""
(err, cmdblock) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerPropertiesRare.VIRTUALSERVER_ANTIFLOOD_POINTS_NEEDED_COMMAND_BLOCK)
(err, ipblock) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerPropertiesRare.VIRTUALSERVER_ANTIFLOOD_POINTS_NEEDED_IP_BLOCK)
(err, afreduce) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerPropertiesRare.VIRTUALSERVER_ANTIFLOOD_POINTS_TICK_REDUCE)
return err, cmdblock, ipblock, afreduce
def getServerType(schid, pattern=None):
err, ver = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_VERSION)
if err != ts3defines.ERROR_ok or not ver: return ServerInstanceType.UNKNOWN
err, platform = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_PLATFORM)
if err != ts3defines.ERROR_ok or not platform: return ServerInstanceType.UNKNOWN
valid_platform = platform in ["Windows", "Linux", "OS X", "FreeBSD"]
if pattern is not None: valid_version = pattern.match(ver)
else: valid_version = match('3(?:\.\d+)* \[Build: \d+\]', ver)
if valid_version and valid_platform: return ServerInstanceType.VANILLA
elif "teaspeak" in ver.lower(): return ServerInstanceType.TEASPEAK
else: return ServerInstanceType.UNKNOWN
def onServerUpdatedEvent(self, schid):
if not self.requestedRVars: return
self.requestedRVars = False
(err, dcgid) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_CHANNEL_GROUP)
(err, acgid) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_CHANNEL_ADMIN_GROUP)
self.cgroups[schid]["default"] = dcgid
self.cgroups[schid]["admin"] = acgid
print(self.name, ">", "new default channel group for #", schid, ":",
dcgid)
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus != ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED: return
(err, suid) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
(err, uid) = ts3lib.getClientSelfVariable(schid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
self.requested = uid
ts3lib.requestClientDBIDfromUID(schid, uid)
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 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 checkServer(self, schid=None):
if not schid: schid = self.schid
(err, servername) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_NAME)
(err, ownuid) = ts3lib.getClientSelfVariable(schid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(self.name+"> Checking for channel....")
print("servername:", servername, "cfg:",self.cfg.get("general","servername"), servername == self.cfg.get("general","servername"))
print("myuid",ownuid,self.cfg.get("general","myuid"), ownuid == self.cfg.get("general","myuid"))
if servername != self.cfg.get("general","servername"): return
if ownuid != self.cfg.get("general","myuid"): return
print("mein test 1")
content = StringIO("[general]\nmychan = ╠-● Administrator | Blu")
cfg = ConfigParser()
cfg.readfp(content)
print(cfg.get("general", "mychan")
)
print(type(cfg.get("general", "mychan"))
)
print(cfg.get("general", "mychan").split(",")
)
return
# mychan = StringIO("╠-● Administrator | Blu").split(",")
# mychan = self.cfg.get("general", "mychan") # .split(",")
print(mychan)
mycid = ts3lib.getChannelIDFromChannelNames(schid, mychan)
print("mein test 2")
self.schids.append({schid: mycid})
print("mein test 3")
self.toggleChannel(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 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 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 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]
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 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
ts3lib.setClientSelfVariableAsString(schid, ts3defines.ClientProperties.CLIENT_NICKNAME, choice(self.nicknames))
ts3lib.flushClientSelfUpdates(schid)
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 dbInsert(self,
schid,
cid,
clid,
cgid,
dbid=None,
invokerName="",
invokerUID="",
name="",
uid=""):
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"dbInsert(schid={}, cid={}, clid={}, cgid={}, dbid={}, invokerName={}, invokerUID={}, name={}, uid={})"
.format(schid, cid, clid, cgid, dbid, invokerName, invokerUID,
name, uid))
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))
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 setupTable(self):
try:
self.tbl_members.clearContents()
self.tbl_members.setRowCount(0)
cache = ts3client.ServerCache(self.schid)
(err, suid) = ts3lib.getServerVariable(self.schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
q = self.execSQL("SELECT * FROM '{}|{}'".format(suid, self.cid))
while q.next():
pos = self.tbl_members.rowCount
if PluginHost.cfg.getboolean("general", "verbose"): print(pos)
self.tbl_members.insertRow(pos)
self.tbl_members.setItem(pos, 0, QTableWidgetItem(datetime.utcfromtimestamp(q.value("timestamp")).strftime('%Y-%m-%d %H:%M:%S')))
self.tbl_members.setItem(pos, 1, QTableWidgetItem(q.value("name")))
self.tbl_members.setItem(pos, 2, QTableWidgetItem(q.value("uid")))
self.tbl_members.setItem(pos, 3, QTableWidgetItem(str(q.value("dbid"))))
box = QComboBox()
box.connect("currentIndexChanged(int index)", self.currentIndexChanged)
i = 0
for cgroup in self.cgroups:
icon = QIcon(cache.icon(self.cgroups[cgroup]["icon"]))
text = "{} ({})".format(self.cgroups[cgroup]["name"], cgroup)
box.addItem(icon, text)
box.setItemData(i, cgroup)
if cgroup == q.value("cgid"): box.setCurrentIndex(i)
i += 1
self.tbl_members.setCellWidget(pos, 4, box)
self.tbl_members.setItem(pos, 5, QTableWidgetItem("{} ({})".format(q.value("invokername"), q.value("INVOKERUID"))))
except: ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "pyTSon", 0)
def onDelChannelEvent(self, schid, channelID, invokerID, invokerName,
invokerUniqueIdentifier):
if not self.toggle: return
if not schid in self.cgroups: return
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
self.execSQL("DROP TABLE IF EXISTS '{}|{}';".format(suid, channelID))
def checkMenus(self, schid=0):
if not self.name in PluginHost.active: return
if schid < 1: schid = ts3lib.getCurrentServerConnectionHandlerID()
err, status = ts3lib.getConnectionStatus(schid)
if status != ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED: return
(err, suid) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: self.toggleMenus(False)
else: self.toggleMenus(True)
def getInterval(self, schid=0):
if schid < 1: schid = ts3lib.getCurrentServerConnectionHandlerID()
(err, suid) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if not suid in self.interval: suid = "default"
interval = randint(self.interval[suid][0]*1000, self.interval[suid][1]*1000)
if PluginHost.cfg.getboolean("general", "verbose"):
print("schid:", schid, "suid:", suid, "min:", self.interval[suid][0]*1000, "max:", self.interval[suid][1]*1000, "interval:", interval)
return interval
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if not self.enabled: return
if newStatus != ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
return
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
(err, self.sgid_guest) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_SERVER_GROUP)
(err, self.cgid_guest) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_CHANNEL_GROUP)
(err, self.cgid_admin) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_CHANNEL_ADMIN_GROUP)
def onClientChannelGroupChangedEvent(self, schid, channelGroupID, channelID, clientID, invokerClientID, invokerName, invokerUniqueIdentity):
(err, suid) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
(err, ownID) = ts3lib.getClientID(schid)
if clientID == ownID:
if channelGroupID == 9: self.mychan = channelID
else: self.mychan = 0
return
def serverURL(schid=None, name=None):
if schid is None:
try: schid = ts3lib.getCurrentServerConnectionHandlerID()
except: pass
if name is None:
try: (error, name) = ts3lib.getServerVariable(schid, schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_NAME)
except: name = schid
return '[b][url=channelid://0]"{}"[/url][/b]'.format(name)
