Update 'README.md'

Reviewed-on: #3

ClanTag.cs

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

@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2.4.9" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2020.11.18.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Commands/ResetRankCommand.cs

@@ -0,0 +1,60 @@
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Interfaces;
+using System;
+using System.Threading.Tasks;
+
+
+
+namespace ClanTagRankApi.Commands
+{
+    /// <summary>
+    /// Example script command
+    /// </summary>
+    public class ResetRankCommand : Command
+    {
+        readonly string rank = "rank";
+        string rank_string;
+        private readonly IMetaService _metaService;
+        private readonly IConfigurationHandler<Configuration> _configurationHandler;
+        private Configuration Config;
+
+        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";
+            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);
+        }
+    }
+}

Commands/SetRankCommand.cs

@@ -0,0 +1,95 @@
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Interfaces;
+using System.Threading.Tasks;
+
+
+namespace ClanTagRankApi.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, 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";
+            Permission = EFClient.Permission.Administrator;
+            RequiresTarget = true;
+            Arguments = new[]
+            {
+                new CommandArgument()
+                {
+                    Name = "rank",
+                    Required = true
+                }
+            };
+        }
+
+        public override async Task ExecuteAsync(GameEvent E)
+        {
+            //var S = E.Owner;
+            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)
+            {
+                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");
+            }
+
+
+            await E.Owner.ExecuteCommandAsync("setrank" + " " + E.Target.ClientNumber + " " + rank_string);
+        }
+    }
+}

Configuration.cs

@@ -3,18 +3,36 @@ using SharedLibraryCore.Interfaces;
 
 namespace ClanTagRankApi
 {
-    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 = "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";
     }
 }

GscApiController.cs

@@ -1,8 +1,12 @@
-using Microsoft.AspNetCore.Mvc;
+using ClanTagRankApi;
+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 +15,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 +37,64 @@ namespace WebfrontCore.Controllers.API
         /// </summary>
         /// <param name="clientname"></param>
         /// <returns></returns>
-
-        [HttpGet("{clientname}")]
-        public IActionResult Clientname(string clientname)
+        [HttpGet("{clientguid}")]
+        public async Task<IActionResult> Clientguid(string clientguid)
         {
-            
+            long decimalNetworkId = clientguid.ConvertGuidToLong(System.Globalization.NumberStyles.Integer);
             var clientInfo = Manager.GetActiveClients()
-                .FirstOrDefault(c => c.Name == clientname);
+                .FirstOrDefault(c => c.NetworkId == decimalNetworkId);
 
             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 = "Sr.Admin";
-                        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);
+
+                return Content(sb.ToString());
+            }
+
+            return Content("Error: Client info is null");
+        }
+        [HttpGet("{clientname}")]
+        public async Task<IActionResult> Clientname(string clientname)
+        {
+
+            var clientInfo = Manager.GetActiveClients()
+                .FirstOrDefault(c => c.Name == clientname);
+
+
+            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);

Plugin.cs

@@ -1,6 +1,11 @@
 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;
 
 
 namespace ClanTagRankApi
@@ -9,23 +14,26 @@ namespace ClanTagRankApi
     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 => "ClanTagRankCommands";
 
-        public string Name => "ClanTagRankApi";
-
-        public float Version => 1.0f;
+        public float Version => 1.31f;
 
         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,12 +45,62 @@ 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 Task OnEventAsync(GameEvent E, Server S) => 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)
+                {
+                    await _metaService.AddPersistentMeta("rank", "none", E.Origin);
+                    rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
+                }
+
+                if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
+                {
+                    rankName = rank_player_var.Value;
+
+                }
+
+                await S.ExecuteCommandAsync("setrank" + " " + E.Origin.ClientNumber + " " + rankName);
+            }
+            if (E.Type == GameEvent.EventType.Start || E.Type == GameEvent.EventType.MapEnd || E.Type == GameEvent.EventType.MapChange)
+            {
+                Thread.Sleep(10000);
+                IList<EFClient> currentclients = E.Owner.Manager.GetActiveClients();
+                foreach(EFClient client in currentclients)
+                {
+                    var rank_player_var = await _metaService.GetPersistentMeta(rank, client);
+                    rankName = client.Level.ClanTag(Config);
+
+                    rank_player_var = await _metaService.GetPersistentMeta("rank", client);
+                    if (rank_player_var == null)
+                    {
+                        await _metaService.AddPersistentMeta("rank", "none", client);
+                        rank_player_var = await _metaService.GetPersistentMeta("rank", client);
+                    }
+
+                    if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
+                    {
+                        rankName = rank_player_var.Value;
+
+                    }
+
+                    await S.ExecuteCommandAsync("setrank" + " " + client.ClientNumber + " " + rankName);
+
+                }
+
+            }
+            //return Task.CompletedTask;
+        }
         public Task OnTickAsync(Server S)// =>
         {
 
@@ -53,6 +111,5 @@ namespace ClanTagRankApi
         public Task OnUnloadAsync() => Task.CompletedTask;
 
 
-    
     }
 }

README.md

@@ -0,0 +1,20 @@
+# ClanTagRankCommands
+
+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 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.