update commands to make sure they address objects being null.

Reviewed-on: #3

.gitignore

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

ClanTag.cs

@@ -0,0 +1,65 @@
+
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore;
+using SharedLibraryCore.Interfaces;
+
+namespace ClanTagRankCommands
+{
+
+    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);
+        }
+
+
+
+    }
+}
+
+
+

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="2.4.9" 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

@@ -0,0 +1,81 @@
+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;
+
+        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();
+
+            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());
+
+                        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,21 +6,34 @@ using SharedLibraryCore.Interfaces;
 using System.Threading.Tasks;
 
 
-
-namespace IW4ScriptCommands.Commands
+namespace ClanTagRankCommands.Commands
 {
+
     /// <summary>
     /// Example script command
     /// </summary>
+    /// 
+
     public class SetRankCommand : Command
     {
         readonly string rank = "rank";
         string rank_string;
         private readonly IMetaService _metaService;
+        private readonly IConfigurationHandler<Configuration> _configurationHandler;
+        private Configuration Config;
 
-        public SetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService) : base(config, lookup)
+
+        public SetRankCommand(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 = "SetRank";
             Description = "set a user's clan tag Rank (does not give permissions)";
             Alias = "sr";
@@ -42,28 +55,61 @@ namespace IW4ScriptCommands.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);
+                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(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
+                {
+                    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());
+                    }
+                }
+
+                    
             }
 
-            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 reset to none");
-
-                E.Origin.Tell("New rank set: [" + rank_player_var.Value + "]" + E.Target.Name);
-            }
-            else
-            {
-                //rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
-                E.Origin.Tell($"invalid rank length (between 1-8 characters), set rank to none to reset");
-            }
         }
     }
 }

Configuration.cs

@@ -1,20 +1,38 @@
 
 using SharedLibraryCore.Interfaces;
 
-namespace ClanTagRankApi
+namespace ClanTagRankCommands
 {
-    internal class Configuration : IBaseConfiguration
+    public class Configuration : IBaseConfiguration
     {
         internal const string _name = "IW4MAdmin";
 
-        public int RestartTimerLength { get; set; }
+        public string WARNING { get; set; }
+        public string User { get; set; }
+        public string Trusted { get; set; }
+        public string Moderator { get; set; }
+        public string Admin { get; set; }
+        public string SeniorAdmin { get; set; }
+        public string Owner { get; set; }
+        public string Creator { get; set; }
+        public string Console { get; set; }
+
 
         public IBaseConfiguration Generate()
         {
             //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 = "";
+            this.Trusted = "Trusted";
+            this.Moderator = "Mod";
+            this.Admin = "Admin";
+            this.SeniorAdmin = "SrAdmin";
+            this.Owner = "Owner";
+            this.Creator = "Creator";
+            this.Console = "Console";
             return (IBaseConfiguration)this;
         }
 
-        string IBaseConfiguration.Name() => "ClanTagRankApi";
+        string IBaseConfiguration.Name() => "ClanTagRankCommands";
     }
 }

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,8 +1,13 @@
-using Microsoft.AspNetCore.Mvc;
+using ClanTagRankCommands;
+using Data.Models;
+using Microsoft.AspNetCore.Mvc;
 using SharedLibraryCore;
