cahnge startup logtype

-change disconnect event logic to target the correct target when removing Guest tag.

.gitignore

@@ -245,3 +245,5 @@ launchSettings.json
 /Tests/ApplicationTests/Files/replay.json
 /GameLogServer/game_log_server_env
 *.bak
+/TebexApiClient.cs
+/Models

ClanTag.cs

@@ -3,7 +3,7 @@ using SharedLibraryCore.Database.Models;
 using SharedLibraryCore;
 using SharedLibraryCore.Interfaces;
 
-namespace ClanTagRankApi
+namespace ClanTagRankCommands
 {
 
     static class ExtensionMethods
@@ -20,7 +20,7 @@ namespace ClanTagRankApi
             switch ((int)level)
             {
                 case -1:
-                    rankName = "Banned";  //this typically won't be seen. 
+                    rankName = "Flagged";  //this typically won't be seen. 
                     break;
                 case 0:
                     rankName = Config.User;

ClanTagRankCommands.csproj

@@ -2,15 +2,21 @@
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <ApplicationIcon />
     <StartupObject />
     <Configurations>Debug;Release;Prerelease</Configurations>
-    <LangVersion>7.1</LangVersion>
+    <LangVersion>10</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2020.11.18.1" PrivateAssets="All" />
+    <Compile Remove="GscApiController.cs" />
+    <Compile Remove="TebexApiClient.cs" />
+    <Compile Remove="unusedClanTag.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.10.13.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Commands/GetRankCommand.cs

@@ -0,0 +1,93 @@
+//using SharedLibraryCore;
+//using SharedLibraryCore.Commands;
+//using SharedLibraryCore.Configuration;
+//using SharedLibraryCore.Database.Models;
+//using SharedLibraryCore.Interfaces;
+//using System.Threading.Tasks;
+
+
+//namespace ClanTagRankCommands.Commands
+//{
+
+//    /// <summary>
+//    /// Example script command
+//    /// </summary>
+//    /// 
+
+//    public class GetRankCommand : Command
+//    {
+//        readonly string rank = "rank";
+//        string rank_string;
+//        private readonly IMetaServiceV2 _metaService;
+//        private readonly IConfigurationHandler<Configuration> _configurationHandler;
+//        private Configuration Config;
+
+
+//        public GetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
+//        {
+//            _metaService = metaService;
+//            _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
+//            if (_configurationHandler.Configuration() == null)
+//            {
+//                _configurationHandler.Set((Configuration)new Configuration().Generate());
+//                _configurationHandler.Save();
+//            }
+//            Config = _configurationHandler.Configuration();
+
+//            Name = "GetRank";
+//            Description = "Get a user's clan tag Rank (does not give permissions)";
+//            Alias = "Gr";
+//            Permission = EFClient.Permission.Trusted;
+//            RequiresTarget = true;
+//            Arguments = new[]
+//            {
+//                new CommandArgument()
+//                {
+//                }
+//            };
+
+//        }
+
+//        public override async Task ExecuteAsync(GameEvent E)
+//        {
+//            rank_string = "none";
+//            if(E.Target is not null)
+//            {
+//                var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
+//                if (rank_player_var == null)
+//                {
+//                    await _metaService.SetPersistentMeta(rank, "none", E.Target.ClientId);
+//                    rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
+//                }
+
+//                if (rank_string.Length > 0 && rank_string.Length < 9)
+//                {
+
+//                    //await _metaService.AddPersistentMeta(rank, rank_string, E.Target);
+//                    rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
+//                    if(rank_player_var.Value == "none" || rank_player_var.Value == "None" || rank_player_var.Value == "NONE")
+//                    {
+                    
+//                        //E.Origin.Tell(E.Target.Name + "'s rank has been reset");
+//                        rank_string = E.Target.Level.ClanTag(Config);
+//                        E.Origin.Tell("[" + rank_string + "]" + E.Target.Name );
+
+//                    }
+
+//                    else
+//                    {
+//                        rank_string = rank_player_var.Value;
+//                        E.Origin.Tell("[" + rank_player_var.Value + "]" + E.Target.Name);
+
+//                    }
+//                }
+
+
+
+
+                    
+//            }
+
+//        }
+//    }
+//}

Commands/InviteGuestCommand.cs

@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Data.Models;
+using Data.Models.Client;
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Dtos;
+using SharedLibraryCore.Interfaces;
+
+
+namespace ClanTagRankCommands.Commands
+{
+    public class InviteGuestCommand : Command
+    {
+        private readonly IMetaServiceV2 _metaService;
+
+
+        public InviteGuestCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) :
+            base(config, layout)
+        {
+            Name = "inviteGuest";
+            Description = "invite a guest to play on donator server (use !find to get @id to invite)";
+            Alias = "guest";
+            Permission = EFClient.Permission.Trusted;
+            RequiresTarget = true;
+            Arguments = new[]
+            {
+                new CommandArgument
+                {
+                    Name = "Player",
+                    Required = true
+                }
+            };
+
+            _metaService = metaService;
+        }
+
+        public override async Task ExecuteAsync(GameEvent gameEvent)
+        {
+            if (gameEvent.Target.Level >= gameEvent.Origin.Level && gameEvent.Origin.Level != EFClient.Permission.Creator)
+            {
+                gameEvent.Origin.Tell("You can't invite someone with the same or higher permissions than you");
+                return;
+            }
+            var token = gameEvent.Owner.Manager.CancellationToken;
+            var clienttag = await _metaService.GetPersistentMetaByLookup("ClientTagV2", "ClientTagNameV2", gameEvent.Target.ClientId, token);
+            if (gameEvent.Target is not null && gameEvent.Target.IsIngame && (gameEvent.Target.Tag is null))
+            {
+                
+                gameEvent.Target.Tell($"you have been temporarily invited to join Donator servers by {gameEvent.Origin.Name}");
+            }
+            if (gameEvent.Target is not null &&  clienttag is not null)
+            {
+                if ((clienttag?.Value.Contains("Guest") ?? false))
+                {
+                    gameEvent.Target.Tag = null;
+                    await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, gameEvent.Target.ClientId, gameEvent.Owner.Manager.CancellationToken);
+                    gameEvent.Target.Tell($"Your guest invite has been revoked by {gameEvent.Origin.Name}");
+                    gameEvent.Origin.Tell($"Guest invite has been revoked for {gameEvent.Target.Name}");
+                    return;
+
+                }
+                else if((clienttag?.Value.Contains("Donator") ?? false) || (clienttag?.Value.Contains("VIP") ?? false))
+                {
+                    gameEvent.Origin.Tell($"Can't set {clienttag?.Value} {gameEvent.Target.Name} to Guest, they already have a rank.");
+                    return;
+                }
+            }
+            else if(gameEvent.Target is null)
+            {
+                gameEvent.Origin.Tell($"Target player is undefined");
+                return;
+            }
+
+
+
+
+            var availableTags = await _metaService.GetPersistentMetaValue<List<LookupValue<string>>>(EFMeta.ClientTagNameV2, token);
+            var matchingTag = availableTags.FirstOrDefault(tag => tag.Value == "Guest".Trim());
+
+            gameEvent.Target.Tag = matchingTag.Value;
+            await _metaService.SetPersistentMetaForLookupKey(EFMeta.ClientTagV2, EFMeta.ClientTagNameV2, matchingTag.Id,
+                gameEvent.Target.ClientId, token);
+            gameEvent.Origin.Tell($"Temporarily set {gameEvent.Target.Name} to Guest");
+        }
+    }
+}

