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