+using SharedLibraryCore.Database.Models;
 using SharedLibraryCore.Interfaces;
 using System.Linq;
 using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Xsl;
 
 namespace WebfrontCore.Controllers.API
 {
@@ -11,8 +16,20 @@ namespace WebfrontCore.Controllers.API
     public class GscApiController : BaseController
     {
         string rankName;
-        public GscApiController(IManager manager) : base(manager)
+        EFMeta customRankName;
+        private readonly IMetaService _metaService;
+        private readonly IConfigurationHandler<Configuration> _configurationHandler;
+        private Configuration Config;
+        public GscApiController(IManager manager, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(manager)
         {
+            _metaService = metaService;
+            _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
+            if (_configurationHandler.Configuration() == null)
+            {
+                _configurationHandler.Set((Configuration)new Configuration().Generate());
+                _configurationHandler.Save();
+            }
+            Config = _configurationHandler.Configuration();
 
         }
 
@@ -21,50 +38,64 @@ namespace WebfrontCore.Controllers.API
         /// </summary>
         /// <param name="clientname"></param>
         /// <returns></returns>
+        [HttpGet("{clientguid}")]
+        public async Task<IActionResult> Clientguid(string clientguid)
+        {
+            long decimalNetworkId = clientguid.ConvertGuidToLong(System.Globalization.NumberStyles.Integer);
+            var clientInfo = Manager.GetActiveClients()
+                .FirstOrDefault(c => c.NetworkId == decimalNetworkId);
 
+            if (clientInfo != null)
+            {
+
+                rankName = clientInfo.Level.ClanTag(Config);
+
+                customRankName = await _metaService.GetPersistentMeta("rank", clientInfo);
+                if (customRankName == null)
+                {
+                    await _metaService.AddPersistentMeta("rank", "none", clientInfo);
+                    customRankName = await _metaService.GetPersistentMeta("rank", clientInfo);
+                }
+
+                if (!(customRankName.Value.Contains("none")) && !(customRankName.Value.Contains("None")) && !(customRankName.Value.Contains("NONE")))
+                {
+                    rankName = customRankName.Value;
+
+                }
+
+                var sb = new StringBuilder();
+                sb.AppendLine(rankName);
+
+                return Content(sb.ToString());
+            }
+
+            return Content("Error: Client info is null");
+        }
         [HttpGet("{clientname}")]
-        public IActionResult Clientname(string clientname)
+        public async Task<IActionResult> Clientname(string clientname)
         {
 
             var clientInfo = Manager.GetActiveClients()
                 .FirstOrDefault(c => c.Name == clientname);
 
+
             if (clientInfo != null)
             {
 
-                switch ((int)clientInfo.Level)
+                rankName = clientInfo.Level.ClanTag(Config);
+
+                customRankName = await _metaService.GetPersistentMeta("rank", clientInfo);
+                if (customRankName == null)
                 {
-                    case 0:
-                        rankName = "User";
-                        break;
-                    case 1:
-                        rankName = "User";
-                        break;
-                    case 2:
-                        rankName = "Trusted";
-                        break;
-                    case 3:
-                        rankName = "Mod";
-                        break;
-                    case 4:
-                        rankName = "Admin";
-                        break;
-                    case 5:
-                        rankName = "SrAdmin";
-                        break;
-                    case 6:
-                        rankName = "Owner";
-                        break;
-                    case 7:
-                        rankName = "Creator";
-                        break;
-                    case 8:
-                        rankName = "Console";
-                        break;
-                    default:
-                        break;
+                    await _metaService.AddPersistentMeta("rank", "none", clientInfo);
+                    customRankName = await _metaService.GetPersistentMeta("rank", clientInfo);
                 }
 
+                if (!(customRankName.Value.Contains("none")) || !(customRankName.Value.Contains("None")) || !(customRankName.Value.Contains("NONE")))
+                {
+                    rankName = customRankName.Value;
+
+                }
 
                 var sb = new StringBuilder();
                 sb.AppendLine(rankName);

Plugin.cs

@@ -1,31 +1,41 @@
 using SharedLibraryCore;
 using SharedLibraryCore.Interfaces;
 using System.Threading.Tasks;
+using System.Threading;
+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
     {
         private readonly IConfigurationHandler<Configuration> _configurationHandler;
+        private readonly ILogger _logger;
         private Configuration Config;
         readonly string rank = "rank";
+        string rankName = "none";
 
 
 
-        public string Name => "ClanTagRankApi";
+        public string Name => "ClanTagRankCommands";
 
-        public float Version => 1.01f;
+        public float Version => 1.42f;
 
         public string Author => "INSANEMODE";
 
         private readonly IMetaService _metaService;
 
-        public Plugin(IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory)
+        public Plugin(IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory, ILogger<Plugin> logger)
         {
+            _logger = logger;
             _metaService = metaService;
-            _configurationHandler = (IConfigurationHandler<Configuration>)configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankApi");
+            _configurationHandler = (IConfigurationHandler<Configuration>)configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
         }
         public Task OnLoadAsync(IManager manager)// => Task.CompletedTask;
         {
@@ -37,21 +47,138 @@ namespace ClanTagRankApi
             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);
-            manager.GetLogger(0L).WriteVerbose(str);
-            
+            _logger.LogInformation(str);
+
             return Task.CompletedTask;
         }
         public async Task OnEventAsync(GameEvent E, Server S)// => Task.CompletedTask;
         {
-            if (E.Type == GameEvent.EventType.Join)
+
+            //if (E.Type == GameEvent.EventType.Join || E.Type == GameEvent.EventType.ChangePermission )
+            if ((E.Type == GameEvent.EventType.Other) && E.Subtype.Contains("RC"))
             {
-                var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
-                if (rank_player_var == null)
+                //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.Target);
-                    rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
+                    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());
+                    }
                 }
+
             }
+            //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)// =>
@@ -64,6 +191,47 @@ namespace ClanTagRankApi
         public Task OnUnloadAsync() => Task.CompletedTask;
 
 
-    
     }
+    public static class yadb
+    {
+        public static Task notifyYADB(string message, string title, string reason, string icon, Server S, EFClient OriginClient, EFClient TargetClient)
+        {
+            string json = "";
+            using (var stream = new System.IO.MemoryStream())
+            {
+                using (var writer = new System.Text.Json.Utf8JsonWriter(stream))
+                {
+                    writer.WriteStartObject();
+                    writer.WriteString("title", title);
+                    writer.WriteString("message", message);
+                    writer.WriteString("reason", reason);
+                    writer.WriteString("icon", icon);
+                    writer.WriteEndObject();
+                }
+
+                json = System.Text.Encoding.UTF8.GetString(stream.ToArray());
+            }
+            var e = new GameEvent()
+            {
+                Origin = OriginClient,
+                Target = TargetClient,
+                Owner = S,
+                Type = GameEvent.EventType.Other,
+                Subtype = "YADB-Embed",
+                Extra = json
+            };
+
+            S.ExecuteEvent(e);
+            Console.WriteLine("event triggered!" + message);
+            return Task.CompletedTask;
+
+
+
+            //notifyYADB("Kicked player @{target} after a successful vote started from @{origin}", $"Vote kicked {target.Name}", gameEvent.Data,":pencil:", Server, origin, target);
+        }
+
+
+    }
+
+
 }

README.md

@@ -1,6 +1,20 @@
-# ClanTagRankApi
+# ClanTagRankCommands
 
-c# plugin for iw4m-admin that adds to the api to allow ClanTagRank to get the (shortened to fit in a clan tag) rank/role of a player based on name.
+c# plugin for iw4m-admin that interacts with ClanTagRank to set the ClanTag of players, either by iw4m-admin permission level, or a custom one set with ```!setRank <player> <tag>```.
+
+
+# Commands
+```(!sr) !setRank <player> <tag>```
+
+```(!rr) !ResetRank <player>```
+
+by default, these require permission level Admin or above, this can be changed,
+
+along with the command names and alias in ```./Configuration/CommnadConfiguration.json```
 
 # Installation
-download the latest ClanTagRankApi.dll from the releases page and place it in the Plugins folder of your iw4m-admin folder, and then head over to https://gitea.insanemode.org/INSANEMODE/ClanTagRank and follow the instructions there.
+download the latest ClanTagRankCommands.dll from the releases page and place it in the Plugins folder of your iw4m-admin folder, and then head over to https://gitea.insanemode.org/INSANEMODE/ClanTagRank and follow the instructions there.
+
+# Configuration
+You can change the default rank names in ```./Configuration/ClanTagRankCommands.json```
+if you do not have it, make sure you are up to date, and you run iw4m-admin to generate the default Configuration.

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