Commands/PermaperkCommand.cs

@@ -0,0 +1,98 @@
+//using SharedLibraryCore;
+//using SharedLibraryCore.Commands;
+//using SharedLibraryCore.Configuration;
+//using SharedLibraryCore.Database.Models;
+//using SharedLibraryCore.Interfaces;
+//using System.Threading.Tasks;
+//using ClanTagRankCommands;
+//using System;
+//using System.Runtime;
+
+//namespace ClanTagRankCommands.Commands
+//{
+//    /// <summary>
+//    /// Example script command
+//    /// </summary>
+//    public class PermaperkCommand : Command
+//    {
+//        private readonly IMetaService _metaService;
+//        private readonly IConfigurationHandler<Configuration> _configurationHandler;
+//        private Configuration Config;
+//        public PermaperkCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
+//        {
+//            _metaService = metaService;
+//            _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
+//            if (_configurationHandler.Configuration() == null)
+//            {
+//                _configurationHandler.Set((Configuration)new Configuration().Generate());
+//                _configurationHandler.Save();
+//            }
+//            Config = _configurationHandler.Configuration();
+//            Name = "Permaperk";
+//            Description = "force permaperks, clan tag, and speed if they don't set correctly.";
+//            Alias = "perma";
+//            Permission = EFClient.Permission.Trusted;
+//            RequiresTarget = false;
+//            Arguments = new[]
+//            {
+//                new CommandArgument()
+//                {
+//                }
+//            };
+//        }
+
+//        public override async Task ExecuteAsync(GameEvent E)
+//        {
+//            //await yadb.notifyYADB("Kicked player @{target} after a successful vote started from @{origin}", $"testing", E.Data,":pencil:", E.Owner, E.Origin, E.Origin);
+//            var speedtoggle = await _metaService.GetPersistentMeta("speedtoggle", E.Origin);
+//            if (speedtoggle == null)
+//            {
+//                // speedtoggle == 1 means slower, unmodified speed)
+//                await _metaService.AddPersistentMeta("speedtoggle", "0", E.Origin);
+//                speedtoggle = await _metaService.GetPersistentMeta("speedtoggle", E.Origin);
+//            }
+//            //await E.Owner.SetDvarAsync("sv_iw4madmin_options", "speedtoggle;" + E.Origin.ClientNumber.ToString() + ";" + speedtoggle.Value.ToString());
+
+//            if (E.Origin is not null && E.Origin.CurrentServer == E.Owner && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)
+//            {
+//                var rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
+//                var rankName = E.Origin.Level.ClanTag(Config);
+
+//                rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
+//                if (rank_player_var == null)
+//                {
+
+//                    await _metaService.AddPersistentMeta("rank", "none", E.Origin);
+//                    rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
+//                }
+
+//                if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
+//                {
+//                    rankName = rank_player_var.Value;
+
+//                }
+//                if (E.Origin is not null && E.Origin.CurrentServer == E.Owner && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)// && (E.Origin.Level > EFClient.Permission.Trusted || rankName != Config.User))
+//                {
+//                    if(string.IsNullOrWhiteSpace(rankName))
+//                    {
+
+//                    }
+//                    else
+//                    {
+//                        await E.Owner.ExecuteCommandAsync("setclantag" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
+//                        await E.Owner.ExecuteCommandAsync("setrole" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
+//                        E.Origin.Tell("Setting permaperks");
+//                    }
+
+//                    //await E.Owner.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Origin.ClientNumber.ToString() + ";" + rankName.ToString());
+//                }
+//            }
+
+
+
+//        }
+//    }
+//}
+
+
+

Commands/ResetRankCommand.cs

@@ -1,60 +1,81 @@
-using SharedLibraryCore;
-using SharedLibraryCore.Commands;
-using SharedLibraryCore.Configuration;
-using SharedLibraryCore.Database.Models;
-using SharedLibraryCore.Interfaces;
-using System;
-using System.Threading.Tasks;
+//using SharedLibraryCore;
+//using SharedLibraryCore.Commands;
+//using SharedLibraryCore.Configuration;
+//using SharedLibraryCore.Database.Models;
+//using SharedLibraryCore.Interfaces;
+//using System;
+//using System.Threading.Tasks;
 
 
 
