- update to net8

- bump sharedlibrarycore version

ClanTag.cs

@@ -11,16 +11,16 @@ namespace ClanTagRankCommands
         public static string Truncate(this string input, int strLength)
         {
             if (string.IsNullOrEmpty(input)) return input;
-            return input.Length <= strLength ? input : input.Substring(0, strLength);
+            return input.Length <= strLength ? input : input[..strLength];
         }
-        public static string ClanTag(this EFClient.Permission level, Configuration Config)
+        public static string ClanTag(this EFClient.Permission level, ClanTagConfiguration Config)
         {
             string rankName;
 
             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,20 +2,28 @@
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ApplicationIcon />
     <StartupObject />
     <Configurations>Debug;Release;Prerelease</Configurations>
-    <LangVersion>10</LangVersion>
+    <LangVersion>Latest</LangVersion>
+    <GenerateDocumentationFile>False</GenerateDocumentationFile>
+    <SignAssembly>False</SignAssembly>
   </PropertyGroup>
 
   <ItemGroup>
+    <Compile Remove="GscApiController.cs" />
     <Compile Remove="TebexApiClient.cs" />
     <Compile Remove="unusedClanTag.cs" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.3.19.1" PrivateAssets="All" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2024.6.29.807" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Models\" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Commands/GameInterfaceReconnectCommand.cs

@@ -0,0 +1,66 @@
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Interfaces;
+using SharedLibraryCore.Interfaces.Events;
+using System.Threading.Tasks;
+
+
+namespace ClanTagRankCommands.Commands
+{
+
+    /// <summary>
+    /// Example script command
+    /// </summary>
+    /// 
+
+    public class GameInterfaceReconnectCommand : Command
+    {
+        
+        private readonly IMetaServiceV2 _metaService;
+        //private readonly IConfigurationHandler<ClanTagConfiguration> _configurationHandler;
+        private ClanTagConfiguration Config;
+
+
+        public GameInterfaceReconnectCommand(CommandConfiguration config, ITranslationLookup lookup, ClanTagConfiguration _Config, IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
+        {
+            _metaService = metaService;
+
+            Config = _Config;
+
+            Name = "GameInterfaceReconnect";
+            Description = "set a user's clan tag Rank (does not give permissions)";
+            Alias = "gir";
+            Permission = EFClient.Permission.Administrator;
+            RequiresTarget = false;
+            //Arguments = new[]
+            //{
+            //    new CommandArgument()
+            //    {
+            //        Name = "rank",
+            //        Required = true
+            //    }
+            //};
+        }
+
+        public override Task ExecuteAsync(GameEvent E)
+        {
+            var gir = new GameEvent()
+            {
+                Origin = Utilities.IW4MAdminClient(),
+                Owner = E.Owner,
+                Type = GameEvent.EventType.Other,
+                Subtype = "ScriptReconnect",
+            };
+
+            E.Owner.ExecuteEvent(gir);
+            return Task.CompletedTask;
+
+        }
+    }
+}
+
+
+
+

Commands/GetRankCommand.cs

@@ -1,94 +1,93 @@
-using SharedLibraryCore;
-using SharedLibraryCore.Commands;
-using SharedLibraryCore.Configuration;
-using SharedLibraryCore.Database.Models;
-using SharedLibraryCore.Interfaces;
-using System.Threading.Tasks;
+//using SharedLibraryCore;
+//using SharedLibraryCore.Commands;
+//using SharedLibraryCore.Configuration;
+//using SharedLibraryCore.Database.Models;
+//using SharedLibraryCore.Interfaces;
+//using System.Threading.Tasks;
 
 
-namespace ClanTagRankCommands.Commands
-{
+//namespace ClanTagRankCommands.Commands
+//{
 
-    /// <summary>
-    /// Example script command
-    /// </summary>
-    /// 
+//    /// <summary>
+//    /// Example script command
+//    /// </summary>
+//    /// 
 
-    public class GetRankCommand : Command
-    {
-        readonly string rank = "rank";
-        string rank_string;
-        private readonly IMetaService _metaService;
-        private readonly IConfigurationHandler<Configuration> _configurationHandler;
-        private Configuration Config;
+//    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, 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 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()
-                {
-                }
-            };
+//            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)
-        {
-            //var S = E.Owner;
-            rank_string = "none";
-            if(E.Target is not null)
-            {
-                var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
-                if (rank_player_var == null)
-                {
-                    await _metaService.AddPersistentMeta(rank, "none", E.Target);
-                    rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
-                }
+//        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)
-                {
+//                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")
-                    {
+//                    //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 );
+//                        //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);
+//                    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

@@ -1,98 +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;
+//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()
-                {
-                }
-            };
-        }
+//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());
+//        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);
+//            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)
-                {
+//                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);
-                }
+//                    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 (!(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))
-                    {
+//                }
+//                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");
-                    }
+//                    }
+//                    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());
-                }
-            }
+//                    //await E.Owner.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Origin.ClientNumber.ToString() + ";" + rankName.ToString());
+//                }
+//            }
 
 
 
-        }
-    }
-}
+//        }
+//    }
+//}
 
 
 

