def answerMessage(self, schid, targetMode, toID, fromID, message, hideprefix=False):
if schid in self.noperms: ts3lib.printMessageToCurrentTab("Insufficient permissions to answer message from {0}".format(fromID)); return
message = [message[i:i + 1024] for i in range(0, len(message), 1024)]
if targetMode == ts3defines.TextMessageTargetMode.TextMessageTarget_CLIENT:
for msg in message: self.returnCode = ts3lib.createReturnCode(); ts3lib.requestSendPrivateTextMsg(schid, msg, fromID, self.returnCode)
elif targetMode == ts3defines.TextMessageTargetMode.TextMessageTarget_CHANNEL:
if hideprefix:
for msg in message: self.returnCode = ts3lib.createReturnCode(); ts3lib.requestSendChannelTextMsg(schid, "{0}".format(msg), toID, self.returnCode)
else:
for msg in message: self.returnCode = ts3lib.createReturnCode(); ts3lib.requestSendChannelTextMsg(schid, "[url=client://]@[/url]%s: %s" % ( self.clientURL(schid, fromID), msg), toID, self.returnCode)
def addUpload(self, path, localfile, overwrite, resume):
"""
Requests an upload to the server.
@param path: path to upload the file to
@type path: str
@param localfile: path to the file to upload
@type localfile: str
@param overwrite: set to True to overwrite an existing file
@type overwrite: bool
@param resume: set to True to resume a previous upload
@type resume: bool
@return: the filetransfer id
@rtype: int
"""
retcode = ts3lib.createReturnCode()
err, ftid = ts3lib.sendFile(self.schid, self.cid, self.password,
joinpath(path,
os.path.split(localfile)[-1]),
overwrite, resume,
os.path.dirname(localfile), retcode)
self.beginInsertRows(QModelIndex(), len(self.transfers),
len(self.transfers))
self.transfers[ftid] = Upload(err, retcode, localfile)
self.endInsertRows()
return ftid
def tick(self):
for schid in self.servers:
if self.hook: sendCommand(self.name, "clientupdate", schid)
else:
self.retcode = ts3lib.createReturnCode()
ts3lib.requestSendPrivateTextMsg(schid, self.text, self.servers[schid]["clid"], self.retcode)
self.timer.setInterval(self.getInterval())
def setChannelCommander(self, schid, enabled):
ts3lib.setClientSelfVariableAsInt(
schid, ts3lib.ClientPropertiesRare.CLIENT_IS_CHANNEL_COMMANDER,
enabled)
returnCode = ts3lib.createReturnCode()
self.retcodes.append(returnCode)
ts3lib.flushClientSelfUpdates(schid, returnCode)
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 addUpload(self, path, localfile, overwrite, resume):
"""
Requests an upload to the server.
@param path: path to upload the file to
@type path: str
@param localfile: path to the file to upload
@type localfile: str
@param overwrite: set to True to overwrite an existing file
@type overwrite: bool
@param resume: set to True to resume a previous upload
@type resume: bool
@return: the filetransfer id
@rtype: int
"""
retcode = ts3lib.createReturnCode()
err, ftid = ts3lib.sendFile(
self.schid, self.cid, self.password,
joinpath(path,
os.path.split(localfile)[-1]), overwrite, resume,
os.path.dirname(localfile), retcode)
self.beginInsertRows(QModelIndex(), len(self.transfers),
len(self.transfers))
self.transfers[ftid] = Upload(err, retcode, localfile)
self.endInsertRows()
return ftid
def addDownload(self, thefile, downloaddir, overwrite, resume):
"""
Requests a download from the server and monitors its progress
@param thefile: remote file to download
@type thefile: File
@param downloaddir: path to the download directory
@type downloaddir: str
@param overwrite: set to True to overwrite an existing file
@type overwrite: bool
@param resume: set to True to resume a previous download
@type resume: bool
@return: the filetransfer id
@rtype: int
"""
retcode = ts3lib.createReturnCode()
err, ftid = ts3lib.requestFile(self.schid, self.cid, self.password,
thefile.fullpath, overwrite, resume,
downloaddir, retcode)
self.beginInsertRows(QModelIndex(), len(self.transfers),
len(self.transfers))
self.transfers[ftid] = Download(err, retcode, thefile, downloaddir)
self.endInsertRows()
self.downcounter += 1
if self.downcounter == 1:
self.timer = self.startTimer(500)
return ftid
def tick(self):
try:
self.retcode = ts3lib.createReturnCode()
if self.mode == 0:
if self.pwc >= len(self.pws):
self.timer.stop()
(err, name) = ts3lib.getChannelVariable(
self.schid, self.cid, ChannelProperties.CHANNEL_NAME)
msgBox(
"Password for channel \"{0}\" was not found :(\n\nTried {1} passwords."
.format(name, self.pwc + 1))
self.cracking = False
return
pw = self.pws[self.pwc]
elif self.mode == 1:
pw = str(self.pwc)
err = ts3lib.verifyChannelPassword(self.schid, self.cid, pw,
self.retcode)
if err != ERROR_ok:
(er, status) = ts3lib.getErrorMessage(err)
print(
'ERROR {0} ({1}) while trying password \"{2}\" for channel #{3} on server #{4}'
.format(status, err, pw, self.cid, self.schid))
# else: print('[{0}] Trying password \"{1}\" for channel #{2} on server #{3}'.format(self.pwc, pw, self.cid, self.schid))
if not self.flooding: self.pwc += self.step
except:
from traceback import format_exc
ts3lib.logMessage(format_exc(), LogLevel.LogLevel_ERROR, "pyTSon",
0)
def tick(self):
new = choice(self.suffixes)
while new == self.last: new = choice(self.suffixes)
ts3lib.setClientSelfVariableAsString(self.schid, ts3defines.ClientProperties.CLIENT_NICKNAME, self.prefix + new)
self.retcode = ts3lib.createReturnCode()
ts3lib.flushClientSelfUpdates(self.schid, self.retcode)
self.last = new
def commandBanList(self, schid, targetMode, toID, fromID, params=""):
# try:
returnCode = ts3lib.createReturnCode()
self.cmdevent = {"event": "onBanListEvent", "returnCode": returnCode, "schid": schid, "targetMode": targetMode, "toID": toID, "fromID": fromID, "params": params}
self.banlist = ""
QTimer.singleShot(2500, self.sendBanList)
ts3lib.requestBanList(schid)
def importChannels(self, schid, file=""):
self.result = {
"success": 0,
"failed": 0,
"total": 0,
"msg": "",
"stop": False
}
channels = self.readChannels(file)
self.result["total"] = len(channels)
for channel in channels:
if self.result["stop"]:
self.result["stop"] = False
return
for k, v in channel["flags"].items():
ts3lib.setChannelVariableAsString(schid, 0, k, v)
print("Setting var", k, "with value", v)
returnCode = ts3lib.createReturnCode()
# result = {}
self.channels.append({
returnCode: (channel["flags"][ChannelProperties.CHANNEL_NAME],
channel["permissions"])
})
self.channels.append(channel)
ts3lib.flushChannelCreation(schid, 0, returnCode)
def deleteFiles(self, files=None):
if self.readonly:
return
if not files:
selfiles = self.selectedFiles()
else:
selfiles = files
if not selfiles:
return
if QMessageBox.question(
self, self._tr("Delete files"),
self._tr("Do you really want to delete all "
"selected files?")) == QMessageBox.No:
return
pathes = [f.fullpath for f in selfiles]
self.delretcode = ts3lib.createReturnCode()
err = ts3lib.requestDeleteFile(self.schid, self.cid, self.password,
pathes, self.delretcode)
if err != ERROR_ok:
self.showError(self._tr("Error deleting files"), err)
def addDownload(self, thefile, downloaddir, overwrite, resume):
"""
Requests a download from the server and monitors its progress
@param thefile: remote file to download
@type thefile: File
@param downloaddir: path to the download directory
@type downloaddir: str
@param overwrite: set to True to overwrite an existing file
@type overwrite: bool
@param resume: set to True to resume a previous download
@type resume: bool
@return: the filetransfer id
@rtype: int
"""
retcode = ts3lib.createReturnCode()
err, ftid = ts3lib.requestFile(self.schid, self.cid, self.password,
thefile.fullpath, overwrite, resume,
downloaddir, retcode)
self.beginInsertRows(QModelIndex(), len(self.transfers),
len(self.transfers))
self.transfers[ftid] = Download(err, retcode, thefile, downloaddir)
self.endInsertRows()
self.downcounter += 1
if self.downcounter == 1:
self.timer = self.startTimer(500)
return ftid
def tick(self):
if PluginHost.cfg.getboolean("general", "verbose"): print(self.servers)
if len(self.servers) < 1:
self.timer.stop()
return
for schid in self.servers:
self.waitingForList.append(schid)
self.retcode = ts3lib.createReturnCode()
ts3lib.requestComplainList(schid, 0, self.retcode)
def onNewChannelCreatedEvent(self, schid, cid, channelParentID, invokerID, invokerName, invokerUniqueIdentifier):
if not self.waitforchannel: return
mycid = ts3lib.getChannelIDFromChannelNames(schid, self.cfg.get("general", "mychan").split(","))
if not channelParentID == mycid: return
self.waitforchannel = False
self.supchan = cid
for (key, val) in self.chan.items("permissions"):
(err, id) = ts3lib.getPermissionIDByName(schid, key)
self.perm = (id, key, ts3lib.createReturnCode())
ts3lib.requestChannelAddPerm(schid, cid, [id], [int(val)])
def tick(self):
for schid in self.servers:
if self.hook: sendCommand(self.name, "clientupdate", schid)
else:
self.retcode = ts3lib.createReturnCode()
ts3lib.requestSendPrivateTextMsg(schid, self.text,
self.servers[schid]["clid"],
self.retcode)
interval = self.getInterval()
# print(self.name, ">", "Sent", self.text, "for schid", schid, "to clid", self.servers[schid]["clid"], "| new interval:", interval)
self.timer.setInterval(interval)
def onServerErrorEvent(self, schid, errorMessage, error, returnCode,
extraMessage):
if not returnCode in self.retcodes: return
self.retcodes.remove(returnCode)
(err, ip) = ts3lib.getConnectionVariable(
schid, self.clid,
ts3defines.ConnectionProperties.CONNECTION_CLIENT_IP)
if ip and ip != "None":
retCode = ts3lib.createReturnCode()
self.retcodes.append(retCode)
ts3lib.requestConnectionInfo(schid, self.clid, retCode)
def _reload(self, path=None):
if path:
self.newpath = path
else:
self.newpath = self._path
self.retcode = ts3lib.createReturnCode()
err = ts3lib.requestFileList(self.schid, self.cid, self.password,
self.newpath, self.retcode)
if err != ERROR_ok:
_errprint(self._tr("Error requesting filelist"), err, self.schid,
self.cid)
def _reload(self, path=None):
if path:
self.newpath = path
else:
self.newpath = self._path
self.retcode = ts3lib.createReturnCode()
err = ts3lib.requestFileList(self.schid, self.cid, self.password,
self.newpath, self.retcode)
if err != ERROR_ok:
_errprint(self._tr("Error requesting filelist"), err, self.schid,
self.cid)
def onConnectionInfoEvent(self, schid, clid):
if PluginHost.cfg.getboolean("general", "verbose"):
print(self.name, "> onConnectionInfoEvent", schid, clid)
if not hasattr(self, "clid") or clid != self.clid: return
(err, ip) = ts3lib.getConnectionVariable(
schid, clid, ts3defines.ConnectionProperties.CONNECTION_CLIENT_IP)
if ip:
if ip == "None":
retCode = ts3lib.createReturnCode()
self.retcodes.append(retCode)
ts3lib.requestConnectionInfo(schid, clid, retCode)
return
elif self.dlg:
self.dlg.txt_ip.setText(ip)
del self.clid
def printQueries(self):
(err, schids) = ts3lib.getServerConnectionHandlerList()
for schid in schids:
(err, cids) = ts3lib.getChannelList(schid)
for cid in cids:
(err, clids) = ts3lib.getChannelClientList(schid, cid)
msg = []
for clid in clids:
(err, ctype) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientPropertiesRare.CLIENT_TYPE)
if ctype != ts3defines.ClientType.ClientType_SERVERQUERY: continue
msg.append(clientURL(schid, clid))
if len(msg) < 1: continue
ts3lib.printMessage(schid, "<{0}> {1} has [b]{2}[/b] Query Clients: {3}".format(Time(), channelURL(schid, cid), len(msg), ", ".join(msg)), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
self.waitingFor = self.query_uids[0]
self.retcode = ts3lib.createReturnCode()
ts3lib.requestClientIDs(schid, self.query_uids[0], self.retcode)
def collect(self, dirs):
"""
Starts collecting files from a list of directories
@param dirs: list of directories
@type dirs: list(File)
"""
for d in dirs:
retcode = ts3lib.createReturnCode()
self.queue[retcode] = d.fullpath
err = ts3lib.requestFileList(self.schid, self.cid, self.password,
d.fullpath, retcode)
if err != ERROR_ok:
del self.queue[retcode]
self.collectionError.emit(self._tr("Error requesting "
"filelist of {dirname}").
format(dirname=d.fullpath), err)
def setData(self, idx, value, role=Qt.EditRole):
if not idx.isValid():
return False
f = self.fileByIndex(idx)
if value == f.name:
return
self.renretcode = ts3lib.createReturnCode()
self.renfile = (f, f.name)
err = ts3lib.requestRenameFile(self.schid, self.cid, self.password,
0, "", f.fullpath, joinpath(f.path,
value),
self.renretcode)
if err == ERROR_ok:
f.name = value
return True
def setData(self, idx, value, role=Qt.EditRole):
if not idx.isValid():
return False
f = self.fileByIndex(idx)
if value == f.name:
return
self.renretcode = ts3lib.createReturnCode()
self.renfile = (f, f.name)
err = ts3lib.requestRenameFile(self.schid, self.cid, self.password,
0, "", f.fullpath,
joinpath(f.path,
value), self.renretcode)
if err == ERROR_ok:
f.name = value
return True
def collect(self, dirs):
"""
Starts collecting files from a list of directories
@param dirs: list of directories
@type dirs: list(File)
"""
for d in dirs:
retcode = ts3lib.createReturnCode()
self.queue[retcode] = d.fullpath
err = ts3lib.requestFileList(self.schid, self.cid, self.password,
d.fullpath, retcode)
if err != ERROR_ok:
del self.queue[retcode]
self.collectionError.emit(
self._tr(
"Error requesting "
"filelist of {dirname}").format(dirname=d.fullpath),
err)
def createFolder(self):
if self.readonly:
return
ok = BoolResult()
dirname = QInputDialog.getText(self, self._tr("Create Folder"),
self._tr("Folder name:"),
QLineEdit.Normal, "", ok)
if not ok or dirname == "":
return
self.createretcode = ts3lib.createReturnCode()
err = ts3lib.requestCreateDirectory(self.schid, self.cid,
self.password,
joinpath(self.path, dirname),
self.createretcode)
if err != ERROR_ok:
self.showError(self._tr("Error creating directory"), err)
def getPerms(self, schid, clid=0, sgid=0):
if self.flood: return
if not clid: (err, clid) = ts3lib.getClientID(schid)
(err, cldbid) = ts3lib.getClientVariable(
schid, clid, ClientPropertiesRare.CLIENT_DATABASE_ID)
self.perms = {"success": 0, "fail": 0, "processed": 0, "stop": False}
with open(path.join(self.path, "essential.csv")) as csvfile:
permissions = csv.reader(csvfile, delimiter=';')
for perm in permissions:
if self.perms["stop"]: break
(err, pid) = ts3lib.getPermissionIDByName(schid, perm[0])
retcode = ts3lib.createReturnCode()
self.retcodes[retcode] = perm[0]
v = 100 if sgid == 2 and perm[1] == "75" else int(perm[1])
ts3lib.requestClientAddPerm(schid, cldbid, [pid], [v],
[int(perm[2])], retcode)
(err, ownCID) = ts3lib.getChannelOfClient(schid, clid)
if self.perms["stop"]: break
ts3lib.requestChannelClientAddPerm(schid, ownCID, cldbid,
[pid], [v], retcode)
def createFolder(self):
if self.readonly:
return
ok = BoolResult()
dirname = QInputDialog.getText(self, self._tr("Create Folder"),
self._tr("Folder name:"),
QLineEdit.Normal, "", ok)
if not ok or dirname == "":
return
self.createretcode = ts3lib.createReturnCode()
err = ts3lib.requestCreateDirectory(self.schid, self.cid,
self.password,
joinpath(self.path, dirname),
self.createretcode)
if err != ERROR_ok:
self.showError(self._tr("Error creating directory"), err)
def uploadAvatar(self, schid, img, filename=""):
try:
img = path.abspath(img)
self.tmp = img
if filename == "": filename = self.generateAvatarFileName(schid)
imgdir = path.dirname(img) + path.sep
self.retcode = ts3lib.createReturnCode()
(error, ftid) = ts3lib.sendFile(schid, 0, "",
"/avatar/" + filename, True, False,
imgdir, self.retcode)
except:
try:
from traceback import format_exc
ts3lib.logMessage(format_exc(),
ts3defines.LogLevel.LogLevel_ERROR,
"PyTSon Script", 0)
except:
try:
from traceback import format_exc
print(format_exc())
except:
print("Unknown Error")
def onUpdateClientEvent(self, schid, clid, invokerID, invokerName,
invokerUID):
if schid != self.waiting_for[0]: return
if clid != self.waiting_for[1]: return
self.waiting_for = (0, 0)
(err, uid) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if err != ts3defines.ERROR_ok: uid = ""
(err, mytsid) = ts3lib.getClientVariable(schid, clid, 61)
if err != ts3defines.ERROR_ok or not mytsid:
if schid in self.mytsids and clid in self.mytsids[schid]:
mytsid = self.mytsids[schid][clid]
else:
mytsid = ""
(err, name) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
if err != ts3defines.ERROR_ok: name = ""
self.clid = clid
type = getServerType(schid)
(err, ip) = ts3lib.getConnectionVariable(
schid, clid, ts3defines.ConnectionProperties.CONNECTION_CLIENT_IP)
if (err != ts3defines.ERROR_ok or not ip) or (ip and ip == "None"):
retcode = ts3lib.createReturnCode()
self.retcodes.append(retcode)
ts3lib.requestConnectionInfo(schid, clid, retcode)
(err, ip) = ts3lib.getConnectionVariable(
schid, clid,
ts3defines.ConnectionProperties.CONNECTION_CLIENT_IP)
if not self.dlg:
self.dlg = BanDialog(self, schid, clid, uid, name, ip, mytsid, "",
type)
else:
self.dlg.setup(self, schid, clid, uid, name, ip, mytsid, ip, type)
self.dlg.show()
self.dlg.raise_()
self.dlg.activateWindow()
def deleteFiles(self, files=None):
if self.readonly:
return
if not files:
selfiles = self.selectedFiles()
else:
selfiles = files
if not selfiles:
return
if QMessageBox.question(self, self._tr("Delete files"),
self._tr("Do you really want to delete all "
"selected files?")) == QMessageBox.No:
return
pathes = [f.fullpath for f in selfiles]
self.delretcode = ts3lib.createReturnCode()
err = ts3lib.requestDeleteFile(self.schid, self.cid, self.password,
pathes, self.delretcode)
if err != ERROR_ok:
self.showError(self._tr("Error deleting files"), err)
def processCommand(self, schid, keyword):
args = keyword.split()
cmd = args.pop(0).lower()
if cmd == "com":
command = " ".join(args)
self.retcode = ts3lib.createReturnCode(); self.schid = schid
err = ts3lib.requestSendClientQueryCommand(schid, command, self.retcode)
if err != ts3defines.ERROR_ok:
(_err, msg) = ts3lib.getErrorMessage(err)
ts3lib.printMessageToCurrentTab("(%s) %s: %s"%(schid, command, msg))
elif cmd == "req":
clid = int(args.pop(0))
self.req = clid
ts3lib.requestClientVariables(schid, clid)
elif cmd == "reqcon":
clid = int(args.pop(0))
self.req = clid
ts3lib.requestConnectionInfo(schid, clid)
elif cmd == "self":
err, clid = ts3lib.getClientID(schid)
ts3lib.printMessageToCurrentTab("[b]{}'s Self Variables:".format(clientURL(schid, clid)))
open(self.filepath, 'w').close()
min=0;max=64
if len(args):
min = int(args.pop(0))
if len(args): max = int(args.pop(0))
for i in range(min, max):
msg = "%s"%i
values = set(item.value for item in ts3enums.ClientProperties)
if i in values: msg += " ({})".format(ts3enums.ClientProperties(i))
msg += ": "
(err, var) = ts3lib.getClientSelfVariableAsString(schid, i)
if err != ts3defines.ERROR_ok:
(_err, var) = ts3lib.getErrorMessage(err)
msg += var
with open(self.filepath, "a", encoding="utf-8") as myfile:
myfile.write(msg+"\n")
ts3lib.printMessageToCurrentTab(msg)
elif cmd == "client":
clid = int(args.pop(0))
ts3lib.printMessageToCurrentTab("[b]{}'s Client Variables:".format(clientURL(schid, clid)))
open(self.filepath, 'w').close()
min=0;max=64
if len(args):
min = int(args.pop(0))
if len(args): max = int(args.pop(0))
for i in range(min, max):
msg = "%s"%i
values = set(item.value for item in ts3enums.ClientProperties)
if i in values: msg += " ({})".format(ts3enums.ClientProperties(i))
msg += ": "
(err, var) = ts3lib.getClientVariableAsString(schid, clid, i)
if err != ts3defines.ERROR_ok:
(_err, var) = ts3lib.getErrorMessage(err)
msg += var
with open(self.filepath, "a", encoding="utf-8") as myfile:
myfile.write(msg+"\n")
ts3lib.printMessageToCurrentTab(msg)
elif cmd == "con":
clid = int(args.pop(0))
ts3lib.printMessageToCurrentTab("[b]{}'s Connection Variables:".format(clientURL(schid, clid)))
open(self.filepath, 'w').close()
min=0;max=65
if len(args):
min = int(args.pop(0))
if len(args): max = int(args.pop(0))
for i in range(min, max):
msg = "%s"%i
values = set(item.value for item in ts3enums.ConnectionProperties)
if i in values: msg += " ({})".format(ts3enums.ConnectionProperties(i))
msg += ": "
(err, var) = ts3lib.getConnectionVariableAsString(schid, clid, i)
if err != ts3defines.ERROR_ok:
(_err, var) = ts3lib.getErrorMessage(err)
msg += var
with open(self.filepath, "a", encoding="utf-8") as myfile:
myfile.write(msg+"\n")
ts3lib.printMessageToCurrentTab(msg)
else: return False
return True
class ContactManager(ts3plugin):
# --------------------------------------------
# Plugin info vars
# --------------------------------------------
name = "Contact Manager"
requestAutoload = False
version = "1.2"
apiVersion = 21
author = "Luemmel"
description = "Automatically grants talkpower, assigns channelgroups for blocked users or friends, send private message to blocked users and friends and kicks blocked users."
offersConfigure = True
commandKeyword = ""
infoTitle = None
hotkeys = []
menuItems = [(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0, "Contact Manager Settings", "")]
directory = path.join(getPluginPath(), "pyTSon", "scripts", "contactmanager")
# --------------------------------------------
# Custom error codes
# --------------------------------------------
error_setClientTalkpower = ts3.createReturnCode()
error_setClientChannelGroup = ts3.createReturnCode()
error_kickFromChannel = ts3.createReturnCode()
error_sendMessage = ts3.createReturnCode()
# --------------------------------------------
# Temporary vars
# --------------------------------------------
channel_group_list = []
channel_group_list_name = []
dlg = None
changesdlg = None
# --------------------------------------------
# Settings
# --------------------------------------------
settings = {}
settings["f_channelgroup"] = None
settings["f_talkpower"] = None
settings["f_message"] = None
settings["f_message_message"] = ""
settings["b_channelgroup"] = None
settings["b_kick"] = None
settings["b_kick_message"] = ""
settings["b_message"] = None
settings["b_message_message"] = ""
def __init__(self):
# --------------------------------------------
# Database
# --------------------------------------------
# Database connect for plugin main.db
self.db = QSqlDatabase.addDatabase("QSQLITE", "pyTSon_contactmanager")
self.db.setDatabaseName(path.join(self.directory, "main.db"))
if not self.db.isValid(): raise Exception("Database main.db is invalid")
if not self.db.open(): raise Exception("Could not open Database main.db")
# Database connect for internal teamspeak settings.db
self.db_c = QSqlDatabase.addDatabase("QSQLITE","pyTSon_contacts")
self.db_c.setDatabaseName(ts3.getConfigPath() + "settings.db")
if not self.db_c.isValid(): raise Exception("Database settings.db is invalid")
if not self.db_c.open(): raise Exception("Could not open Database settings.db")
# --------------------------------------------
# Load General Settings
# --------------------------------------------
s = self.db.exec_("SELECT * FROM settings LIMIT 1")
if not self.db.lastError().isValid():
if s.next():
self.settings["f_channelgroup"] = bool(s.value("db_f_channelgroup"))
self.settings["f_talkpower"] = bool(s.value("db_f_talkpower"))
self.settings["f_message"] = bool(s.value("db_f_message"))
self.settings["f_message_message"] = s.value("db_f_message_message")
self.settings["b_channelgroup"] = bool(s.value("db_b_channelgroup"))
self.settings["b_kick"] = bool(s.value("db_b_kick"))
self.settings["b_kick_message"] = s.value("db_b_kick_message")
self.settings["b_message"] = bool(s.value("db_b_message"))
self.settings["b_message_message"] = s.value("db_b_message_message")
def stop(self):
self.db.close()
self.db.delete()
self.db_c.close()
self.db_c.delete()
QSqlDatabase.removeDatabase("pyTSon_contactmanager")
QSqlDatabase.removeDatabase("pyTSon_contacts")
# --------------------------------------------
# Dialog
# --------------------------------------------
def configure(self, qParentWidget):
self.openMainDialog()
def onMenuItemEvent(self, sch_id, a_type, menu_item_id, selected_item_id):
if a_type == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL:
if menu_item_id == 0: self.openMainDialog()
def openMainDialog(self):
self.dlg = MainDialog(self)
self.dlg.show()
self.dlg.raise_()
self.dlg.activateWindow()
# This method fires on connect to a server and if you open the right system
# Fires multipletimes for each channelgroup
def onChannelGroupListEvent(self, schid, chgid, name, atype, iconID, saveDB):
# If regular group
if atype == 1:
# Append channelgroup ids and channelgroup names to temporary vars
self.channel_group_list.append(chgid)
self.channel_group_list_name.append(name)
# This method fires if all channelgroups were send via onChannelGroupListEvent()
def onChannelGroupListFinishedEvent(self, schid):
(error, sname) = ts3.getServerVariableAsString(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_NAME)
(error, suid) = ts3.getServerVariableAsString(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
# Start checking for channelgroup updates or if server is known
self.checkServer(schid, sname, suid, self.channel_group_list, self.channel_group_list_name)
# Reset temporary lists
self.channel_group_list = []
self.channel_group_list_name = []
def checkServer(self, schid, sname, suid, channelgroups, channelgroups_name):
s = self.db.exec_("SELECT * FROM server WHERE db_suid='"+str(suid)+"' LIMIT 1")
if not self.db.lastError().isValid():
# If server is known checkServerForUpdate() else insertServer()
if s.next(): self.checkServerForUpdate(schid, sname, suid, channelgroups, channelgroups_name)
else: self.insertServer(schid, sname, suid, channelgroups, channelgroups_name)
# This method inserts a new server into server table and channelgroups into channelgroups table
def insertServer(self, schid, sname, suid, channelgroups, channelgroups_name):
# Insert new Server in server table
i = self.db.exec_("INSERT INTO server (db_name, db_suid) VALUES ('%s', '%s')" % (sname,suid))
# Get new Server DB id
s = self.db.exec_("SELECT db_id FROM server WHERE db_suid='"+str(suid)+"' LIMIT 1")
if not self.db.lastError().isValid():
if s.next(): sid = s.value("db_id")
# Insert channelgroups
# Generating value string that goes into insert statemenet
# sid - channelgroup id - channelgroup name
channelgroup_insert_values = ""
for index, val in enumerate(channelgroups):
channelgroup_insert_values += "("+str(sid)+", '"+str(channelgroups[index])+"', '"+str(channelgroups_name[index])+"'),"
# remove last char
channelgroup_insert_values = channelgroup_insert_values[:-1]
# Insert all channelgroups + names
i = self.db.exec_("INSERT INTO channelgroups (db_sid, db_id, db_name) VALUES "+channelgroup_insert_values)
def checkServerForUpdate(self, schid, sname, suid, channelgroups, channelgroups_name):
sid = None
# Get Server DB id and name
s = self.db.exec_("SELECT * FROM server WHERE db_suid='"+str(suid)+"' LIMIT 1")
if not self.db.lastError().isValid():
if s.next():
sid = s.value("db_id")
# If servername changed then update new servername
if s.value("db_name") != sname:
u = self.db.exec_("UPDATE server SET db_name='%s' WHERE db_suid='%s' " % (sname,suid))
# Temporary vars for DB output
check_channelgroups = []
check_channelgroups_name = []
s = self.db.exec_("SELECT db_id, db_name FROM channelgroups WHERE db_sid = "+str(sid))
if not self.db.lastError().isValid():
# Add all DB channelgroups to temporary vars
while s.next():
check_channelgroups.append(s.value("db_id"))
check_channelgroups_name.append(s.value("db_name"))
# If new channelgroups dont match db channelgroups then dump db data and insert new
if check_channelgroups != channelgroups or check_channelgroups_name != channelgroups_name:
# Delete all channelgroups from channelgroups table
d = self.db.exec_("DELETE FROM channelgroups WHERE db_sid='"+str(sid)+"'")
# Insert channelgroups
# Generating value string that goes into insert statemenet
# sid - channelgroup id - channelgroup name
channelgroup_insert_values = ""
for index, val in enumerate(channelgroups):
channelgroup_insert_values += "("+str(sid)+", '"+str(channelgroups[index])+"', '"+str(channelgroups_name[index])+"'),"
# remove last char
channelgroup_insert_values = channelgroup_insert_values[:-1]
# Insert all channelgroups + names
i = self.db.exec_("INSERT INTO channelgroups (db_sid, db_id, db_name) VALUES %s" % (channelgroup_insert_values))
# Show Changes dialog
self.changesdlg = ChangesDialog(self)
self.changesdlg.show()
self.changesdlg.raise_()
self.changesdlg.activateWindow()
def onClientKickFromChannelEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, kickerID, kickerName, kickerUniqueIdentifier, kickMessage):
# Own client ID and own channel
(error, myid) = ts3.getClientID(schid)
(error, mych) = ts3.getChannelOfClient(schid, myid)
if oldChannelID == mych and not myid == kickerID:
(error, cuid) = ts3.getClientVariableAsString(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
(error, cname) = ts3.getClientVariableAsString(schid, clientID, ts3defines.ClientProperties.CLIENT_NICKNAME)
status = self.contactStatus(kickerUniqueIdentifier)
kickerName_show = "[color=black]"+kickerName+"[/color]"
if status == 0: friend = kickerName_show = "[color=#02D110]"+kickerName+"[/color]"
ts3.printMessage(schid, "[color=black]‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾[/color]", ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
ts3.printMessage(schid, "[URL=client://"+str(clientID)+"/"+str(cuid)+"~"+cname+"][color=black]"+cname+"[/color][/URL] [color=black]was kicked by[/color] [URL=client://"+str(kickerID)+"/"+str(kickerUniqueIdentifier)+"~"+kickerName+"]"+kickerName_show+"[/URL]", ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
ts3.printMessage(schid, "[color=black]_____________________________________[/color]", ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moveMessage):
self.doContactActions(schid, clientID)
def onClientDisplayNameChanged(self, schid, clientID, displayName, uid):
QTimer.singleShot(200, lambda : self.doContactActions(schid, clientID))
def doContactActions(self, schid, clientID):
# Own client ID and own channel
(error, myid) = ts3.getClientID(schid)
(error, mych) = ts3.getChannelOfClient(schid, myid)
(error, cch) = ts3.getChannelOfClient(schid, clientID)
(error, isDefaultChannel) = ts3.getChannelVariableAsInt(schid, mych, ts3defines.ChannelProperties.CHANNEL_FLAG_DEFAULT)
# Only react if client joins my channel and at least one setting is activated
if not isDefaultChannel == 1 and cch == mych and not myid == clientID and (self.settings["f_channelgroup"] or self.settings["f_talkpower"] or self.settings["b_channelgroup"] or self.settings["b_kick"]):
# Contact status check
(error, cuid) = ts3.getClientVariableAsString(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
status = self.contactStatus(cuid)
# Only react if friend or blocked joined the channel
if status == 0 or status == 1:
# blocked
if status == 1:
# Assign blocked channelgroup
if self.settings["b_channelgroup"]:
channelgroup = self.setClientChannelGroup(schid, 1, clientID, mych)
# kick blocked
if self.settings["b_kick"]:
ts3.requestClientKickFromChannel(schid, clientID, self.settings["b_kick_message"], self.error_kickFromChannel)
(error, new_cch) = ts3.getChannelOfClient(schid, clientID)
# Send message to blocked user if kick was valid
if not new_cch == mych and self.settings["b_message"]:
ts3.requestSendPrivateTextMsg(schid, self.settings["b_message_message"], clientID, self.error_sendMessage)
# freinds
if status == 0:
# Assign friends channelgroup
if self.settings["f_channelgroup"]:
self.setClientChannelGroup(schid, 0, clientID, mych)
# Grant friends talkpower
if self.settings["f_talkpower"]:
ts3.requestClientSetIsTalker(schid, clientID, True, self.error_setClientTalkpower)
# Send message to friends
if self.settings["f_message"]:
ts3.requestSendPrivateTextMsg(schid, self.settings["f_message_message"], clientID, self.error_sendMessage)
def contactStatus(self, uid):
# --------------------------------------------
# Returns:
# 2 = Normal user
# 1 = Blocked user
# 0 = Friend
# --------------------------------------------
status = 2
s = self.db_c.exec_("SELECT * FROM contacts WHERE value LIKE '%%IDS="+str(uid)+"%%' LIMIT 1")
if not self.db.lastError().isValid():
if s.next():
val = s.value("value")
for l in val.split('\n'):
if l.startswith('Friend='):
status = int(l[-1])
return status
def setClientChannelGroup(self, schid, status, cid, chid):
(error, suid) = ts3.getServerVariableAsString(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
(error, curr_channelgroup) = ts3.getClientVariableAsString(schid, cid, ts3defines.ClientPropertiesRare.CLIENT_CHANNEL_GROUP_ID)
db = self.db.exec_("SELECT db_f_channelgroup, db_b_channelgroup FROM server WHERE db_suid='"+str(suid)+"' LIMIT 1")
if not self.db.lastError().isValid():
if db.next():
if status == 1 and (db.value("db_b_channelgroup") == "" or db.value("db_b_channelgroup") == int(curr_channelgroup)): return
if status == 0 and (db.value("db_f_channelgroup") == "" or db.value("db_f_channelgroup") == int(curr_channelgroup)): return
(error, cdbid) = ts3.getClientVariableAsUInt64(schid, cid, ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
group = None
if status == 1: group = db.value("db_b_channelgroup")
if status == 0: group = db.value("db_f_channelgroup")
ts3.requestSetClientChannelGroup(schid, [group], [chid], [cdbid], self.error_setClientChannelGroup)
# Catching Plguin Errors
def onServerErrorEvent(self, schid, errorMessage, error, returnCode, extraMessage):
if returnCode == self.error_sendMessage or returnCode == self.error_kickFromChannel or returnCode == self.error_setClientTalkpower or returnCode == self.error_setClientChannelGroup: return True
def onServerPermissionErrorEvent(self, schid, errorMessage, error, returnCode, failedPermissionID):
if returnCode == self.error_sendMessage or returnCode == self.error_kickFromChannel or returnCode == self.error_setClientTalkpower or returnCode == self.error_setClientChannelGroup: return True
def fakeChannel(self, schid, channelID):
err, ownID = ts3lib.getClientID(schid)
err, ownCID = ts3lib.getChannelOfClient(schid, ownID)
# channel = self.ts3host.getChannel(schid, channelID)
(error, name) = ts3lib.getChannelVariable(
schid, channelID, ts3defines.ChannelProperties.CHANNEL_NAME)
# name = name.encode("utf-8").decode(sys.stdout.encoding)
if not error and name:
ts3lib.setChannelVariableAsString(
schid, ownCID, ts3defines.ChannelProperties.CHANNEL_NAME,
self.str_replace(name))
"""
(error, phonetic) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NAME_PHONETIC)
if debug: print("err:", error, "CHANNEL_NAME_PHONETIC", phonetic)
if not error and phonetic: ts3lib.setChannelVariableAsString(schid, 0,ts3defines.ChannelPropertiesRare.CHANNEL_NAME_PHONETIC,phonetic)
(error, pw) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_FLAG_PASSWORD)
if debug: print("err:", error, "CHANNEL_FLAG_PASSWORD", pw)
if pw:
(err, path, _pw) = ts3lib.getChannelConnectInfo(schid, channelID)
if debug: print("err:", error, "_pw", _pw)
ts3lib.setChannelVariableAsString(schid, 0,ts3defines.ChannelProperties.CHANNEL_PASSWORD,_pw if _pw else ".")
"""
"""
(error, topic) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_TOPIC)
if debug: print("err:", error, "CHANNEL_TOPIC", topic)
if not error and topic: ts3lib.setChannelVariableAsString(schid, 0,ts3defines.ChannelProperties.CHANNEL_TOPIC,topic)
ts3lib.requestChannelDescription(schid, channelID)
(error, description) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_DESCRIPTION)
if debug: print("err:", error, "CHANNEL_DESCRIPTION", description)
if not error and description: ts3lib.setChannelVariableAsString(schid, 0,ts3defines.ChannelProperties.CHANNEL_DESCRIPTION,description.decode('utf-8'))
"""
"""
(error, neededtp) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER)
if debug: print("err:", error, "CHANNEL_NEEDED_TALK_POWER", neededtp)
if not error and neededtp: ts3lib.setChannelVariableAsInt(schid, 0,ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER,neededtp)
(error, codec) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC)
if debug: print("err:", error, "CHANNEL_CODEC", codec)
if not error and codec: ts3lib.setChannelVariableAsInt(schid, 0,ts3defines.ChannelProperties.CHANNEL_CODEC,codec)
(error, quality) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC_QUALITY)
if debug: print("err:", error, "CHANNEL_CODEC_QUALITY", quality)
if not error and quality: ts3lib.setChannelVariableAsInt(schid, 0,ts3defines.ChannelProperties.CHANNEL_CODEC_QUALITY,quality)
(error, latency) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC_LATENCY_FACTOR)
if debug: print("err:", error, "CHANNEL_CODEC_LATENCY_FACTOR", latency)
if not error and latency: ts3lib.setChannelVariableAsInt(schid, 0,ts3defines.ChannelProperties.CHANNEL_CODEC_LATENCY_FACTOR,latency)
(error, unencrypted) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_CODEC_IS_UNENCRYPTED)
if debug: print("err:", error, "CHANNEL_CODEC_IS_UNENCRYPTED", unencrypted)
if not error and unencrypted: ts3lib.setChannelVariableAsInt(schid, 0,ts3defines.ChannelProperties.CHANNEL_CODEC_IS_UNENCRYPTED,unencrypted)
(error, maxclients) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS)
if debug: print("err:", error, "CHANNEL_MAXCLIENTS", maxclients)
if not error and maxclients: ts3lib.setChannelVariableAsInt(schid, 0,ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS,maxclients)
(error, maxfamilyclients) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXFAMILYCLIENTS)
if debug: print("err:", error, "CHANNEL_MAXFAMILYCLIENTS", maxfamilyclients)
if not error and maxfamilyclients: ts3lib.setChannelVariableAsInt(schid, 0,ts3defines.ChannelProperties.CHANNEL_MAXFAMILYCLIENTS,maxfamilyclients)
(error, iconid) = ts3lib.getChannelVariable(schid, channelID, ts3defines.ChannelPropertiesRare.CHANNEL_ICON_ID)
if debug: print("err:", error, "CHANNEL_ICON_ID", iconid)
if not error and iconid: ts3lib.setChannelVariableAsInt(schid, 0,ts3defines.ChannelPropertiesRare.CHANNEL_ICON_ID,iconid)
"""
self.retcode = ts3lib.createReturnCode()
err = ts3lib.flushChannelUpdates(schid, ownCID, self.retcode)
_err, errmsg = ts3lib.getErrorMessage(err)
print("ts3lib.flushChannelUpdates", "schid:", schid, "ownID:", ownID,
"ownCID:", ownCID, "retcode", self.retcode, "err", err, "errmsg",
errmsg)
if err == ts3defines.ERROR_ok: return
err = ts3lib.flushChannelCreation(schid, 0, self.retcode)
_err, errmsg = ts3lib.getErrorMessage(err)
print("ts3lib.flushChannelCreation", "schid:", schid, "0", "retcode",
self.retcode, "err", err, "errmsg", errmsg)
def revokeTalkPower(self, schid, clid, revoke=True):
self.retcode = ts3lib.createReturnCode()
ts3lib.requestClientSetIsTalker(schid, clid, not revoke, self.retcode)