-namespace ClanTagRankApi.Commands
-{
-    /// <summary>
-    /// Example script command
-    /// </summary>
-    public class ResetRankCommand : Command
-    {
-        readonly string rank = "rank";
-        string rank_string;
-        private readonly IMetaService _metaService;
-        private readonly IConfigurationHandler<Configuration> _configurationHandler;
-        private Configuration Config;
+//namespace ClanTagRankCommands.Commands
+//{
+//    /// <summary>
+//    /// Example script command
+//    /// </summary>
+//    public class ResetRankCommand : Command
+//    {
+//        readonly string rank = "rank";
+//        string rank_string;
+//        private readonly IMetaServiceV2 _metaService;
+//        private readonly IConfigurationHandler<Configuration> _configurationHandler;
+//        private Configuration Config;
 
-        public ResetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
-        {
-            _metaService = metaService;
-            _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
-            if (_configurationHandler.Configuration() == null)
-            {
-                _configurationHandler.Set((Configuration)new Configuration().Generate());
-                _configurationHandler.Save();
-            }
-            Config = _configurationHandler.Configuration();
+//        public ResetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
+//        {
+//            _metaService = metaService;
+//            _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
+//            if (_configurationHandler.Configuration() == null)
+//            {
+//                _configurationHandler.Set((Configuration)new Configuration().Generate());
+//                _configurationHandler.Save();
+//            }
+//            Config = _configurationHandler.Configuration();
 
-            Name = "ResetRank";
-            Description = "set a user's clan tag Rank (does not give permissions)";
-            Alias = "rr";
-            Permission = EFClient.Permission.Administrator;
-            RequiresTarget = true;
-            Arguments = new[]
-            {
-                new CommandArgument()
-                {
-                    //Name = "rank",
-                    //Required = false
-                }
-            };
-        }
+//            Name = "ResetRank";
+//            Description = "set a user's clan tag Rank (does not give permissions)";
+//            Alias = "rr";
+//            Permission = EFClient.Permission.Administrator;
+//            RequiresTarget = true;
+//            Arguments = new[]
+//            {
+//                new CommandArgument()
+//                {
+//                    //Name = "rank",
+//                    //Required = false
+//                }
+//            };
+//        }
 
-        public override async Task ExecuteAsync(GameEvent E)
-        {
-            //var S = E.Owner;
-            rank_string = "none";
-            await _metaService.AddPersistentMeta(rank, rank_string, E.Target);
-            rank_string = E.Target.Level.ClanTag(Config);
-            E.Origin.Tell(E.Target.Name + "'s rank has been reset to: " + rank_string);
-            await E.Owner.ExecuteCommandAsync("setrank" + " " + E.Target.ClientNumber + " " + rank_string);
-        }
-    }
-}
+//        public override async Task ExecuteAsync(GameEvent E)
+//        {
+//            //var S = E.Owner;
+//            rank_string = "none";
+//            if(E.Target is not null)
+//            {
+//                await _metaService.SetPersistentMeta(rank, rank_string, E.Target.ClientId);
+//                rank_string = E.Target.Level.ClanTag(Config);
+//                E.Origin.Tell(E.Target.Name + "'s rank has been reset to: " + rank_string);
+//                if (E.Target is not null && E.Target.IsIngame )
+//                {
+//                    if (string.IsNullOrWhiteSpace(rank_string))
+//                    {
+//                        await E.Owner.ExecuteCommandAsync("resetclantag" + " " + E.Target.ClientNumber.ToString());
+
+//                        await E.Owner.ExecuteCommandAsync("resetrole " + E.Target.ClientNumber.ToString());
+
+//                    }
+//                    else
+//                    {
+//                        await E.Owner.ExecuteCommandAsync("setclantag" + " " + E.Target.ClientNumber.ToString() + " " + rank_string.ToString());
+//                        //await E.Owner.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Target.ClientNumber.ToString() + ";" + rank_string.ToString());
+//                        await E.Owner.ExecuteCommandAsync("setrole " + E.Target.ClientNumber.ToString() + " " + rank_string.ToString());
+//                    }
+//                }
+
+
+//            }
+
+//        }
+//    }
+//}

Commands/SetDonatorCommand.cs