Commands/ResetRankCommand.cs

@@ -1,81 +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 ClanTagRankCommands.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";
-            if(E.Target is not null)
-            {
-                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);
-                if (E.Target is not null && E.Target.IsIngame )
-                {
-                    if (string.IsNullOrWhiteSpace(rank_string))
-                    {
-                        await E.Owner.ExecuteCommandAsync("resetclantag" + " " + E.Target.ClientNumber.ToString());
+//        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());
+//                        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());
-                    }
-                }
+//                    }
+//                    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

@@ -3,6 +3,7 @@ using SharedLibraryCore.Commands;
 using SharedLibraryCore.Configuration;
 using SharedLibraryCore.Database.Models;
 using SharedLibraryCore.Interfaces;
+using SharedLibraryCore.Interfaces.Events;
 using System.Threading.Tasks;
 
 
@@ -18,21 +19,21 @@ namespace ClanTagRankCommands.Commands
     {
         readonly string rank = "rank";
         string rank_string;
-        private readonly IMetaService _metaService;
-        private readonly IConfigurationHandler<Configuration> _configurationHandler;
-        private Configuration Config;
+        private readonly IMetaServiceV2 _metaService;
+        //private readonly IConfigurationHandler<ClanTagConfiguration> _configurationHandler;
+        private ClanTagConfiguration Config;
 
 
-        public SetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
+        public SetRankCommand(CommandConfiguration config, ITranslationLookup lookup, ClanTagConfiguration _Config, 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();
+            //_configurationHandler = configurationHandlerFactory.GetConfigurationHandler<ClanTagConfiguration>("ClanTagRankCommands");
+            //if (_configurationHandler.Configuration() == null)
+            //{
+            //    _configurationHandler.Set((ClanTagConfiguration)new ClanTagConfiguration().Generate());
+            //    _configurationHandler.Save();
+            //}
+            Config = _Config;
 
             Name = "SetRank";
             Description = "set a user's clan tag Rank (does not give permissions)";
@@ -49,7 +50,7 @@ namespace ClanTagRankCommands.Commands
             };
         }
 
