def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL:
if menuItemID == 0:
self.channel = selectedItemID
ts3lib.printMessageToCurrentTab('[{:%Y-%m-%d %H:%M:%S}] '.format(datetime.now())+" Set target channel to [color=yellow]"+str(self.channel)+"[/color]")
elif menuItemID == 1:
(e, cgid) = ts3lib.getServerVariableAsUInt64(schid, ts3defines.VirtualServerPropertiesRare.VIRTUALSERVER_DEFAULT_CHANNEL_GROUP)
x = QDialog()
x.setAttribute(Qt.WA_DeleteOnClose)
dbid = QInputDialog.getInt(x, "Manually change channel group", "Enter DBID", QLineEdit.Normal)
if self.channel == 0:
(e, ownID) = ts3lib.getClientID(schid)
(e, self.channel) = ts3lib.getChannelOfClient(schid, ownID)
name = "DBID: %s"%dbid
if self.debug:
ts3lib.printMessageToCurrentTab("toggle: {0} | debug: {1} | channel: {2} | groups: {3} | dbid: {4} | name: {5}".format(self.toggle,self.debug,self.channel,self.groups,dbid,name))
ts3lib.printMessageToCurrentTab("schid: {0} | cgid: {1} | dbid: {2}".format(schid,cgid,dbid))
if not self.dlg: self.dlg = ChannelGroupDialog(schid, cgid, dbid, name, self.channel, self.groups)
self.dlg.show();self.dlg.raise_();self.dlg.activateWindow()
elif atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT:
if menuItemID == 0:
if self.channel == 0:
(e, ownID) = ts3lib.getClientID(schid)
(e, self.channel) = ts3lib.getChannelOfClient(schid, ownID)
(e, dbid) = ts3lib.getClientVariableAsUInt64(schid, selectedItemID, ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
(e, cgid) = ts3lib.getClientVariableAsUInt64(schid, selectedItemID, ts3defines.ClientPropertiesRare.CLIENT_CHANNEL_GROUP_ID)
(e, name) = ts3lib.getClientVariableAsString(schid, selectedItemID, ts3defines.ClientProperties.CLIENT_NICKNAME)
if self.debug: ts3lib.printMessageToCurrentTab("toggle: {0} | debug: {1} | channel: {2} | groups: {3} | dbid: {4} | name: {5}".format(self.toggle,self.debug,self.channel,self.groups,dbid,name))
if not self.dlg: self.dlg = ChannelGroupDialog(schid, cgid, dbid, name, self.channel, self.groups)
self.dlg.show();self.dlg.raise_();self.dlg.activateWindow()
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype == PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL:
if menuItemID == 0:
error, ownid = ts3.getClientID(schid)
if error == ERROR_ok:
error, meta = ts3.getClientVariableAsString(schid, ownid, ClientProperties.CLIENT_META_DATA)
if error == ERROR_ok:
x = QWidget()
_meta = QInputDialog.getMultiLineText(x, "Change own Meta Data", "Meta Data:", meta)
if _meta == meta: return
error = ts3.setClientSelfVariableAsString(schid, ClientProperties.CLIENT_META_DATA, _meta)
if not error == ERROR_ok:
_t = QMessageBox(QMessageBox.Critical, "Error #%s"%error, "Unable to set own meta data!");_t.show()
elif menuItemID == 1:
error, ownid = ts3.getClientID(schid)
if error == ERROR_ok:
error, flag = ts3.getClientVariableAsString(schid, ownid, ClientPropertiesRare.CLIENT_FLAG_AVATAR)
ts3.printMessageToCurrentTab("Your current avatar flag is: %s"%flag)
if error == ERROR_ok:
x = QWidget()
_flag = QInputDialog.getText(x, "Change own Avatar Flag", "Avatar File MD5:")
if _flag == "x" or _flag.strip() == flag.strip(): return
error = ts3.setClientSelfVariableAsString(schid, ClientPropertiesRare.CLIENT_FLAG_AVATAR, _flag)
error2 = ts3.flushClientSelfUpdates(schid)
if not error == ERROR_ok or not error2 == ERROR_ok:
_t = QMessageBox(QMessageBox.Critical, "Error", "Unable to set own avatar flag!");_t.show()
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 onHotkeyOrCommandEvent(self, keyword, schid=0):
if not schid: schid = ts3lib.getCurrentServerConnectionHandlerID()
if keyword == "restrict_last_joined_server":
self.requested = self.last_joined_server
msg = self.cfg.get("restrict", "poke")
if msg: ts3lib.requestClientPoke(schid, self.requested, msg)
ts3lib.requestClientVariables(schid, self.last_joined_server)
# self.restrictClient(schid, self.last_joined_server)
elif keyword == "restrict_last_joined_channel":
self.requested = self.last_joined_channel
msg = self.cfg.get("restrict", "poke")
if msg: ts3lib.requestClientPoke(schid, self.requested, msg)
ts3lib.requestClientVariables(schid, self.last_joined_channel)
# self.restrictClient(schid, self.last_joined_channel)
elif keyword == "ban_last_joined_server":
msg = self.cfg.get("ban", "poke")
if msg:
ts3lib.requestClientPoke(schid, self.last_joined_server, msg)
self.banClient(schid, self.last_joined_server)
elif keyword == "ban_last_joined_channel":
msg = self.cfg.get("ban", "poke")
if msg:
ts3lib.requestClientPoke(schid, self.last_joined_channel, msg)
self.banClient(schid, self.last_joined_channel)
elif keyword == "revoke_last_talk_power_channel":
self.revokeTalkPower(schid, self.last_talk_power)
elif keyword == "restrict_last_joined_channel_from_local_channels":
self.restrictForeigners(schid, self.last_joined_channel)
elif keyword == "last_joined_channel_to_customBan":
self.toCustomBan(schid, self.last_joined_channel)
elif keyword == "last_joined_server_to_customBan":
self.toCustomBan(schid, self.last_joined_server)
elif keyword == "join_selected_channel_pw":
window = self.app.activeWindow()
if window is None or not window.className() == "MainWindow": return
selected = widget("ServerTreeView", self.app).currentIndex()
if not selected: return
name = selected.data()
item = getIDByName(name, schid)
if item[1] != ServerTreeItemType.CHANNEL: return
(err, clid) = ts3lib.getClientID(schid)
(err, cid) = ts3lib.getChannelOfClient(schid, clid)
if cid == item[0]: return
pw = getChannelPassword(schid, item[0], calculate=True)
if not pw: return
# ts3lib.printMessageToCurrentTab("{} > Joining {} (pw: {})".format(self.name, name, pw))
ts3lib.requestClientMove(schid, clid, item[0], pw)
elif keyword == "rejoin_last_channel_pw":
(err, clid) = ts3lib.getClientID(schid)
(err, cid) = ts3lib.getChannelOfClient(schid, clid)
tcid = self.lastchans[schid]
if cid == tcid: return
pw = getChannelPassword(schid, tcid, calculate=True)
# (err, name) = ts3lib.getChannelVariable(schid, tcid, ts3defines.ChannelProperties.CHANNEL_NAME)
# ts3lib.printMessageToCurrentTab("{} > Rejoining {} (pw: {})".format(self.name, name, pw))
ts3lib.requestClientMove(schid, clid, tcid, pw if pw else "123")
def onMenuItemEvent(self, schid, atype, menuItemID, channel):
if atype != ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL: return
try:
(error, ownID) = ts3lib.getClientID(schid)
(error, maxclients) = ts3lib.getChannelVariable(
schid, channel,
ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS)
if self.debug:
ts3lib.printMessageToCurrentTab(
"error: {0} | maxclients: {1}".format(error, maxclients))
if menuItemID == 0:
pw = inputBox("Enter Channel Password", "Password:"******"clients: {0}".format(clients))
(error, maxfamilyclients) = ts3lib.getChannelVariable(
schid, channel,
ts3defines.ChannelProperties.CHANNEL_MAXFAMILYCLIENTS)
if self.debug:
ts3lib.printMessageToCurrentTab(
"error: {0} | maxfamilyclients: {1}".format(
error, maxfamilyclients))
if clients < maxclients and clients < maxfamilyclients:
ts3lib.requestClientMove(schid, ownID, channel, pw)
return True
(error, name) = ts3lib.getChannelVariableAsString(
schid, channel, ts3defines.ChannelProperties.CHANNEL_NAME)
self.schid = schid
self.channel = channel
self.password = pw
self.cname = name
if not pw:
ts3lib.printMessageToCurrentTab(
"Queued for channel [url=channelid://{0}]{1}[/url]. [color=red]{2}[/color] client(s) remaining."
.format(channel, name, maxclients - clients + 1))
else:
ts3lib.printMessageToCurrentTab(
"Queued for channel [url=channelid://{0}]{1}[/url] with password \"{2}\". [color=red]{3}[/color] client(s) remaining."
.format(channel, name, pw, maxclients - clients + 1))
elif menuItemID == 1:
pw = inputBox("Enter Channel Password", "Password:"******"pyTSon", 0)
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 onClientMoveEvent(self, serverConnectionHandlerID, clientID, oldChannelID, newChannelID, visibility, moveMessage):
#Log Channel Change
#ts3lib.printMessageToCurrentTab("Switched room from %s to %s" % (tshelp.getChannelName(serverConnectionHandlerID,oldChannelID), tshelp.getChannelName(serverConnectionHandlerID,newChannelID)))
if self.currentActiveServer == serverConnectionHandlerID and clientID == ts3lib.getClientID(serverConnectionHandlerID)[1]: #If User Moves
self.ws.send(json.dumps({'event': 'onClientMoveEvent', 'channelID' : newChannelID, 'channelName': tshelp.getChannelName(serverConnectionHandlerID,newChannelID), 'clients': tshelp.getNearbyClients(self.currentActiveServer)}))
# self.ws.send(json.dumps({'event': 'updateChannelClients', 'clients': tshelp.getNearbyClients(self.currentActiveServer)}))
# updateChannelClients()
elif self.currentActiveServer == serverConnectionHandlerID and clientID != ts3lib.getClientID(serverConnectionHandlerID)[1] and (tshelp.getChannelID(serverConnectionHandlerID) == oldChannelID or tshelp.getChannelID(serverConnectionHandlerID) == newChannelID):
EVENT = 0
if tshelp.getChannelID(serverConnectionHandlerID) == newChannelID:
EVENT = 0
else:
EVENT = 1
self.ws.send(json.dumps({'event': 'nearbyClientMoveEvent', 'client': tshelp.getClientInfo(serverConnectionHandlerID, clientID), 'status': EVENT}))
def preProcessVar(self, schid, id, name, var, lst):
return name, var
if name == "CLIENT_META_DATA":
(err, ownID) = ts3lib.getClientID(schid)
if id == ownID: return name, None
elif name == "CHANNEL_PASSWORD": return name, None
return name, var
def onUpdateChannelEditedEvent(self, schid, channelID, invokerID,
invokerName, invokerUniqueIdentifier):
if self.debug:
ts3lib.printMessageToCurrentTab(
"self.schid: {0} | schid: {1}".format(self.schid, schid))
if self.debug:
ts3lib.printMessageToCurrentTab(
"self.channel: {0} | channelID: {1}".format(
self.channel, channelID))
if self.schid == schid and self.channel == channelID:
clients = self.channelClientCount(schid, channelID)
if self.debug:
ts3lib.printMessageToCurrentTab("clients: {0}".format(clients))
(error, maxclients) = ts3lib.getChannelVariableAsUInt64(
schid, channelID,
ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS)
if self.debug:
ts3lib.printMessageToCurrentTab(
"error: {0} | maxclients: {1}".format(error, maxclients))
(error, maxfamilyclients) = ts3lib.getChannelVariableAsUInt64(
schid, channelID,
ts3defines.ChannelProperties.CHANNEL_MAXFAMILYCLIENTS)
if self.debug:
ts3lib.printMessageToCurrentTab(
"error: {0} | maxfamilyclients: {1}".format(
error, maxfamilyclients))
if clients < maxclients and clients < maxfamilyclients:
(error, ownID) = ts3lib.getClientID(schid)
ts3lib.requestClientMove(schid, ownID, channelID,
self.password)
self.schid = 0
self.channel = 0
self.password = ""
self.name = ""
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID,
visibility, moveMessage):
if self.schid == schid and self.channel == oldChannelID:
clients = self.channelClientCount(schid, oldChannelID)
if self.debug:
ts3lib.printMessageToCurrentTab("clients: {0}".format(clients))
(error, maxclients) = ts3lib.getChannelVariableAsUInt64(
schid, oldChannelID,
ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS)
if self.debug:
ts3lib.printMessageToCurrentTab(
"error: {0} | maxclients: {1}".format(error, maxclients))
(error, maxfamilyclients) = ts3lib.getChannelVariableAsUInt64(
schid, oldChannelID,
ts3defines.ChannelProperties.CHANNEL_MAXFAMILYCLIENTS)
if self.debug:
ts3lib.printMessageToCurrentTab(
"error: {0} | maxfamilyclients: {1}".format(
error, maxfamilyclients))
if clients < maxclients and clients < maxfamilyclients:
(error, ownID) = ts3lib.getClientID(schid)
ts3lib.requestClientMove(schid, ownID, oldChannelID,
self.password)
self.schid = 0
self.channel = 0
self.password = ""
self.name = ""
else:
ts3lib.printMessageToCurrentTab(
"{0} left channel [url=channelid://{1}]{2}[/url]. [color=red]{3}[/color] client(s) remaining."
.format(self.clientURL(schid, clientID), channel, name,
maxclients - clients + 1))
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["state"] = 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:
if PluginHost.cfg.getboolean("general", "verbose"):
print("cmax", cmax, ">=", "clients", 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 onClientPokeEvent(self, serverConnectionHandlerID, fromClientID,
pokerName, pokerUID, message, ffIgnored):
#is it me?
(err, schids) = ts3lib.getServerConnectionHandlerList()
if err == ts3defines.ERROR_ok:
for schid in schids:
(err, myid) = ts3lib.getClientID(schid)
if err == ts3defines.ERROR_ok:
if fromClientID == myid:
return 0
else:
ts3lib.printMessageToCurrentTab(
"error getting own client id")
else:
ts3lib.printMessageToCurrentTab("error getting schids")
(err, name) = ts3lib.getClientVariableAsString(
serverConnectionHandlerID, fromClientID,
ts3defines.ClientProperties.CLIENT_NICKNAME)
if err != ts3defines.ERROR_ok:
err = ts3lib.requestClientPoke(serverConnectionHandlerID,
fromClientID, "?")
else:
err = ts3lib.requestClientPoke(serverConnectionHandlerID,
fromClientID, "?")
self.lastpoker = (serverConnectionHandlerID, fromClientID)
if err != ts3defines.ERROR_ok:
ts3lib.printMessageToCurrentTab("poke error: %d" % err)
return 0
else:
return 0
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 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 fakeClient(self, schid, clientID):
(error, _clid) = ts3lib.getClientID(schid)
(error, tnick) = ts3lib.getClientVariableAsUInt64(
schid, clientID, ts3defines.ClientProperties.CLIENT_NICKNAME)
(error, tnickp) = ts3lib.getClientVariableAsUInt64(
schid, clientID,
ts3defines.ClientProperties.CLIENT_NICKNAME_PHONETIC)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL and menuItemID == 0:
error, ownid = ts3lib.getClientID(schid)
if not error == ts3defines.ERROR_ok:
_t = QMessageBox(
QMessageBox.Critical, "Error #%s" % error,
"Unable to get own client ID in Tab #%s!" % schid)
_t.show()
return
error, ownchan = ts3lib.getChannelOfClient(schid, ownid)
if not error == ts3defines.ERROR_ok:
_t = QMessageBox(
QMessageBox.Critical, "Error #%s" % error,
"Unable to get own channel ID in Tab #%s!" % schid)
_t.show()
return
self.sendMessage(
schid,
ts3defines.TextMessageTargetMode.TextMessageTarget_CHANNEL,
ownchan)
elif atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT and menuItemID == 0:
self.sendMessage(
schid,
ts3defines.TextMessageTargetMode.TextMessageTarget_CLIENT,
selectedItemID)
elif atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL and menuItemID == 0:
self.sendMessage(
schid,
ts3defines.TextMessageTargetMode.TextMessageTarget_CHANNEL,
selectedItemID)
def onMenuItemEvent(self, serverConnectionHandlerID, atype, menuItemID, selectedItemID):
if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL:
if menuItemID == 0:
#self.reconnect(serverConnectionHandlerID)
ownID = ts3lib.getClientID(serverConnectionHandlerID)[1]
channelID = ts3lib.getChannelOfClient(serverConnectionHandlerID, ownID)[1]
channelPassword = ts3lib.getChannelConnectInfo(serverConnectionHandlerID, channelID, 256)[2]
ts3lib.printMessageToCurrentTab(channelPassword)
ts3lib.playWaveFile(serverConnectionHandlerID, path.join(self.soundPath, "yee.wav"))
ts3lib.printMessageToCurrentTab("F**k off. You know this has no use. Like your life. Pew Pew.")
if menuItemID == 1:
self.antiMoveStatus = not self.antiMoveStatus
ts3lib.printMessageToCurrentTab("{0}Set {1} to [color=green]{2}[/color]".format(timestamp(), self.name, self.antiMoveStatus))
if menuItemID == 2:
self.antiChannelKickStatus = not self.antiChannelKickStatus
ts3lib.printMessageToCurrentTab("{0}Set {1} to [color=green]{2}[/color]".format(timestamp(), self.name, self.antiChannelKickStatus))
if menuItemID == 3:
self.antiServerKickStatus = not self.antiServerKickStatus
ts3lib.printMessageToCurrentTab("{0}Set {1} to [color=green]{2}[/color]".format(timestamp(), self.name, self.antiServerKickStatus))
if menuItemID == 4:
self.antiServerBanStatus = not self.antiServerBanStatus
ts3lib.printMessageToCurrentTab("{0}Set {1} to [color=green]{2}[/color]".format(timestamp(), self.name, self.antiServerBanStatus))
if menuItemID == 5:
self.backup(serverConnectionHandlerID)
ts3lib.printMessageToCurrentTab("{0}[color=green]Backup complete![/color]".format(timestamp()))
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, 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 onClientMoveMovedEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moverID, moverName, moverUniqueIdentifier, moveMessage):
if not schid in self.targets: return
if self.targets[schid] != clientID: return
(err, ownID) = ts3lib.getClientID(schid)
if clientID != ownID or moverID == ownID: return
ts3lib.printMessageToCurrentTab("{} {}: [color=orange]No longer auto-dragging[/color] {} because we were moved!".format(timestamp(),self.name,clientURL(schid, self.targets[schid])))
del self.targets[schid]
def onTextMessageEvent(self, schid, targetMode, toID, fromID, fromName, fromUniqueIdentifier, message, ffIgnored):
if ffIgnored: return
(error, myid) = ts3lib.getClientID(schid)
_message = message.lower()
if myid == fromID and not "~check~" in _message: return
if not any(substring in _message for substring in ["[url]", "[url="]): return
msg = {
"schid": schid,
"returnCode": ts3lib.createReturnCode(),
"invoker": fromID,
"targetMode": targetMode,
"urls": parseURLs(message, self.bbcode_url),
"response": "[b]Link Checker:[/b]"
}
hosts = []
for url in msg["urls"]:
if url[0] != url[1]:
msg["response"] += "\n[color=orange]Suspicous Link [url]{}[/url] points to [url]{}[/url][/color]".format(url[0],url[1])
# answerMessage(schid, targetMode, fromID, "[color=orange]{}: {}".format(url[0], url[1]))
host = QUrl(url[1]).host()
if host and "." in host and not host in hosts:
hosts.append(host)
if len(hosts) > 0:
self.messages.append(msg)
self.getLinkInfo(hosts)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL:
if menuItemID == 0:
self.dlg = ServersDialog(self)
self.dlg.show()
#ts3.printMessageToCurrentTab(str(self.filters))
elif menuItemID == 1:
_schid = ts3.getCurrentServerConnectionHandlerID()
(error, _clid) = ts3.getClientID(_schid)
(error, _ip) = ts3.getConnectionVariableAsString(
_schid, _clid,
ts3defines.ConnectionProperties.CONNECTION_SERVER_IP)
(error, _port) = ts3.getConnectionVariableAsString(
_schid, _clid,
ts3defines.ConnectionProperties.CONNECTION_SERVER_PORT)
url = ""
if _port != "":
_url = self.config['GENERAL'][
'api'] + "serverlist/result/server/ip/" + _ip + ":" + _port + "/"
else:
_url = self.config['GENERAL'][
'api'] + "serverlist/result/server/ip/" + _ip + "/"
ts3.printMessageToCurrentTab(
str("Navigating to \"" + _url + "\""))
webbrowser.open(_url)
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID,
visibility, moveMessage):
if self.debug:
ts3lib.printMessageToCurrentTab(
"oldChannelID: {0}".format(oldChannelID))
if not oldChannelID == 0: return
(error, _clid) = ts3lib.getClientID(schid)
if self.debug:
ts3lib.printMessageToCurrentTab(
"_clid: {0} | clientID: {1}".format(_clid, clientID))
if clientID == _clid: return
if self.debug:
ts3lib.printMessageToCurrentTab(
"newChannelID: {0} | self.default: {1}".format(
newChannelID, self.default))
if not newChannelID == self.default: return
#(error, uid) = ts3lib.getClientVariableAsString(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
#if self.debug: ts3lib.printMessageToCurrentTab("uid: {0} | self.tmp: {1}".format(uid,self.tmp))
#if uid in self.tmp: return
(error, suid) = ts3lib.getServerVariableAsString(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if self.debug:
ts3lib.printMessageToCurrentTab(
"suid: {0} | self.cfg.sections(): {1} | self.cfg.has_section(suid): {2}"
.format(suid, self.cfg.sections(), self.cfg.has_section(suid)))
if not self.cfg.has_section(suid): return
self.update = clientID
ts3lib.requestClientVariables(schid, clientID)
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 onClientMoveMovedEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moverID, moverName, moverUniqueIdentifier, moveMessage):
if not schid in self.targets: return
if PluginHost.cfg.getboolean("general", "verbose"): print(self.name,"onClientMoveMovedEvent > self.targets[schid]",self.targets[schid],"moverUniqueIdentifier",moverUniqueIdentifier)
if self.targets[schid] != clientID: return
(err, ownID) = ts3lib.getClientID(schid)
if clientID != ownID or moverID == ownID: return
self.stop(" because we were moved", schid, clientID)
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 sendCommand(name, cmd, schid=0, silent=True, reverse=False, mode=1):
"""
Sends a command through TS3Hook.
:param mode: See enum: HookMode
:param reverse:
:param name:
:param cmd:
:param schid:
:param silent:
"""
if schid == 0: schid = ts3lib.getCurrentServerConnectionHandlerID()
if PluginHost.cfg.getboolean("general", "verbose") or not silent:
ts3lib.printMessage(
schid,
'{timestamp} [color=orange]{name}[/color]:[color=white] {prefix}{message}'
.format(timestamp=timestamp(),
name=name,
prefix="-" if reverse else "~",
message=cmd),
ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
print("mode:", mode)
if mode == HookMode.TS3HOOK:
cmd = "{}cmd{}".format("-" if reverse else "~", cmd.replace(" ", "~s"))
elif mode == HookMode.TSPATCH:
cmd = "{}{}".format("-" if reverse else "~", cmd)
else:
raise SyntaxError("No HookMode specified!")
(err, clid) = ts3lib.getClientID(schid)
retcode = "" # "TS3Hook:Command:{}".format(ts3lib.createReturnCode(256))
err = ts3lib.requestSendPrivateTextMsg(schid, cmd, clid, retcode)
if err != ts3defines.ERROR_ok:
ts3lib.requestSendChannelTextMsg(schid, cmd, 0, retcode)
if err != ts3defines.ERROR_ok:
ts3lib.requestSendServerTextMsg(schid, cmd, retcode)
def onClientMoveSubscriptionEvent(self, schid, clientID, oldChannelID, newChannelID, visibility):
if not self.check: return False
if self.toggle:
(error, _clid) = ts3lib.getClientID(schid)
if clientID != _clid:
(error, uid) = ts3lib.getClientVariableAsString(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
self.checkUser(uid)
def processCommand(self, schid, cmd):
cmd = cmd.split(' ', 1)
command = cmd[0].lower()
if command == "ping":
count = int(cmd[1]) if cmd[1] else 5
c = {}
(err, clids) = ts3lib.getClientList(schid)
for clid in clids:
# if len(self.c) > 10: break
if not clid in self.c:
ts3lib.requestConnectionInfo(schid, clid)
self.c.append(clid)
(err, ping) = ts3lib.getConnectionVariableAsUInt64(schid, clid, ts3defines.ConnectionProperties.CONNECTION_PING)
if err == ts3defines.ERROR_ok: c[clid] = ping
print(c)
s = sorted(c.items(), key=lambda x: int(x[1]))
t = take(count, s)
string = ""
place = 1
for k,v in t:
string += '{0}: {1} with [b]{2}[/b]ms\n'.format(place,clientURL(schid,k),v)
place += 1
(err, ownid) = ts3lib.getClientID(schid)
(err, ownchan) = ts3lib.getChannelOfClient(schid, ownid)
message = [string[i:i + 900] for i in range(0, len(string), 900)]
# message = re.findall('.{1,1024}(?:\n|$)', string)
# message = (textwrap.wrap(string, 1024))
# message = (line.strip() for line in re.findall(r'.{1,80}(?:\s+|$)', string))
# message = textwrap.wrap(string, 1024, break_long_words=False)
for msg in message: ts3lib.requestSendChannelTextMsg(schid, '\n{0}'.format(msg), ownchan)
elif command == "clear":
self.c = []
return 1
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 _reload(self):
err, self.myid = ts3lib.getClientID(self.schid)
err = ts3lib.requestServerGroupList(self.schid)
if err != ts3defines.ERROR_ok:
_errprint("Error requesting servergrouplist", err, self.schid)
err = ts3lib.requestChannelGroupList(self.schid)
if err != ts3defines.ERROR_ok:
_errprint("Error requesting channelgroups", err, self.schid)
self.beginResetModel()
self.allchans = {}
self.objs = {}
self._reloadServerinfo()
self._reloadChannellist()
self._reloadClientlist()
self.endResetModel()