@@ -0,0 +1,215 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Policy;
+using System.Threading;
+using System.Threading.Tasks;
+using Data.Models;
+using Data.Models.Client;
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Dtos;
+using SharedLibraryCore.Interfaces;
+
+
+namespace ClanTagRankCommands.Commands
+{
+    public class SetDonatorCommand : Command
+    {
+        private readonly IMetaServiceV2 _metaService;
+        private readonly IRemoteCommandService _remoteCommandService;
+
+
+
+
+
+        public SetDonatorCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService, IRemoteCommandService remoteCommandService) :
+            base(config, layout)
+        {
+            Name = "SetDonator";
+            Description = "Sets a player to Donator rank";
+            Alias = "Donator";
+            Permission = EFClient.Permission.Moderator;
+            RequiresTarget = true;
+            Arguments = new[]
+            {
+                new CommandArgument
+                {
+                    Name = "Player",
+                    Required = true
+                }
+            };
+
+            _metaService = metaService;
+            _remoteCommandService = remoteCommandService;
+        }
+
+        public override async Task ExecuteAsync(GameEvent gameEvent)
+        {
+            var token = gameEvent.Owner.Manager.CancellationToken;
+
+            var availableTags = await _metaService.GetPersistentMetaValue<List<LookupValue<string>>>(EFMeta.ClientTagNameV2, token);
+            var matchingTag = availableTags.FirstOrDefault(tag => tag.Value == "Donator".Trim());
+            var clienttag = await _metaService.GetPersistentMetaByLookup("ClientTagV2", "ClientTagNameV2", gameEvent.Target.ClientId, token);
+            if (gameEvent.Target is not null && gameEvent.Target.IsIngame)
+            {
+                if (gameEvent.Target.Tag is null || gameEvent.Target.Tag.Contains("Guest"))
+                {
+                    gameEvent.Origin.Tell($"set {gameEvent.Target.Name}'s rank");
+                    if (gameEvent.Target.IsIngame)
+                    {
+                        gameEvent.Target.Tell($"Your rank has been set to Donator");
+                    }
+
+                    var args3 = new List<string>();
+                    args3.Add(matchingTag.Value);
+                    await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "sct",
+                        args3, gameEvent.Owner);
+                    //var sct = $"{Utilities.CommandPrefix}sct @{gameEvent.Target.ClientId} {matchingTag.Value}";
+                    //await gameEvent.Owner.ExecuteCommandAsync(sct);
+                    if (gameEvent.Target.Level < EFClient.Permission.Moderator && gameEvent.Target.Level != EFClient.Permission.Banned)
+                    {
+                        gameEvent.Target.SetLevel(EFClient.Permission.Trusted, gameEvent.Origin);
+                    }
+                }
+                else if (gameEvent.Target.Tag.Contains("Donator"))
+                {
+                    gameEvent.Origin.Tell($"Unset {gameEvent.Target.Name}'s rank");
+                    if (gameEvent.Target.IsIngame)
+                    {
+                        gameEvent.Target.Tell($"Your Donator rank has been removed");
+                    }
+
+                    //var uct = $"{Utilities.CommandPrefix}uct @{gameEvent.Target.ClientId}";
+                    //await gameEvent.Owner.ExecuteCommandAsync(uct);
+                    var args = new List<string>();
+                    var commandResponse =
+                    await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "uct",
+                        args, gameEvent.Owner);
+                    //string.Join(".", commandResponse.Select(result => result.Response));
+                    if (gameEvent.Target.Level < EFClient.Permission.Moderator && gameEvent.Target.Level != EFClient.Permission.Banned)
+                    {
+                        gameEvent.Target.SetLevel(EFClient.Permission.User, gameEvent.Origin);
+                    }
+
+
+
+                }
+
+                else if(gameEvent.Target.Tag is not null && !gameEvent.Target.Tag.Contains("Guest"))
+                {
+                    gameEvent.Origin.Tell($"Error! Can't set {gameEvent.Target.Name}'s tag, because a different tag is already set");
+                }
+            }
+            else if(gameEvent.Target is not null && !gameEvent.Target.IsIngame)
+            {
+                if (clienttag is null || (clienttag?.Value.Contains("Guest") ?? false))
+                {
+                    gameEvent.Origin.Tell($"set {gameEvent.Target.Name}'s rank");
+
+                    var args4 = new List<string>();
+                    args4.Add("Your rank has been set to Donator");
+                    await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "om",
+                        args4, gameEvent.Owner);
+                    //var om = $"{Utilities.CommandPrefix}om @{gameEvent.Target.ClientId} Your rank has been set to Donator";
+                    //await gameEvent.Owner.ExecuteCommandAsync(om);
+                    var args3 = new List<string>();
+                    args3.Add(matchingTag.Value);
+                    await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "sct",
+                        args3, gameEvent.Owner);
+                    //var sct = $"{Utilities.CommandPrefix}sct @{gameEvent.Target.ClientId} {matchingTag.Value}";
+                    //await gameEvent.Owner.ExecuteCommandAsync(sct);
+                    if (gameEvent.Target.Level < EFClient.Permission.Moderator && gameEvent.Target.Level != EFClient.Permission.Banned)
+                    {
+                        gameEvent.Target.SetLevel(EFClient.Permission.Trusted, gameEvent.Origin);
+                    }
+                }
+                else if ((clienttag?.Value.Contains("Donator") ?? false))
+                {
+                    gameEvent.Origin.Tell($"Unset {gameEvent.Target.Name}'s rank");
+
+
+                    //var om = $"{Utilities.CommandPrefix}om @{gameEvent.Target.ClientId} Your Donator rank has been removed";
+                    //await gameEvent.Owner.ExecuteCommandAsync(om);
+                    var args2 = new List<string>();
+                    args2.Add("Your Donator rank has been removed");
+                    await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "om",
+                        args2, gameEvent.Owner);
+
+                    //var uct = $"{Utilities.CommandPrefix}uct @{gameEvent.Target.ClientId}";
+                    //await gameEvent.Owner.ExecuteCommandAsync(uct);
+                    var args = new List<string>();
+                    var commandResponse =
+                    await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "uct",
+                        args, gameEvent.Owner);
+                    //string.Join(".", commandResponse.Select(result => result.Response));
+                    if (gameEvent.Target.Level < EFClient.Permission.Moderator && gameEvent.Target.Level != EFClient.Permission.Banned)
+                    {
+                        gameEvent.Target.SetLevel(EFClient.Permission.User, gameEvent.Origin);
+                    }
+
+
+
+                }
+
+                else if (gameEvent.Target.Tag is not null && clienttag is not null && !gameEvent.Target.Tag.Contains("Guest"))
+                {
+                    gameEvent.Origin.Tell($"Error! Can't set {gameEvent.Target.Name}'s tag, because a different tag is already set");
+                }
+            }
+            else if(gameEvent.Target is null)
+            {
+                gameEvent.Origin.Tell($"Error! target player is null");
+            }
+
+            //gameEvent.Target.Tag = matchingTag.Value;
+
+            //await _metaService.SetPersistentMetaForLookupKey(EFMeta.ClientTagV2, EFMeta.ClientTagNameV2, matchingTag.Id,
+            //    gameEvent.Target.ClientId, token);
+            //if (gameEvent.Target.Level < EFClient.Permission.Moderator)
+            //{
+            //    gameEvent.Target.SetLevel(EFClient.Permission.Trusted, gameEvent.Origin);
+            //}
+
+            //gameEvent.Origin.Tell($"Set {gameEvent.Target.Name} to Donator");
+            //if (gameEvent.Target.IsIngame)
+            //{
+            //    gameEvent.Target.Tell($"Your rank has been set to Donator!");
+            //}
+            //else
+            //{
+            //    var cmd = $"{Utilities.CommandPrefix}om @{gameEvent.Target.ClientId} Your rank has been set to Donator!";
+            //    await gameEvent.Owner.ExecuteCommandAsync(cmd);
+            //    //var impersonatedCommandEvent = new GameEvent
+            //    //{
+            //    //    Type = GameEvent.EventType.Command,
+            //    //    Origin = gameEvent.Origin,
+            //    //    //ImpersonationOrigin = gameEvent.Origin,
+            //    //    Message = cmd,
+            //    //    Data = cmd,
+            //    //    Owner = gameEvent.Owner,
+            //    //    CorrelationId = gameEvent.CorrelationId
+            //    //};
+            //    //gameEvent.Owner.Manager.AddEvent(impersonatedCommandEvent);
+
+            //    //var result = await impersonatedCommandEvent.WaitAsync(Utilities.DefaultCommandTimeout,
+            //    //    gameEvent.Owner.Manager.CancellationToken);
+            //    //await result.WaitAsync(Utilities.DefaultCommandTimeout, gameEvent.Owner.Manager.CancellationToken);
+
+            //    // remove the added command response
+            //    // todo: something weird happening making this change required
+            //    //var responses = gameEvent.Owner.Manager.ProcessingEvents
+            //    //    .Where(ev => ev.Value.CorrelationId == impersonatedCommandEvent.CorrelationId)
+            //    //    .SelectMany(ev => ev.Value.Output)
+            //    //    .ToList();
+
+            //    //foreach (var output in responses)
+            //    //    await gameEvent.Origin.Tell(_translationLookup["COMMANDS_RUN_AS_SUCCESS"].FormatExt(output))
+            //    //        .WaitAsync();
+
+            //}
+        }
+    }
+}
+
+

Commands/SetRankCommand.cs

@@ -6,7 +6,7 @@ using SharedLibraryCore.Interfaces;
 using System.Threading.Tasks;
 
 