-        public override async Task ExecuteAsync(GameEvent E)
+        public override async Task ExecuteAsync(GameEvent E )
         {
             //var S = E.Owner;
             rank_string = "none";
@@ -57,18 +58,18 @@ namespace ClanTagRankCommands.Commands
                 rank_string = E.Data;
             if(E.Target is not null)
             {
-                var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
+                var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
                 if (rank_player_var == null)
                 {
-                    await _metaService.AddPersistentMeta(rank, "none", E.Target);
-                    rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
+                    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);
+                    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")
                     {
                     

Configuration.cs

@@ -3,7 +3,7 @@ using SharedLibraryCore.Interfaces;
 
 namespace ClanTagRankCommands
 {
-    public class Configuration : IBaseConfiguration
+    public class ClanTagConfiguration : IBaseConfiguration
     {
         internal const string _name = "IW4MAdmin";
 

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

@@ -1,7 +1,10 @@
-using SharedLibraryCore;
+using Serilog.Debugging;
+using SharedLibraryCore;
 using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Events.Game;
 using SharedLibraryCore.Interfaces;
 using System.Collections.Generic;
+using System.Globalization;
 using EventGeneratorCallback = System.ValueTuple<string, string, 
     System.Func<string, SharedLibraryCore.Interfaces.IEventParserConfiguration,
     SharedLibraryCore.GameEvent, 
@@ -13,6 +16,8 @@ namespace IW4MAdmin.Plugins.ClanTagRankCommands.Events
     {
 
         private const string EVENT_RC = "RC";
+        private const string EVENT_ScriptBan = "ScriptBan";
+        private const string EVENT_ScriptReconnect = "ScriptReconnect";
 
         /// <summary>
         /// this is a custom event printed out by _clientids.gsc (used for recording highest personal round records)
@@ -37,6 +42,50 @@ namespace IW4MAdmin.Plugins.ClanTagRankCommands.Events
             }
             );
         }
+        private EventGeneratorCallback ScriptBan()
+        {
+            return (EVENT_ScriptBan, EVENT_ScriptBan, (eventLine, _, _) =>
+            {
+                string[] lineSplit = eventLine.Split(";");
+
+
+                long originId = lineSplit[1].ConvertGuidToLong(NumberStyles.Integer);
+                int clientnum = int.Parse(lineSplit[2]);
+                var scriptBan = new ScriptBanEvent
+
+                {
+                    Type = GameEvent.EventType.Other,
+                    Subtype = EVENT_ScriptBan,
+                    Origin = Utilities.IW4MAdminClient(),
+                    Target = new EFClient { NetworkId = originId, Name = lineSplit[3], ClientNumber = clientnum },
+                    ScriptData = eventLine
+                };
+                return scriptBan;
+            }
+            );
+        }
+        private EventGeneratorCallback ScriptReconnect()
+        {
+            return (EVENT_ScriptReconnect, EVENT_ScriptReconnect, (eventLine, _, _) =>
+            {
+                string[] lineSplit = eventLine.Split(";");
+
+
+                //long originId = lineSplit[1].ConvertGuidToLong(NumberStyles.Integer);
+                //int clientnum = int.Parse(lineSplit[2]);
+                var ScriptReconnect = new ScriptReconnectEvent
+
+                {
+                    Type = GameEvent.EventType.Other,
+                    Subtype = EVENT_ScriptReconnect,
+                    Origin = Utilities.IW4MAdminClient(),
+                    //Target = new EFClient { NetworkId = originId, Name = lineSplit[3], ClientNumber = clientnum },
+                    ScriptData = eventLine
+                };
+                return ScriptReconnect;
+            }
+            );
+        }
         //private const string EVENT_RoundNumber = "RoundNumber";
 
         ///// <summary>
@@ -60,8 +109,15 @@ namespace IW4MAdmin.Plugins.ClanTagRankCommands.Events
         public IEnumerable<EventGeneratorCallback> Events =>
             new[]
             {
-                RC(),
+                RC(),ScriptBan(), ScriptReconnect(),
 
             };
+
+        public class ScriptBanEvent : GameScriptEvent
+        {
+        }
+        public class ScriptReconnectEvent : GameScriptEvent
+        {
+        }
     }
 }

GscApiController.cs

@@ -17,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,198 +3,319 @@ using SharedLibraryCore.Interfaces;
 using System.Threading.Tasks;
 using System.Threading;
 using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Helpers;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Events.Management;
+using SharedLibraryCore.Interfaces.Events;
+using Microsoft.Extensions.DependencyInjection;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
 using Data.Models;
 using System;
+using JsonSerializer = System.Text.Json.JsonSerializer;
+using System.Linq;
+using Serilog.Core;
+using EFClient = Data.Models.Client.EFClient;
+using static IW4MAdmin.Plugins.ClanTagRankCommands.Events.Script;
+using SharedLibraryCore.Events.Game;
+using SharedLibraryCore.Events.Server;
+using System.Collections.Concurrent;
+
 
 
 namespace ClanTagRankCommands
 {
 
-    public class Plugin : IPlugin
+    public class Plugin : IPluginV2
     {
-        private readonly IConfigurationHandler<Configuration> _configurationHandler;
         private readonly ILogger _logger;
-        private Configuration Config;
-        readonly string rank = "rank";
-        string rankName = "none";
+        //private ClanTagConfiguration Config;
+        //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.42f;
+        //public float Version => 1.5f;
 
         public string Author => "INSANEMODE";
 
-        private readonly IMetaService _metaService;
+        string IModularAssembly.Version => "2.0";
 
-        public Plugin(IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory, ILogger<Plugin> logger)
+        private readonly IMetaServiceV2 _metaService;
+
+        public static string DonatorKey = "IW4MDonator";
+
+        public static DataManager DataManager;
+
+        public Plugin(IMetaServiceV2 metaService, ClanTagConfiguration Config, ILogger<Plugin> logger, IInteractionRegistration interactionRegistration, IRemoteCommandService remoteCommandService)
         {
+
+            IManagementEventSubscriptions.Load += OnLoad;
+            IManagementEventSubscriptions.Unload += OnUnloadAsync;
+            IGameEventSubscriptions.ScriptEventTriggered += OnScriptEvent;
+
+            _remoteCommandService = remoteCommandService;
             _logger = logger;
             _metaService = metaService;
-            _configurationHandler = (IConfigurationHandler<Configuration>)configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
-        }
-        public Task OnLoadAsync(IManager manager)// => Task.CompletedTask;
-        {
-            if (_configurationHandler.Configuration() == null)
+            _interactionRegistration = interactionRegistration;
+            DataManager = new DataManager(metaService, logger);
+            IManagementEventSubscriptions.ClientStateDisposed += async (clientEvent, token) =>
             {
-                _configurationHandler.Set((Configuration)new Configuration().Generate());
-                _configurationHandler.Save();
-            }
-            Config = _configurationHandler.Configuration();
-            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);
-
-            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.Other) && E.Subtype.Contains("RC"))
-            {
-                //Console.WriteLine("RC: " + E.Origin.Name);
-
-                if (E.Origin is not null && E.Origin.CurrentServer == S && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)
+                if ((clientEvent.Client.CurrentServer.Hostname.Contains("Donator") || clientEvent.Client.CurrentServer.Hostname.Contains("Test")) && clientEvent.Client.Tag == "Guest")
                 {
-                    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;
-
-                    }
-                    if (E.Origin is not null && E.Origin.CurrentServer == S && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)// && (E.Origin.Level > EFClient.Permission.Trusted || rankName != Config.User))
-                    {
-                        if (string.IsNullOrWhiteSpace(rankName))
-                        {
-                            //await S.ExecuteCommandAsync("resetclantag" + " " + E.Origin.ClientNumber.ToString());
-
-                            //await S.ExecuteCommandAsync("resetrole " + E.Origin.ClientNumber.ToString());
-
-                        }
-                        else
-                        {
-                            await S.ExecuteCommandAsync("setclantag" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
-                            await S.ExecuteCommandAsync("setrole " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
-                        }
-
-                        //await S.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Origin.ClientNumber.ToString() + ";" + rankName.ToString());
-                    }
+                    Console.WriteLine("Guest disconnected, removing guest tag.");
+                    _logger.LogInformation("Guest disconnected, removing guest tag.");
+                    clientEvent.Client.Tag = null;
+                    await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, clientEvent.Client.ClientId,
+                        token);
                 }
-
-            }
-            //if ((E.Type == GameEvent.EventType.Connect))
-            //{
-            //    //Console.WriteLine("RC: " + E.Origin.Name);
-
-            //    if (E.Origin.CurrentServer == S && E.Origin is object && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)
-            //    {
-            //        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;
-
-            //        }
-            //        if (E.Origin.CurrentServer == S && E.Origin is object && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)// && (E.Origin.Level > EFClient.Permission.Trusted || rankName != Config.User))
-            //        {
-            //            if (string.IsNullOrWhiteSpace(rankName) || rankName.Length < 1)
-            //            {
-            //                //await S.ExecuteCommandAsync("resetclantag" + " " + E.Origin.ClientNumber.ToString());
-
-            //                //await S.ExecuteCommandAsync("resetrole " + E.Origin.ClientNumber.ToString());
-
-            //            }
-            //            else
-            //            {
-            //                await S.ExecuteCommandAsync("setclantag" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
-
-            //                await S.ExecuteCommandAsync("setrole " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
-            //            }
-
-            //            //await S.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Origin.ClientNumber.ToString() + ";" + rankName.ToString());
-            //        }
-            //    }
-
-            //}
-            //if ((E.Type == GameEvent.EventType.Other) && E.Subtype.Contains("YADB-Embed"))
-            //{
-            //    Console.WriteLine(E.Extra);
-            //    Console.WriteLine(E.Origin.Name);
-            //}
-            //if (E.Type == GameEvent.EventType.Start || E.Type == GameEvent.EventType.MapChange)
-            //{
-            //    var currentclients = S.GetClientsAsList();  //GetActiveClients();
-            //    foreach (EFClient client in currentclients)
-            //    {
-            //        if (client.CurrentServer == S && client is object && client.ClientNumber != -1 && client.ClientNumber != 9)
-            //        {
-            //            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;
-
-            //            }
-            //            if (client.CurrentServer == S && client is object && client.ClientNumber != -1 && client.ClientNumber != 9)
-            //            {
-            //                await S.SetDvarAsync("sv_iw4madmin_role", "setRole;" + client.ClientNumber.ToString() + ";" + rankName.ToString());
-            //                await S.ExecuteCommandAsync("setclantag" + " " + client.ClientNumber.ToString() + " " + rankName.ToString());
-            //            }
-
-            //        }
-
-
-            //    }
-
-            //}
-            //return Task.CompletedTask;
+            };
         }
