public static async Task InitBot(ConnectionConfig config) { Header(); Logger.Warn("Loading TSQB..."); _tsClient = new TeamSpeakClient(config.Ip, config.QueryPort); try { await _tsClient.Connect(); await _tsClient.Login(config.QueryLogin, config.QueryPassword); await _tsClient.UseServer(config.ServerId); await _tsClient.ChangeNickName(config.QueryNickname); await _tsClient.RegisterServerNotification(); await _tsClient.RegisterTextPrivateNotification(); await _tsClient.RegisterChannelNotification(0); await EventsManager.HandleEvents(_tsClient); await CommandsManager.HandleCommands(_tsClient); Logger.Info("Welcome abort captain, all systems online."); await KeepAlive(); } catch (Exception ex) { Logger.Fatal(ex, "An error has been detected!"); Environment.Exit(-1); } }
public async static Task <IReadOnlyList <TeamSpeak3QueryApi.Net.Specialized.Responses.GetServerListInfo> > GetServerinfo() { try { var rc = new TeamSpeakClient(host); await rc.Connect(); await rc.Login(username, pass); await rc.UseServer(1); await rc.WhoAmI(); await rc.RegisterServerNotification(); await rc.RegisterChannelNotification(30); var servers = await rc.GetServers(); await rc.Logout(); return(servers); } catch { } return(null); }
private async Task InternalStart() { _teamSpeakClient = new TeamSpeakClient(_settings.Teamspeak.Host, _settings.Teamspeak.Port); _logger.LogInformation("Starting teamspeak client..."); await _teamSpeakClient.Connect(); await _teamSpeakClient.Login(_settings.Teamspeak.Username, _settings.Teamspeak.Key); _logger.LogInformation("Teamspeak bot connected"); await _teamSpeakClient.UseServer(1); _logger.LogInformation("Server changed"); var me = await _teamSpeakClient.WhoAmI(); _logger.LogInformation($"Connected using username {me.NickName}"); _nicknamesCache.Clear(); var clients = await _teamSpeakClient.GetClients(); foreach (var client in clients) { _nicknamesCache.AddOrUpdate(client.Id, client.NickName, (i, s) => client.NickName); } await _teamSpeakClient.RegisterServerNotification(); _teamSpeakClient.Subscribe <ClientEnterView>(UserEntered); _teamSpeakClient.Subscribe <ClientLeftView>(UserLeft); _system.Actor <TelegramMessageChannel>().Tell(new MessageArgs <string>(_settings.Telegram.HostGroupId, "[TEAMSPEAK_ACTOR] I'm alive")); }
private static async Task CollectOnlineTime(TeamSpeakClient bot, DateTime lastRun) { Console.WriteLine("[>] Collecting online time"); var clients = await bot.GetClients(); var clientInfos = new List <GetClientDetailedInfo>(); foreach (var cl in clients.Where(c => c.Type == ClientType.FullClient)) { clientInfos.Add(await bot.GetClientInfo(cl.Id)); } var trackedClients = new List <GetClientDetailedInfo>(); foreach (var cl in clientInfos.Where(c => c.ServerGroupIds.Any(id => ConfigManager.Config.UserGroups.Contains(id)))) { trackedClients.Add(cl); } bool anyChange = false; foreach (var ci in trackedClients) { anyChange |= UpdateClientTime(lastRun, ci); } if (anyChange) { ClientManager.Save(); } }
public async Task <ConnectionResult> Login(String LoginName, String LoginPass, String Server, int VServerID = 1) { TSClient = new TeamSpeakClient(Server); this.VServerID = VServerID <= 0 ? VServerID : 1; try { //TSClient. await TSClient.Connect(); await TSClient.Login(LoginName, LoginPass); await TSClient.UseServer(this.VServerID); } catch (SocketException e) { Console.WriteLine(e.Message); return(ConnectionResult.SOCKET); } catch (TeamSpeak3QueryApi.Net.QueryException e) { Console.WriteLine(e.Error.Message); return(ConnectionResult.QUERY); } catch (Exception e) { Console.WriteLine(e.Message); return(ConnectionResult.UNKNOWN); } return(ConnectionResult.OK); }
private async Task InitTSQuery() { tsQuery = new TeamSpeakClient(TeamspeakQueryAddress, TeamspeakQueryPort); // Create rich client instance try { await tsQuery.Connect(); // connect to the server await tsQuery.Login(TeamspeakLogin, TeamspeakPassword); // login to do some stuff that requires permission await tsQuery.UseServer(1); // Use the server with id '1' var me = await tsQuery.WhoAmI(); // Get information about yourself! var channel = (await tsQuery.FindChannel(TeamspeakChannel)).FirstOrDefault(); Utils.Delay(100, false, async() => await UpdateTeamspeak(channel) ); } catch (QueryException ex) { Console.WriteLine(ex.ToString()); } }
public async static Task <List <TeamSpeak3QueryApi.Net.Specialized.Responses.GetClientInfo> > GetClients() { try { var rc = new TeamSpeakClient(host); await rc.Connect(); await rc.Login(username, pass); await rc.UseServer(1); await rc.WhoAmI(); await rc.RegisterServerNotification(); await rc.RegisterChannelNotification(30); var serverGroups = await rc.GetServerGroups(); var firstNormalGroup = serverGroups?.FirstOrDefault(s => s.ServerGroupType == ServerGroupType.NormalGroup); var groupClients = await rc.GetServerGroupClientList(firstNormalGroup.Id); var currentClients = await rc.GetClients(); var fullClients = currentClients.Where(c => c.Type == ClientType.FullClient).ToList(); await rc.Logout(); return(fullClients); } catch { } return(null); }
private static async Task PokeAdmins(TeamSpeakClient tsClient, ClientMoved client) { var channelId = 2; var groupToPoke = 6; var clients = await tsClient.GetClients(); var toPoke = await tsClient.GetServerGroupClientList(groupToPoke); if (client.TargetChannel == channelId) { foreach (var clid in client.ClientIds) { var clientInfo = await tsClient.GetClientInfo(clid); await tsClient.SendMessage($"Witaj {clientInfo.NickName} na kanale pomocy!", MessageTarget.Private, clid); await tsClient.SendMessage($"Za chwilę jakiś administrator udzieli Ci pomocy.", MessageTarget.Private, clid); foreach (var admin in toPoke) { var seriuslyToPoke = clients.Where(c => c.DatabaseId == admin.ClientDatabaseId); foreach (var oknow in seriuslyToPoke) { await tsClient.PokeClient(oknow.Id, "Ktos czeka na kanale pomocy!"); } } } } }
public async Task <bool> EnsureConnected() { if (_tsClientConnection == null) { _tsClientConnection = await CreateConnection(); } return(_tsClientConnection != null); }
public static Task SendOfflineMessage(this TeamSpeakClient tsclient, String uid, String message, String subject = "Message from GameBot") { message = message ?? string.Empty; return(tsclient.Client. Send("messageadd", new Parameter("cluid", uid), new Parameter("subject", subject), new Parameter("message", message))); }
public static String Quit(this TeamSpeakClient tsclient) { if (tsclient != null) { tsclient.Client.Send("quit"); return("OK"); } return("ERROR"); }
private static async Task WelcomeMessage(TeamSpeakClient tsClient, ClientEnterView client) { await tsClient.SendMessage($"Welcome {client.NickName}!", MessageTarget.Private, client.Id); await tsClient.SendMessage($"Today is {DateTime.Today.ToString(CultureInfo.CurrentCulture)}!", MessageTarget.Private, client.Id); await tsClient.SendMessage($"Your UID is {client.Uid}.", MessageTarget.Private, client.Id); await tsClient.SendMessage("Have a nice day!", MessageTarget.Private, client.Id); }
public TeamspeakLiveService(TeamspeakConfiguration teamspeakConfiguration, IMediator mediator, ILogger <TeamspeakLiveService> logger) { _teamspeakConfiguration = teamspeakConfiguration; _mediator = mediator; _logger = logger; _teamspeakClient = new TeamSpeakClient(teamspeakConfiguration.Host, teamspeakConfiguration.Port); _usernameCache = new ConcurrentDictionary <int, string>(); }
private static async Task <TeamSpeakClient> GetConnectedClient() { var bot = new TeamSpeakClient(ConfigManager.Config.Host, ConfigManager.Config.Port); await bot.Connect(); await bot.Login(ConfigManager.Config.QueryUsername, ConfigManager.Config.QueryPassword); await bot.UseServer((await bot.GetServers()).FirstOrDefault().Id); return(bot); }
private static async Task HelloWorld(TeamSpeakClient tsClient, TextMessage client, params object[] args) { if (args.Length != 0) { var arguments = String.Join(" ", args); await tsClient.SendMessage($"You said: {arguments}", MessageTarget.Private, client.InvokerId); } else { await tsClient.SendMessage("You said nothing! :(", MessageTarget.Private, client.InvokerId); } }
public static async Task HandleEvents(TeamSpeakClient tsClient) { try { await OnClientJoin(tsClient); await OnClientMoved(tsClient); } catch (Exception e) { Logger.Fatal(e, "An error has been detected!"); } }
public TeamSpeakUserChecker(AppSettings settings) { _settings = settings; _username = settings.TeamSpeakUserName; _password = settings.TeamSpeakPassword; _serverPort = settings.TeamSpeakServerPort; _serverIp = settings.TeamSpeakServerIp; _tsClientConnection = CreateConnection().Result; _clients = new List <GetClientInfo>(); }
public async Task ConnectAndLogin() { try { dbid = Convert.ToInt32(configuration.GetSection("Teamspeak:DatabaseID").Value); string server = configuration.GetSection("Teamspeak:Server").Value; string port = configuration.GetSection("Teamspeak:Port").Value; string username = configuration.GetSection("Teamspeak:Username").Value; string password = configuration.GetSection("Teamspeak:Password").Value; nickname = configuration.GetSection("Nickname").Value; tsClient = new TeamSpeakClient(server, Convert.ToInt32(port)); // Create rich client instance await tsClient.Connect(); // connect to the server await tsClient.Login(username, password); // login to do some stuff that requires permission await tsClient.UseServer(1); // Use the server with id '1' #if DEBUG await tsClient.ChangeNickName(nickname + "_DEBUG"); #else await tsClient.ChangeNickName(nickname); #endif botClient = await tsClient.WhoAmI(); await tsClient.MoveClient(botClient.ClientId, 1); await tsClient.RegisterChannelNotification(1); tsClient.Subscribe <ClientMoved>(ClientMoved); await tsClient.RegisterTextChannelNotification(); tsClient.Subscribe <TextMessage>(ChatMessageReceived); var pChannel = await tsClient.GetChannels(); } catch (Exception e) { logger.LogWarning(e.Message); logger.LogWarning(e.StackTrace); } }
protected override void OnStart(string[] args) { try { _eventLog1.WriteEntry("Startings service"); // Update the service state to Start Pending. var serviceStatus = new ServiceStatus { dwCurrentState = ServiceState.SERVICE_START_PENDING, dwWaitHint = 100000 }; SetServiceStatus(ServiceHandle, ref serviceStatus); _configMonitor = new FileMonitor(string.Concat(System.Reflection.Assembly.GetEntryAssembly()?.Location, ".config")) { FileChanged = ConfigChanged }; _timer.Elapsed += OnElapsedTime; _timer.Interval = 120000; //number in milisecinds _timer.Enabled = true; _timer.Start(); _teamSpeakClient = ConnectToTeamspeak().Result; if (_teamSpeakClient == null) { serviceStatus.dwCurrentState = ServiceState.SERVICE_STOPPED; SetServiceStatus(ServiceHandle, ref serviceStatus); Stop(); return; } //Debugger.Launch(); _teamSpeakClient.Subscribe <ClientEnterView>(NewClientEntered); _channelList = GetChannelList().Result; // Update the service state to Running. _serverStatusMonitor = new FileMonitor(ConfigurationManager.AppSettings["ServerStatusPath"]) { FileChanged = ServerStatusChanged }; ServerStatusChanged(null, new FileSystemEventArgs(WatcherChangeTypes.Changed, Path.GetDirectoryName(ConfigurationManager.AppSettings["ServerStatusPath"]), Path.GetFileName(ConfigurationManager.AppSettings["ServerStatusPath"]))); serviceStatus.dwCurrentState = ServiceState.SERVICE_RUNNING; SetServiceStatus(ServiceHandle, ref serviceStatus); _eventLog1.WriteEntry("Started service"); } catch (Exception e) { _eventLog1?.WriteEntry($"Failed to start: {e.Message}", EventLogEntryType.Error); } }
static async void DoItRich() { var loginData = File.ReadAllLines("..\\..\\..\\logindata.secret"); var host = loginData[0].Trim(); var user = loginData[1].Trim(); var password = loginData[2].Trim(); var rc = new TeamSpeakClient(host); await rc.Connect(); await rc.Login(user, password); await rc.UseServer(1); await rc.WhoAmI(); await rc.RegisterServerNotification(); await rc.RegisterChannelNotification(30); var currentClients = await rc.GetClients(); var fullClients = currentClients.Where(c => c.Type == ClientType.FullClient).ToList(); //var fullClients = from c // in currentClients // where c.Type == ClientType.FullClient // select c; //fullClients.ForEach(async c=> await rc.KickClient(c, KickOrigin.Channel)); await rc.KickClient(fullClients, KickOrigin.Channel); //foreach (var client in fullClients) // await rc.KickClient(client.ClientId, KickTarget.Channel); // await rc.MoveClient(1, 1); // await rc.KickClient(1, KickTarget.Server); rc.Subscribe <ClientEnterView>(data => data.ForEach(c => Trace.WriteLine("Client " + c.NickName + " joined."))); rc.Subscribe <ClientLeftView>(data => data.ForEach(c => Trace.WriteLine("Client with id " + c.Id + " left (kicked/banned/left)."))); rc.Subscribe <ServerEdited>(data => Debugger.Break()); rc.Subscribe <ChannelEdited>(data => Debugger.Break()); rc.Subscribe <ClientMoved>(data => Debugger.Break()); Console.WriteLine("Done1"); }
public async Task Disconnect() { try { tsClient.Unsubscribe <ClientMoved>(ClientMoved); tsClient.Unsubscribe <TextMessage>(ChatMessageReceived); await tsClient.Logout(); tsClient.Dispose(); tsClient = null; } catch (Exception e) { logger.LogWarning(e.Message); logger.LogWarning(e.StackTrace); } }
private static async Task OnClientMoved(TeamSpeakClient tsClient) { var functions = ClientChannelChanged.AvailableFunctions; Logger.Info("OnClientMoved event has been loaded!"); tsClient.Subscribe <ClientMoved>(data => data.ForEach(client => { if (client != null) { functions.ForEach(async func => { await func(tsClient, client); }); } } )); }
static async Task Main(string[] args) { var loginData = File.ReadAllLines("..\\..\\..\\logindata.secret"); var host = loginData[0].Trim(); var user = loginData[1].Trim(); var password = loginData[2].Trim(); var rc = new TeamSpeakClient(host); await rc.Connect(); await rc.Login(user, password); await rc.UseServer(1); await rc.WhoAmI(); await rc.RegisterServerNotification(); await rc.RegisterChannelNotification(30); var serverGroups = await rc.GetServerGroups(); var firstNormalGroup = serverGroups?.FirstOrDefault(s => s.ServerGroupType == ServerGroupType.NormalGroup); var groupClients = await rc.GetServerGroupClientList(firstNormalGroup.Id); var currentClients = await rc.GetClients(); var fullClients = currentClients.Where(c => c.Type == ClientType.FullClient).ToList(); await rc.KickClient(fullClients, KickOrigin.Channel); // await rc.MoveClient(1, 1); // await rc.KickClient(1, KickTarget.Server); rc.Subscribe <ClientEnterView>(data => data.ForEach(c => Debug.WriteLine($"Client {c.NickName} joined."))); rc.Subscribe <ClientLeftView>(data => data.ForEach(c => Debug.WriteLine($"Client with id {c.Id} left (kicked/banned/left)."))); rc.Subscribe <ServerEdited>(data => Debugger.Break()); rc.Subscribe <ChannelEdited>(data => Debugger.Break()); rc.Subscribe <ClientMoved>(data => Debugger.Break()); Console.WriteLine("Done"); Console.ReadLine(); }
public bool CheckConnection(bool reconnect = false) { bool CheckFunc() => (TeamSpeakClient?.Client?.Client?.Connected ?? false) && (TeamSpeakClient?.Client?.IsConnected ?? false); if (CheckFunc()) { return(true); } if (!reconnect) { return(CheckFunc()); } try { lock (_ts3ClientSyncRoot) { if (CheckFunc()) { return(true); } if ((_lastReconnectTry + _ts3ServerInfo.QueryReconnectTimeout) > DateTime.Now) { return(false); } _lastReconnectTry = DateTime.Now; TeamSpeakClient?.Dispose(); TeamSpeakClient = new TeamSpeakClient(_ts3ServerInfo.QueryHostname, _ts3ServerInfo.QueryPort); TeamSpeakClient.ConnectAndInitConnection(_ts3ServerInfo).Wait(); } } catch (Exception ex) when(ex is QueryException || ex is QueryProtocolException) { //TODO: LOG return(false); } return(CheckFunc()); }
private async Task <TeamSpeakClient> CreateConnection() { try { var conn = new TeamSpeakClient(_serverIp, _serverPort); await conn.Connect(); await conn.Login(_username, _password); await conn.UseServer(1); return(conn); } catch (Exception e) { Console.WriteLine(e); } return(null); }
private async Task <TeamSpeakClient> ConnectToTeamspeak() { try { var rc = new TeamSpeakClient(ConfigurationManager.AppSettings["TS_IP"]); // Create rich client instance await rc.Connect(); // connect to the server await rc.Login(ConfigurationManager.AppSettings["TS_USER"], ConfigurationManager.AppSettings["TS_PASSWORD"]); // login to do some stuff that requires permission await rc.UseServer(1); // Use the server with id '1' await rc.RegisterServerNotification(); //rc.Subscribe<ClientEnterView>(Test); return(rc); } catch (Exception ex) { _eventLog1?.WriteEntry($"Failed to connect to ts3: {ex.Message}", EventLogEntryType.Error); return(null); } }
private static async Task SetTopList(TeamSpeakClient bot) { if (!ClientManager.Clients.Any()) { Console.WriteLine("[!] Couldn't update channel info: no users! =========="); return; } Console.WriteLine("[>] Updating channel info"); var topUsers = ClientManager.Clients.OrderByDescending(x => x.ActiveTime).ToArray(); var channelName = FormatChannelName(topUsers.FirstOrDefault());; var channelInfo = await bot.GetChannelInfo(ConfigManager.Config.ChannelId); var editInfo = new EditChannelInfo(); editInfo.Description = FormatChannelDescription(topUsers); if (channelInfo.Name != channelName) { editInfo.Name = channelName; } await bot.EditChannel(ConfigManager.Config.ChannelId, editInfo); }
public static async Task HandleCommands(TeamSpeakClient tsClient) { var commands = Commands.AvailableFunctions; Logger.Info("Commands have been loaded!"); tsClient.Subscribe <TextMessage>(data => data.ForEach(async client => { if (client != null) { if (client.InvokerUid == "serveradmin") { return; } if (client.Message.StartsWith("!")) { var usedcommand = client.Message.Split(" "); var commandName = usedcommand[0].Replace("!", ""); if (commands.ContainsKey(commandName)) { var arguments = usedcommand.Skip(1).Where(x => !String.IsNullOrEmpty(x)).ToArray(); await commands[commandName](tsClient, client, arguments); } else { await tsClient.SendMessage("This command does not exists.", MessageTarget.Private, client.InvokerId); } } else { await tsClient.SendMessage("Use a valid command starting with [b]`!`[/b].", MessageTarget.Private, client.InvokerId); } } })); }
private async void Run() { var loginData = File.ReadAllLines("..\\..\\..\\logindata.secret"); var token = loginData[0].Trim(); var rc = new TeamSpeakClient(); await rc.Connect(); await rc.Auth(token); await rc.RegisterNotification(Event.Any); var whoami = await rc.WhoAmI(); Console.WriteLine($"I am client {whoami.ClientId} in channel {whoami.ChannelId}."); var selected = await rc.Use(); Console.WriteLine($"Currently looking at connection {selected.ServerConnectionHandlerId}."); var serverVariable = await rc.GetServerVariable(ServerVariable.Name, ServerVariable.Platform, ServerVariable.Version, ServerVariable.Created, ServerVariable.CodecEncryptionMode, ServerVariable.DefaultServerGroup, ServerVariable.DefaultChannelGroup, ServerVariable.HostbannerUrl, ServerVariable.HostbannerGfxUrl, ServerVariable.HostbannerGfxInterval, ServerVariable.PrioritySpeakerDimmModificator, ServerVariable.Id, ServerVariable.HostbuttonTooltip, ServerVariable.HostbuttonUrl, ServerVariable.HostbuttonGfxUrl, ServerVariable.NamePhonetic, ServerVariable.IconId, ServerVariable.Ip, ServerVariable.AskForPrivilegekey, ServerVariable.HostbannerMode); Console.WriteLine($"My server is called {serverVariable.Name} running version {serverVariable.Version}."); var connections = await rc.GetConnectionList(); Console.WriteLine($"I have {connections.Count} active connections."); var myChannel = await rc.GetChannelInfo(whoami.ChannelId); Console.WriteLine($"I am currently in channel {myChannel.Path} on {serverVariable.Name}."); var channelClients = await rc.GetChannelClients(whoami.ChannelId); Console.WriteLine($"There are {channelClients.Count} users in my channel."); rc.Subscribe <CurrentServerConnectionChanged>(data => Console.WriteLine($"Switched active connection to {data.First().ServerConnectionHandlerId}")); rc.Subscribe <TalkStatusChange>(data => { var stuff = data.First(); if (stuff.ServerConnectionHandlerId != selected.ServerConnectionHandlerId) { return; } var clientName = channelClients.First(c => c.ClientId == stuff.Id).Name ?? $"Unknown {stuff.Id}"; if (stuff.IsTalking) { Console.WriteLine($"{serverVariable.Name}: {clientName} started talking"); } else { Console.WriteLine($"{serverVariable.Name}: {clientName} stopped talking"); } }); }
private void ChangeUserLobby(UserTeam userTeam, ClientEnterView clientEnterView = null) { try { if (_teamSpeakClient == null || !_teamSpeakClient.Client.IsConnected) { _teamSpeakClient = ConnectToTeamspeak().Result; } if (_channelList == null || _channelList.Count == 0) { _channelList = GetChannelList().Result; } var currentClients = GetClients().Result; if (currentClients == null) { if (ConfigurationManager.AppSettings["Debug"] == "True") { _eventLog1.WriteEntry($"Failed to retrieve CurrentClients"); } return; } TsUser tsUser; if (clientEnterView != null) { tsUser = new TsUser { ChannelId = clientEnterView.TargetChannelId, UserId = clientEnterView.Id, UserName = clientEnterView.NickName }; } else { var user = currentClients.FirstOrDefault(x => string.Equals(x.NickName, userTeam.TsUser, StringComparison.CurrentCultureIgnoreCase)); if (user == null) { if (ConfigurationManager.AppSettings["Debug"] == "True") { _eventLog1.WriteEntry($"User: {userTeam.TsUser} not found in ts3"); } return; } tsUser = new TsUser { ChannelId = user.ChannelId, UserId = user.Id, UserName = user.NickName }; } if (ConfigurationManager.AppSettings["Debug"] == "True") { _eventLog1.WriteEntry($"User: {userTeam.TsUser} found in ts3"); } var channel = _channelList.FirstOrDefault(x => x.Name == userTeam.TsChannel); if (channel == null) { if (ConfigurationManager.AppSettings["Debug"] == "True") { _eventLog1.WriteEntry($"Channel: {userTeam.TsChannel} not found in ts3"); } return; } if (ConfigurationManager.AppSettings["Debug"] == "True") { _eventLog1.WriteEntry($"Channel: {userTeam.TsChannel} found in ts3 for user {userTeam.TsUser}"); } if (channel.Id == tsUser.ChannelId) { if (ConfigurationManager.AppSettings["Debug"] == "True") { _eventLog1.WriteEntry($"User: {userTeam.TsUser} is already in channel: {channel.Name}"); } return; } if (ConfigurationManager.AppSettings["Debug"] == "True") { _eventLog1.WriteEntry($"Change user: {tsUser.UserName} to channel {channel.Name}"); } _teamSpeakClient.MoveClient(tsUser.UserId, channel.Id); } catch (Exception e) { _eventLog1.WriteEntry(e.Message, EventLogEntryType.Error); } }