-namespace ClanTagRankApi.Commands
+namespace ClanTagRankCommands.Commands
 {
 
     /// <summary>
@@ -18,12 +18,12 @@ namespace ClanTagRankApi.Commands
     {
         readonly string rank = "rank";
         string rank_string;
-        private readonly IMetaService _metaService;
+        private readonly IMetaServiceV2 _metaService;
         private readonly IConfigurationHandler<Configuration> _configurationHandler;
         private Configuration Config;
 
 
-        public SetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
+        public SetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
         {
             _metaService = metaService;
             _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
@@ -55,41 +55,61 @@ namespace ClanTagRankApi.Commands
             rank_string = "none";
             if (E.Data != null)
                 rank_string = E.Data;
-            var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
-            if (rank_player_var == null)
+            if(E.Target is not null)
             {
-                await _metaService.AddPersistentMeta(rank, "none", E.Target);
-                rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
-            }
-
-            if (rank_string.Length > 0 && rank_string.Length < 9)
-            {
-
-                await _metaService.AddPersistentMeta(rank, rank_string, E.Target);
-                rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
-                if(rank_player_var.Value == "none" || rank_player_var.Value == "None" || rank_player_var.Value == "NONE")
+                var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
+                if (rank_player_var == null)
                 {
-                    
-                    //E.Origin.Tell(E.Target.Name + "'s rank has been reset");
-                    rank_string = E.Target.Level.ClanTag(Config);
-                    E.Origin.Tell(E.Target.Name + "'s rank has been reset to: " + rank_string);
-
+                    await _metaService.SetPersistentMeta(rank, "none", E.Target.ClientId);
+                    rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
                 }
 
+                if (rank_string.Length > 0 && rank_string.Length < 9)
+                {
+
+                    await _metaService.SetPersistentMeta(rank, rank_string, E.Target.ClientId);
+                    rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
+                    if(rank_player_var.Value == "none" || rank_player_var.Value == "None" || rank_player_var.Value == "NONE")
+                    {
+                    
+                        //E.Origin.Tell(E.Target.Name + "'s rank has been reset");
+                        rank_string = E.Target.Level.ClanTag(Config);
+                        E.Origin.Tell(E.Target.Name + "'s rank has been reset to: " + rank_string);
+
+                    }
+
+                    else
+                    {
+                        rank_string = rank_player_var.Value;
+                        E.Origin.Tell("New rank set: [" + rank_player_var.Value + "]" + E.Target.Name);
+
+                    }
+                }
                 else
                 {
-                    rank_string = rank_player_var.Value;
-                    E.Origin.Tell("New rank set: [" + rank_player_var.Value + "]" + E.Target.Name);
-
+                    E.Origin.Tell($"invalid rank length (between 1-8 characters), set rank to none, or use !ResetRank to reset");
                 }
-            }
-            else
-            {
-                E.Origin.Tell($"invalid rank length (between 1-8 characters), set rank to none, or use !ResetRank to reset");
+
+                if(E.Target is not null && E.Target.IsIngame)
+                {
+                    if (string.IsNullOrWhiteSpace(rank_string))
+                    {
+                        await E.Owner.ExecuteCommandAsync("resetclantag" + " " + E.Target.ClientNumber.ToString());
+
+                        await E.Owner.ExecuteCommandAsync("resetrole " + E.Target.ClientNumber.ToString());
+
+                    }
+                    else
+                    {
+                        await E.Owner.ExecuteCommandAsync("setclantag" + " " + E.Target.ClientNumber.ToString() + " " + rank_string.ToString());
+                        
+                        await E.Owner.ExecuteCommandAsync("setrole " + E.Target.ClientNumber.ToString() + " " + rank_string.ToString());
+                    }
+                }
+
+                    
             }
 
-
-            await E.Owner.ExecuteCommandAsync("setrank" + " " + E.Target.ClientNumber + " " + rank_string);
         }
     }
 }

Configuration.cs

@@ -1,7 +1,7 @@
 
 using SharedLibraryCore.Interfaces;
 