-        public Task OnTickAsync(Server S)// =>
+        public static void RegisterDependencies(IServiceCollection serviceCollection)
+        {
+            serviceCollection.AddConfiguration<ClanTagConfiguration>("ClanTagRankCommands");
+            
+        }
+        private Task OnLoad(IManager manager, CancellationToken token)
         {
 
-            return Task.CompletedTask;
+            string version = manager.Version;
+            string str = string.Format("Loaded {0} ({1}) by {2} in {3} ({4})!", (object)((IPluginV2)this).Name, (object)((IPluginV2)this).Version, (object)((IPluginV2)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 = 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 = 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 = 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 = EFClient.Permission.Trusted,
+                        Source = Name,
+                        Enabled = true,
+                        PermissionAccess = "read",
+                        PermissionEntity = "Interaction",
+                        Description = "Cancel a guest invite"
+                    };
+
+            });
+            return Task.CompletedTask;
         }
 
-        public Task OnUnloadAsync() => Task.CompletedTask;
+        private Task OnScriptEvent(GameScriptEvent scriptEvent, CancellationToken token)
+        {
+            if (scriptEvent is not ScriptBanEvent ScriptBan)
+            {
+                return Task.CompletedTask;
+            }
 
+            try
+            {
+                string[] lineSplit = ScriptBan.ScriptData.Split(";");
+                var sender = Utilities.IW4MAdminClient(ScriptBan.Owner);
+                sender.AdministeredPenalties = new List<EFPenalty>
+                {
+                    new()
+                    {
+                        
+                        AutomatedOffense = $"Profanity Filter Match: {lineSplit[4]} - {string.Join(",", lineSplit[5])}"
+                    }
+                };
+                SharedLibraryCore.Database.Models.EFClient efClient = (SharedLibraryCore.Database.Models.EFClient)null;
+                string rule = ScriptBan.Owner.Manager.GetApplicationSettings().Configuration().GlobalRules.Where(rule => rule.Contains("hate")).FirstOrDefault().ToString();
+                efClient = ScriptBan.Owner.GetClientsAsList().First<SharedLibraryCore.Database.Models.EFClient>((Func<SharedLibraryCore.Database.Models.EFClient, bool>)(_client => _client.NetworkId == ScriptBan.Target.NetworkId));
+                efClient.Ban($"Profanity filter Racism match - -{rule}", sender, false);
+                
+                //ScriptBan.Owner.Ban("Blatent racism match", ScriptBan.Target., sender);
+                
+            }
+
+            catch (Exception e)
+            {
+                _logger.LogError(e, "Could not parse ScriptBan Event: {Data}", e.Data);
+            }
+
+            return Task.CompletedTask;
+        }
+
+        //public async Task OnDisconnect(GameEvent E, Server S)// => Task.CompletedTask;
+        //{
+        //    if (E.Type == GameEventV2.EventType.Disconnect && (S.Hostname.Contains("Donator") || S.Hostname.Contains("Test")) && E.Origin.Tag == "Guest")
+        //    {
+        //        Console.WriteLine("Guest disconnected, removing guest tag.");
+        //        _logger.LogInformation("Guest disconnected, removing guest tag.");
+        //        E.Origin.Tag = null;
+        //        await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, E.Origin.ClientId,
+        //            E.Owner.Manager.CancellationToken);
+        //    }
+        //    else if (E.Type == GameEventV2.EventType.Other && (S.Hostname.Contains("Donator") || S.Hostname.Contains("Test")) && E.Origin.Tag == "Guest")
+        //    {
+        //        Console.WriteLine("Guest triggered event of type Other, removing guest tag.");
+        //        _logger.LogInformation("Guest triggered event of type Other, removing guest tag.");
+        //        E.Origin.Tag = null;
+        //        await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, E.Origin.ClientId,
+        //            E.Owner.Manager.CancellationToken);
+        //    }
+
+
+        //}
+        //public async Task OnEventAsync(GameEventV2 E, Server S)// => Task.CompletedTask;
+        //{
+        //    if (E.Type == GameEventV2.EventType.Disconnect && (S.Hostname.Contains("Donator") || S.Hostname.Contains("Test")) && E.Origin.Tag == "Guest")
+        //    {
+        //        Console.WriteLine("Guest disconnected, removing guest tag.");
+        //        _logger.LogInformation("Guest disconnected, removing guest tag.");
+        //        E.Origin.Tag = null;
+        //        await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, E.Origin.ClientId,
+        //            E.Owner.Manager.CancellationToken);
+        //    }
+        //    else if (E.Type == GameEventV2.EventType.Other && (S.Hostname.Contains("Donator") || S.Hostname.Contains("Test")) && E.Origin.Tag == "Guest")
+        //    {
+        //        Console.WriteLine("Guest triggered event of type Other, removing guest tag.");
+        //        _logger.LogInformation("Guest triggered event of type Other, removing guest tag.");
+        //        E.Origin.Tag = null;
+        //        await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, E.Origin.ClientId,
+        //            E.Owner.Manager.CancellationToken);
+        //    }
+            
+
+        //}
+        //public Task OnTickAsync(Server S)// =>
+        //{
+
+        //    return Task.CompletedTask;
+
+        //}
+
+        private Task OnUnloadAsync(IManager manager, CancellationToken token) //=>
+        {
+            
+            _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)
+        public static Task notifyYADB(string message, string title, string reason, string icon, Server S, SharedLibraryCore.Database.Models.EFClient OriginClient, SharedLibraryCore.Database.Models.EFClient TargetClient)
         {
             string json = "";
             using (var stream = new System.IO.MemoryStream())