update commands to make sure they address objects being null.

.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

ClanTagRankCommands.csproj

@@ -2,15 +2,20 @@
 
   <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="TebexApiClient.cs" />
+    <Compile Remove="unusedClanTag.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.3.19.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Commands/GetRankCommand.cs

@@ -0,0 +1,94 @@
+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 IMetaService _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();
+
+            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);
+                }
+
+                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")
+                    {
+                    
+                        //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/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

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
 
 
 
-namespace ClanTagRankApi.Commands
+namespace ClanTagRankCommands.Commands
 {
     /// <summary>
     /// Example script command
@@ -51,10 +51,31 @@ namespace ClanTagRankApi.Commands
         {
             //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);
+            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());
+
+                        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/SetRankCommand.cs

@@ -6,7 +6,7 @@ using SharedLibraryCore.Interfaces;
 using System.Threading.Tasks;
 
 
-namespace ClanTagRankApi.Commands
+namespace ClanTagRankCommands.Commands
 {
 
     /// <summary>
@@ -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);
+                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.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")
+                    {
+                    
+                        //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";

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;

Plugin.cs

@@ -6,9 +6,11 @@ using SharedLibraryCore.Database.Models;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
+using Data.Models;
+using System;
 
 
-namespace ClanTagRankApi
+namespace ClanTagRankCommands
 {
 
     public class Plugin : IPlugin
@@ -23,13 +25,13 @@ namespace ClanTagRankApi
 
         public string Name => "ClanTagRankCommands";
 
-        public float Version => 1.31f;
+        public float Version => 1.42f;
 
         public string Author => "INSANEMODE";
 
         private readonly IMetaService _metaService;
 
-        public Plugin(IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory, ILogger<Plugin> logger) 
+        public Plugin(IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory, ILogger<Plugin> logger)
         {
             _logger = logger;
             _metaService = metaService;
@@ -46,46 +48,28 @@ 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);
-            
+
             return Task.CompletedTask;
         }
         public async Task OnEventAsync(GameEvent E, Server S)// => Task.CompletedTask;
         {
-            if (E.Type == GameEvent.EventType.Join ||E.Type == GameEvent.EventType.ChangePermission)
-            {
-                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)
+            //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)
                 {
-                    await _metaService.AddPersistentMeta("rank", "none", E.Origin);
+                    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.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);
-            }
-            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);
+
+                        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")))
@@ -93,12 +77,108 @@ namespace ClanTagRankApi
                         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("setrank" + " " + client.ClientNumber + " " + rankName);
+                            //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.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)// =>
@@ -112,4 +192,46 @@ namespace ClanTagRankApi
 
 
     }
+    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);
+        }
+
+
+
+    }
+}
+
+
+