-namespace ClanTagRankApi
+namespace ClanTagRankCommands
 {
     public class Configuration : IBaseConfiguration
     {
@@ -22,7 +22,7 @@ namespace ClanTagRankApi
         {
             //this.RestartTimerLength = Utilities.PromptInt("How long in seconds until a server is killed after it is empty?", (string)null, 60, 86400, new int?(43200));
             this.WARNING = "Do Not Exceed 8 characters, names will be truncated.";
-            this.User = "User";
+            this.User = "";
             this.Trusted = "Trusted";
             this.Moderator = "Mod";
             this.Admin = "Admin";

DataManager.cs

@@ -0,0 +1,155 @@
+using ClanTagRankCommands;
+using System.Collections.Generic;
+using System.Linq;
+using Data.Models;
+//using Data.Models.Client;
+using SharedLibraryCore.Interfaces;
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Dtos;
+using System.Threading.Tasks;
+using static System.Enum;
+using Microsoft.Extensions.Logging;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+using System.Text.Json.Serialization;
+using System.Threading;
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Helpers;
+
+using System;
+
+
+using JsonSerializer = System.Text.Json.JsonSerializer;
+
+using Serilog.Core;
+using Data.Models.Client;
+
+namespace ClanTagRankCommands;
+
+public class DataManager
+{
+    public DataManager(IMetaServiceV2 metaService, ILogger<Plugin> logger)
+    {
+        _logger = logger;
+        _metaService = metaService;
+    }
+
+    private readonly IMetaServiceV2 _metaService;
+    private readonly ILogger _logger;
+
+    public async Task<DonatorState> ReadPersistentData(int? ClientId, IManager manager)
+    {
+        var token = manager.CancellationToken;
+        var availableTags = await _metaService.GetPersistentMetaValue<List<LookupValue<string>>>(EFMeta.ClientTagNameV2, token);
+        var matchingTag = availableTags.FirstOrDefault(tag => tag.Value == "Donator".Trim());
+        _logger.LogInformation("Reading persistent data for {0}", ClientId);
+        DonatorState clientDonatorState = DonatorState.User;
+        if(ClientId is not null)
+        {
+            
+            var existingtag = await _metaService.GetPersistentMetaByLookup("ClientTagV2", "ClientTagNameV2", (int)ClientId,
+                    token);//GetAdditionalProperty<string>(EFMeta.ClientTagNameV2);
+            
+            
+            if (existingtag is null || existingtag.Value.Contains("Guest"))
+            {
+                _logger.LogInformation("No existing tag found for {0}", ClientId);
+                return clientDonatorState;
+            }
+            else if (existingtag.Value.Contains("Donator"))
+            {
+                _logger.LogInformation("Existing tag: {0}", existingtag.Value);
+                clientDonatorState = DonatorState.Donator;
+            }
+            else if (existingtag is not null && !existingtag.Value.Contains("Guest"))
+            {
+                _logger.LogInformation("Existing tag: {0}", existingtag.Value);
+                clientDonatorState = DonatorState.Other;
+            }
+
+        }
+
+
+        //var clientDonatorState = client.ToPartialClient().Tag ??
+        //Parse<DonatorState>(value: client.ToPartialClient().Tag ?? nameof(DonatorState.User));
+
+        return clientDonatorState;
+    }
+    //public async Task<DonatorStateMeta> GetCurrentMuteState(EFClient client)
+    //{
+    //    try
+    //    {
+    //        //await _onMuteAction.WaitAsync();
+    //        var ClientDonatorMeta = await ReadPersistentDataV2(client);
+    //        if (ClientDonatorMeta is not null) return ClientDonatorMeta;
+
+    //        // Return null if the client doesn't have old or new meta.
+    //        var DonatorState = await ReadPersistentDataV1(client);
+    //        ClientDonatorMeta = new DonatorStateMeta
+    //        {
+    //            //Reason = muteState is null ? string.Empty : _translationLookup["PLUGINS_MUTE_MIGRATED"],
+    //            //Expiration = muteState switch
+    //            //{
+    //            //    null => DateTime.UtcNow,
+    //            //    MuteState.Muted => null,
+    //            //    _ => DateTime.UtcNow
+    //            //},
+    //            DonatorState = muteState ?? DonatorState.User,
+    //            CommandExecuted = true
+    //        };
+
+    //        // Migrate old mute meta, else, client has no state, so set a generic one, but don't write it to database.
+    //        if (DonatorState is not null)
+    //        {
+    //            ClientDonatorMeta.CommandExecuted = false;
+    //            await WritePersistentData(client, ClientDonatorMeta);
+    //            //await CreatePenalty(muteState.Value, Utilities.IW4MAdminClient(), client, ClientDonatorMeta.Expiration,
+    //             //   ClientDonatorMeta.Reason);
+    //        }
+    //        else
+    //        {
+    //            client.SetAdditionalProperty(Plugin.MuteKey, ClientDonatorMeta);
+    //        }
+
+    //        return ClientDonatorMeta;
+    //    }
+    //    finally
+    //    {
+    //        //if (_onMuteAction.CurrentCount == 0) _onMuteAction.Release();
+    //    }
+    //}
+    //private async Task<DonatorStateMeta?> ReadPersistentDataV2(EFClient client)
+    //{
+    //    // Get meta from client
+    //    var clientDonatorMeta = client.GetAdditionalProperty<DonatorStateMeta>(Plugin.DonatorKey);
+    //    if (clientDonatorMeta is not null) return clientDonatorMeta;
+
+    //    // Get meta from database and store in client if exists
+    //    clientDonatorMeta = await _metaService.GetPersistentMetaValue<DonatorStateMeta>(Plugin.DonatorKey, client.ClientId);
+    //    if (clientDonatorMeta is not null) client.SetAdditionalProperty(Plugin.DonatorKey, clientDonatorMeta);
+
+    //    return clientDonatorMeta;
+    //}
+
+
+    //public async Task WritePersistentData(EFClient client, DonatorState state)
+    //{
+    //    await _metaService.SetPersistentMeta(Plugin.DonatorKey, state.ToString(), client.ClientId);
+    //    client.SetAdditionalProperty(Plugin.DonatorKey, state);
+    //}
+}
+
+public class DonatorStateMeta
+{
+    //public string Reason { get; set; } = string.Empty;
+    //public DateTime? Expiration { get; set; }
+    public DonatorState DonatorState { get; set; }
+    [JsonIgnore] public bool CommandExecuted { get; set; }
+}
+public enum DonatorState
+{
+    User,
+    Donator,
+    Other
+}

Events/Script.cs

@@ -0,0 +1,67 @@
+using SharedLibraryCore;
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Interfaces;
+using System.Collections.Generic;
+using EventGeneratorCallback = System.ValueTuple<string, string, 
+    System.Func<string, SharedLibraryCore.Interfaces.IEventParserConfiguration,
+    SharedLibraryCore.GameEvent, 
+    SharedLibraryCore.GameEvent>>;
+
+namespace IW4MAdmin.Plugins.ClanTagRankCommands.Events
+{
+    public class Script : IRegisterEvent
+    {
+
+        private const string EVENT_RC = "RC";
+
+        /// <summary>
+        /// this is a custom event printed out by _clientids.gsc (used for recording highest personal round records)
+        /// </summary>
+        /// <returns></returns>
+        private EventGeneratorCallback RC()
+        {
+            return (EVENT_RC, EVENT_RC, (string eventLine, IEventParserConfiguration config, GameEvent autoEvent) =>
+            {
+                string[] lineSplit = eventLine.Split(";");
+
+
+                long originId = lineSplit[1].ConvertGuidToLong(config.GuidNumberStyle, 1);
+
+                autoEvent.Type = GameEvent.EventType.Other;
+                autoEvent.Origin = new EFClient() { NetworkId = originId };
+                autoEvent.RequiredEntity = GameEvent.EventRequiredEntity.Origin;
+                autoEvent.GameTime = autoEvent.GameTime;
+                autoEvent.Subtype = EVENT_RC;
+
+                return autoEvent;
+            }
+            );
+        }
+        //private const string EVENT_RoundNumber = "RoundNumber";
+
+        ///// <summary>
+        ///// this is a custom event printed out by _clientids.gsc (used for recording highest server round records)
+        ///// </summary>
+        ///// <returns></returns>
+        //private EventGeneratorCallback RoundNumber()
+        //{
+        //    return (EVENT_RoundNumber, EVENT_RoundNumber, (string eventLine, IEventParserConfiguration config, GameEvent autoEvent) =>
+        //    {
+        //        string[] lineSplit = eventLine.Split(";");
+
+        //        autoEvent.Type = GameEvent.EventType.RoundNumber;
+        //        autoEvent.Origin = Utilities.IW4MAdminClient();
+        //        autoEvent.GameTime = autoEvent.GameTime;
+
+        //        return autoEvent;
+        //    }
+        //    );
+        //}
+        public IEnumerable<EventGeneratorCallback> Events =>
+            new[]
+            {
+                RC(),
+
+            };
+    }
+}

GscApiController.cs

@@ -1,4 +1,5 @@
-using ClanTagRankApi;
+using ClanTagRankCommands;
+using Data.Models;
 using Microsoft.AspNetCore.Mvc;
 using SharedLibraryCore;
 using SharedLibraryCore.Database.Models;
@@ -16,10 +17,10 @@ namespace WebfrontCore.Controllers.API
     {
         string rankName;
         EFMeta customRankName;
-        private readonly IMetaService _metaService;
+        private readonly IMetaServiceV2 _metaService;
         private readonly IConfigurationHandler<Configuration> _configurationHandler;
         private Configuration Config;
-        public GscApiController(IManager manager, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(manager)
+        public GscApiController(IManager manager, IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(manager)
         {
             _metaService = metaService;
             _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");

Plugin.cs

@@ -3,12 +3,19 @@ using SharedLibraryCore.Interfaces;
 using System.Threading.Tasks;
 using System.Threading;
 using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Helpers;
+
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
+using Data.Models;
+using System;
+using SharedLibraryCore.Commands;
+using JsonSerializer = System.Text.Json.JsonSerializer;
+using System.Linq;
+using Serilog.Core;
 
-
-namespace ClanTagRankApi
+namespace ClanTagRankCommands
 {
 
     public class Plugin : IPlugin
@@ -16,24 +23,35 @@ namespace ClanTagRankApi
         private readonly IConfigurationHandler<Configuration> _configurationHandler;
         private readonly ILogger _logger;
         private Configuration Config;
-        readonly string rank = "rank";
-        string rankName = "none";
+        //readonly string rank = "rank";
+        //string rankName = "none";
+        private readonly IInteractionRegistration _interactionRegistration;
+        private static readonly string DonatorInteraction = "Webfront::Profile::Donator";
+        private static readonly string GuestInteraction = "Webfront::Profile::Guest";
+        private readonly IRemoteCommandService _remoteCommandService;
 
 
 
         public string Name => "ClanTagRankCommands";
 
-        public float Version => 1.31f;
+        public float Version => 1.5f;
 
         public string Author => "INSANEMODE";
 
-        private readonly IMetaService _metaService;
+        private readonly IMetaServiceV2 _metaService;
 
-        public Plugin(IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory, ILogger<Plugin> logger) 
+        public static string DonatorKey = "IW4MDonator";
+
+        public static DataManager DataManager;
+
+        public Plugin(IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory, ILogger<Plugin> logger, IInteractionRegistration interactionRegistration, IRemoteCommandService remoteCommandService)
         {
+            _remoteCommandService = remoteCommandService;
             _logger = logger;
             _metaService = metaService;
             _configurationHandler = (IConfigurationHandler<Configuration>)configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
+            _interactionRegistration = interactionRegistration;
+            DataManager = new DataManager(metaService, logger);
         }
         public Task OnLoadAsync(IManager manager)// => Task.CompletedTask;
         {
@@ -46,60 +64,144 @@ namespace ClanTagRankApi
             string version = manager.Version;
             string str = string.Format("Loaded {0} ({1}) by {2} in {3} ({4})!", (object)((IPlugin)this).Name, (object)((IPlugin)this).Version, (object)((IPlugin)this).Author, (object)"IW4MAdmin", (object)version);
             _logger.LogInformation(str);
-            
+            _interactionRegistration.RegisterInteraction(DonatorInteraction, async (clientId, game, token) =>
+            {
+                await Task.Delay(1);
+                _logger.LogDebug($"Donator button interaction for {clientId.Value}");
+                if (!clientId.HasValue)
+                {
+                    _logger.LogDebug($"No client id provided");
+                    return null;
+                }
+                //var client = manager.GetClientService().Get(clientId.Value).Result;
+                var DonatorState = await DataManager.ReadPersistentData(clientId.Value, manager);
+                _logger.LogDebug($"DonatorState: {(int)DonatorState}");
+                return DonatorState is DonatorState.User
+                    ? new InteractionData
+                    {
+                        EntityId = clientId.Value,
+                        Name = "Set Donator",
+                        DisplayMeta = "oi-circle-check",
+                        ActionPath = "DynamicAction",
+                        ActionMeta = new()
+                        {
+                        { "InteractionId", "command" },
+                        { "Data", $"Donator" },
+                        { "ActionButtonLabel", "Confirm" },
+                        { "Name", "Set Donator rank" },
+                        { "ShouldRefresh", true.ToString() }
+                        },
+                        MinimumPermission = Data.Models.Client.EFClient.Permission.Administrator,
+                        Source = Name,
+                        Enabled = true,
+                        PermissionAccess = "read",
+                        PermissionEntity = "Interaction",
+                        Description = "Set Donator rank for client"
+                    }
+                    : new InteractionData
+                    {
+                        EntityId = clientId.Value,
+                        Name = "UnSet Donator",
+                        DisplayMeta = "oi-circle-x",
+                        ActionPath = "DynamicAction",
+                        ActionMeta = new()
+                        {
+                        { "InteractionId", "command" },
+                        { "Data", $"Donator" },
+                        { "ActionButtonLabel", "Confirm" },
+                        { "Name", "UnSet Donator rank" },
+                        { "ShouldRefresh", true.ToString() }
+                        },
+                        MinimumPermission = Data.Models.Client.EFClient.Permission.Administrator,
+                        Source = Name,
+                        Enabled = true,
+                        PermissionAccess = "read",
+                        PermissionEntity = "Interaction",
+                        Description = "UnSet Donator rank for client"
+                    };
+
+            });
+            _logger.LogDebug("Registered Donator Interaction");
+            _interactionRegistration.RegisterInteraction(GuestInteraction, async (clientId, game, token) =>
+            {
+                await Task.Delay(1);
+                _logger.LogDebug($"guest button interaction for {clientId.Value}");
+                if (!clientId.HasValue)
+                {
+                    _logger.LogDebug($"No client id provided");
+                    return null;
+                }
+                bool guest;
+                var clienttag = await _metaService.GetPersistentMetaByLookup("ClientTagV2", "ClientTagNameV2", (int)clientId,
+                    token);
+                if(clienttag is not null && clienttag.Value.Contains("Guest"))
+                {
+                    guest = false;
+                }
+                else if(clienttag is not null && !clienttag.Value.Contains("Guest"))
+                {
+                    return null;
+                }
+                else
+                {
+                    guest = true;
+                }
+                return guest
+                    ? new InteractionData
+                    {
+                        EntityId = clientId.Value,
+                        Name = "Invite Guest",
+                        DisplayMeta = "oi-people",
+                        ActionPath = "DynamicAction",
+                        ActionMeta = new()
+                        {
+                        { "InteractionId", "command" },
+                        { "Data", $"Guest" },
+                        { "ActionButtonLabel", "Confirm" },
+                        { "Name", "Temporarily invite guest to donator server" },
+                        { "ShouldRefresh", true.ToString() }
+                        },
+                        MinimumPermission = Data.Models.Client.EFClient.Permission.Trusted,
+                        Source = Name,
+                        Enabled = true,
+                        PermissionAccess = "read",
+                        PermissionEntity = "Interaction",
+                        Description = "Temporarily invite a guest, until they leave the server"
+                    }
+                    : new InteractionData
+                    {
+                        EntityId = clientId.Value,
+                        Name = "Cancel Guest Invite",
+                        DisplayMeta = "oi-circle-x",
+                        ActionPath = "DynamicAction",
+                        ActionMeta = new()
+                        {
+                        { "InteractionId", "command" },
+                        { "Data", $"Guest" },
+                        { "ActionButtonLabel", "Confirm" },
+                        { "Name", "Cancel guest invite" },
+                        { "ShouldRefresh", true.ToString() }
+                        },
+                        MinimumPermission = Data.Models.Client.EFClient.Permission.Trusted,
+                        Source = Name,
+                        Enabled = true,
+                        PermissionAccess = "read",
+                        PermissionEntity = "Interaction",
+                        Description = "Cancel a guest invite"
+                    };
+
+            });
             return Task.CompletedTask;
         }
         public async Task OnEventAsync(GameEvent E, Server S)// => Task.CompletedTask;
         {
-            if (E.Type == GameEvent.EventType.Join ||E.Type == GameEvent.EventType.ChangePermission)
+            if (E.Type == GameEvent.EventType.Disconnect && (S.Hostname.Contains("Donator") || S.Hostname.Contains("Test")) && E.Origin.Tag == "Guest")
             {
-                Thread.Sleep(10000);
-                var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Origin);
-                rankName = E.Origin.Level.ClanTag(Config);
-
-                rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
-                if (rank_player_var == null)
-                {
-                    await _metaService.AddPersistentMeta("rank", "none", E.Origin);
-                    rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
-                }
-
-                if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
-                {
-                    rankName = rank_player_var.Value;
-
-                }
-
-                await S.ExecuteCommandAsync("setrank" + " " + E.Origin.ClientNumber + " " + rankName);
+                E.Origin.Tag = null;
+                await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, E.Origin.ClientId,
+                    E.Owner.Manager.CancellationToken);
             }
-            if (E.Type == GameEvent.EventType.Start || E.Type == GameEvent.EventType.MapEnd || E.Type == GameEvent.EventType.MapChange)
-            {
-                Thread.Sleep(10000);
-                IList<EFClient> currentclients = E.Owner.Manager.GetActiveClients();
-                foreach(EFClient client in currentclients)
-                {
-                    var rank_player_var = await _metaService.GetPersistentMeta(rank, client);
-                    rankName = client.Level.ClanTag(Config);
 
-                    rank_player_var = await _metaService.GetPersistentMeta("rank", client);
-                    if (rank_player_var == null)
-                    {
-                        await _metaService.AddPersistentMeta("rank", "none", client);
-                        rank_player_var = await _metaService.GetPersistentMeta("rank", client);
-                    }
-
-                    if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
-                    {
-                        rankName = rank_player_var.Value;
-
-                    }
-
-                    await S.ExecuteCommandAsync("setrank" + " " + client.ClientNumber + " " + rankName);
-
-                }
-
-            }
-            //return Task.CompletedTask;
         }
         public Task OnTickAsync(Server S)// =>
         {
@@ -108,8 +210,56 @@ namespace ClanTagRankApi
 
         }
 
-        public Task OnUnloadAsync() => Task.CompletedTask;
+        public Task OnUnloadAsync() //=>
+        {
+            
+            _interactionRegistration.UnregisterInteraction(DonatorInteraction);
+            _interactionRegistration.UnregisterInteraction(GuestInteraction);
+            return Task.CompletedTask;
+        }
 
 
     }
+    public static class yadb
+    {
+        public static Task notifyYADB(string message, string title, string reason, string icon, Server S, EFClient OriginClient, EFClient TargetClient)
+        {
+            string json = "";
+            using (var stream = new System.IO.MemoryStream())
+            {
+                using (var writer = new System.Text.Json.Utf8JsonWriter(stream))
+                {
+                    writer.WriteStartObject();
+                    writer.WriteString("title", title);
+                    writer.WriteString("message", message);
+                    writer.WriteString("reason", reason);
+                    writer.WriteString("icon", icon);
+                    writer.WriteEndObject();
+                }
+
+                json = System.Text.Encoding.UTF8.GetString(stream.ToArray());
+            }
+            var e = new GameEvent()
+            {
+                Origin = OriginClient,
+                Target = TargetClient,
+                Owner = S,
+                Type = GameEvent.EventType.Other,
+                Subtype = "YADB-Embed",
+                Extra = json
+            };
+
+            S.ExecuteEvent(e);
+            Console.WriteLine("event triggered!" + message);
+            return Task.CompletedTask;
+
+
+
+            //notifyYADB("Kicked player @{target} after a successful vote started from @{origin}", $"Vote kicked {target.Name}", gameEvent.Data,":pencil:", Server, origin, target);
+        }
+
+
+    }
+
+
 }

unusedClanTag.cs

@@ -0,0 +1,65 @@
+
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore;
+using SharedLibraryCore.Interfaces;
+
+namespace Tebex_IW4M_Admin
+{
+
+    static class ExtensionMethods
+    {
+        public static string Truncate(this string input, int strLength)
+        {
+            if (string.IsNullOrEmpty(input)) return input;
+            return input.Length <= strLength ? input : input.Substring(0, strLength);
+        }
+        public static string ClanTag(this EFClient.Permission level, Configuration Config)
+        {
+            string rankName;
+
+            switch ((int)level)
+            {
+                case -1:
+                    rankName = "Banned";  //this typically won't be seen. 
+                    break;
+                case 0:
+                    rankName = Config.User;
+                    break;
+                case 1:
+                    rankName = Config.User;  //1 = flagged, but don't want to show this in game.
+                    break;
+                case 2:
+                    rankName = Config.Trusted;
+                    break;
+                case 3:
+                    rankName = Config.Moderator;
+                    break;
+                case 4:
+                    rankName = Config.Admin;
+                    break;
+                case 5:
+                    rankName = Config.SeniorAdmin;
+                    break;
+                case 6:
+                    rankName = Config.Owner;
+                    break;
+                case 7:
+                    rankName = Config.Creator;
+                    break;
+                case 8:
+                    rankName = Config.Console;
+                    break;
+                default:
+                    rankName = Config.User;
+                    break;
+            }
+            return rankName.Truncate(8);
+        }
+
+
+
+    }
+}
+
+
+