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 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 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 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 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)