IW4M-Admin/SharedLibraryCore/Utilities.cs

1362 lines
49 KiB
C#
Raw Normal View History

2022-01-26 11:32:16 -05:00
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
2022-01-26 11:32:16 -05:00
using System.Net.Http;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
2022-01-26 11:32:16 -05:00
using Data.Models;
using Humanizer;
using Humanizer.Localisation;
2023-04-05 10:54:57 -04:00
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using SharedLibraryCore.Configuration;
2022-01-26 11:32:16 -05:00
using SharedLibraryCore.Database.Models;
using SharedLibraryCore.Dtos.Meta;
2023-04-05 10:54:57 -04:00
using SharedLibraryCore.Events.Server;
using SharedLibraryCore.Exceptions;
2022-01-26 11:32:16 -05:00
using SharedLibraryCore.Helpers;
using SharedLibraryCore.Interfaces;
using SharedLibraryCore.Localization;
using SharedLibraryCore.RCon;
using static System.Threading.Tasks.Task;
using static SharedLibraryCore.Server;
using static Data.Models.Client.EFClient;
using static Data.Models.EFPenalty;
2022-01-26 11:32:16 -05:00
using ILogger = Microsoft.Extensions.Logging.ILogger;
2018-04-08 02:44:42 -04:00
namespace SharedLibraryCore
{
public static class Utilities
{
// note: this is only to be used by classes not created by dependency injection
public static ILogger DefaultLogger { get; set; }
#if DEBUG == true
public static string OperatingDirectory => $"{Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)}{Path.DirectorySeparatorChar}";
#else
2022-01-26 11:32:16 -05:00
public static string OperatingDirectory =>
$"{Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)}{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}";
#endif
2018-04-21 18:18:20 -04:00
public static Encoding EncodingType;
2022-01-26 11:32:16 -05:00
public static Layout CurrentLocalization = new Layout(new Dictionary<string, string>());
2023-04-05 10:54:57 -04:00
public static TimeSpan DefaultCommandTimeout { get; set; } = new(0, 0, /*Utilities.IsDevelopment ? 360 : */25);
2022-01-26 11:32:16 -05:00
public static char[] DirectorySeparatorChars = { '\\', '/' };
public static char CommandPrefix { get; set; } = '!';
2022-01-26 11:32:16 -05:00
public static string ToStandardFormat(this DateTime? time) => time?.ToString("yyyy-MM-dd H:mm:ss UTC");
public static string ToStandardFormat(this DateTime time) => time.ToString("yyyy-MM-dd H:mm:ss UTC");
2022-06-05 17:27:56 -04:00
public static EFClient IW4MAdminClient(Server server = null)
{
2022-01-26 11:32:16 -05:00
return new EFClient
{
ClientId = 1,
State = EFClient.ClientState.Connected,
2022-01-26 11:32:16 -05:00
Level = Permission.Console,
CurrentServer = server,
2022-01-26 11:32:16 -05:00
CurrentAlias = new EFAlias
{
Name = "IW4MAdmin"
2018-12-03 20:21:13 -05:00
},
AdministeredPenalties = new List<EFPenalty>()
};
}
2022-01-26 11:32:16 -05:00
2023-04-05 10:54:57 -04:00
public static EFClient AsConsoleClient(this IGameServer server)
{
return new EFClient
{
ClientId = 1,
State = EFClient.ClientState.Connected,
Level = Permission.Console,
CurrentServer = server as Server,
CurrentAlias = new EFAlias
{
Name = "IW4MAdmin"
},
AdministeredPenalties = new List<EFPenalty>()
};
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// fallback id for world events
/// </summary>
public const long WORLD_ID = -1;
2022-01-26 11:32:16 -05:00
2022-07-09 21:57:00 -04:00
public static Dictionary<Permission, string> PermissionLevelOverrides { get; } = new ();
//Remove words from a space delimited string
2022-01-26 11:32:16 -05:00
public static string RemoveWords(this string str, int num)
{
if (str == null || str.Length == 0)
{
return "";
}
2022-01-26 11:32:16 -05:00
var newStr = string.Empty;
var tmp = str.Split(' ');
2022-01-26 11:32:16 -05:00
for (var i = 0; i < tmp.Length; i++)
if (i >= num)
{
newStr += tmp[i] + ' ';
}
return newStr;
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// caps client name to the specified character length - 3
2023-04-05 10:54:57 -04:00
/// and adds ellipses to the end of the remaining client name
/// </summary>
2023-04-05 10:54:57 -04:00
/// <param name="name">client name</param>
/// <param name="maxLength">max number of characters for the name</param>
/// <returns></returns>
2023-04-05 10:54:57 -04:00
public static string CapClientName(this string name, int maxLength)
2022-01-26 11:32:16 -05:00
{
2023-04-05 10:54:57 -04:00
if (string.IsNullOrWhiteSpace(name))
{
return "-";
}
return name.Length > maxLength ? $"{name[..(maxLength - 3)]}..." : name;
2022-01-26 11:32:16 -05:00
}
2022-01-26 11:32:16 -05:00
public static Permission MatchPermission(string str)
{
2022-01-26 11:32:16 -05:00
var lookingFor = str.ToLower();
2022-07-09 21:57:00 -04:00
for (var perm = Permission.User; perm < Permission.Console; perm++)
if (lookingFor.Contains(perm.ToString().ToLower())
2022-01-26 11:32:16 -05:00
|| lookingFor.Contains(CurrentLocalization
2022-07-09 21:57:00 -04:00
.LocalizationIndex[$"GLOBAL_PERMISSION_{perm.ToString().ToUpper()}"].ToLower()))
{
2022-07-09 21:57:00 -04:00
return perm;
}
2022-01-26 11:32:16 -05:00
return Permission.Banned;
}
2015-08-23 17:58:48 -04:00
/// <summary>
2022-01-26 11:32:16 -05:00
/// Remove all IW Engine color codes
2015-08-23 17:58:48 -04:00
/// </summary>
/// <param name="str">String containing color codes</param>
/// <returns></returns>
public static string StripColors(this string str)
{
if (str == null)
{
return "";
}
2018-03-06 02:22:19 -05:00
str = Regex.Replace(str, @"(\^+((?![a-z]|[A-Z]).){0,1})+", "");
str = Regex.Replace(str, @"\(Color::(.{1,16})\)", "");
2019-08-02 19:04:34 -04:00
return str;
}
2019-08-02 19:04:34 -04:00
/// <summary>
2022-01-26 11:32:16 -05:00
/// returns a "fixed" string that prevents message truncation in IW4 (and probably other Q3 clients)
2019-08-02 19:04:34 -04:00
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
2022-01-26 11:32:16 -05:00
public static string FixIW4ForwardSlash(this string str)
{
return str.Replace("//", "/ /");
}
2022-07-08 21:40:27 -04:00
public static string RemoveDiacritics(this string text)
{
var normalizedString = text.Normalize(NormalizationForm.FormD);
2022-07-08 21:40:27 -04:00
var stringBuilder = new StringBuilder();
2019-08-02 19:04:34 -04:00
2022-07-08 21:40:27 -04:00
foreach (var c in from c in normalizedString.EnumerateRunes()
let unicodeCategory = Rune.GetUnicodeCategory(c)
where unicodeCategory != UnicodeCategory.NonSpacingMark
select c)
{
stringBuilder.Append(c);
}
2022-07-08 21:40:27 -04:00
return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
}
public static string FormatMessageForEngine(this string str, IRConParserConfiguration config)
{
if (config == null || string.IsNullOrEmpty(str))
{
return str;
}
var output = str;
2023-06-24 21:08:40 -04:00
var colorCodeMatches = Regex.Matches(output, @"\(Color::(\w{1,16})\)",
2022-01-26 11:32:16 -05:00
RegexOptions.IgnoreCase | RegexOptions.Compiled);
foreach (var match in colorCodeMatches.Where(m => m.Success))
{
var key = match.Groups[1].ToString();
output = output.Replace(match.Value, config.ColorCodeMapping.TryGetValue(key, out var code) ? code : "");
}
if (config.ShouldRemoveDiacritics)
{
output = output.RemoveDiacritics();
}
2022-04-28 18:22:15 -04:00
return output.FixIW4ForwardSlash();
}
2022-07-09 21:57:00 -04:00
private static readonly IList<string> ZmGameTypes = new[]
{ "zclassic", "zstandard", "zcleansed", "zgrief", "zom", "cmp" };
2022-01-26 11:32:16 -05:00
/// <summary>
2022-01-26 11:32:16 -05:00
/// indicates if the given server is running a zombie game mode
/// </summary>
/// <param name="server"></param>
/// <returns></returns>
2022-01-26 11:32:16 -05:00
public static bool IsZombieServer(this Server server)
{
2022-07-09 21:57:00 -04:00
return new[] { Game.T4, Game.T5, Game.T6 }.Contains(server.GameName) &&
ZmGameTypes.Contains(server.Gametype.ToLower());
2022-01-26 11:32:16 -05:00
}
2022-01-26 11:32:16 -05:00
public static bool IsCodGame(this Server server)
{
return server.RconParser?.RConEngine == "COD";
}
2015-08-23 17:58:48 -04:00
/// <summary>
2022-01-26 11:32:16 -05:00
/// Get the color key corresponding to a given user level
2015-08-23 17:58:48 -04:00
/// </summary>
/// <param name="level">Specified player level</param>
/// <param name="localizedLevel"></param>
2015-08-23 17:58:48 -04:00
/// <returns></returns>
public static string ConvertLevelToColor(Permission level, string localizedLevel)
{
// todo: make configurable
var colorCode = level switch
{
Permission.Banned => "Red",
Permission.Flagged => "Map",
Permission.Owner => "Accent",
Permission.User => "Yellow",
Permission.Trusted => "Green",
_ => "Pink"
};
return $"(Color::{colorCode}){localizedLevel ?? level.ToString()}";
}
public static string ToLocalizedLevelName(this Permission permission)
{
2022-01-26 11:32:16 -05:00
var localized =
CurrentLocalization.LocalizationIndex[$"GLOBAL_PERMISSION_{permission.ToString().ToUpper()}"];
return PermissionLevelOverrides.ContainsKey(permission) && PermissionLevelOverrides[permission] != permission.ToString()
? PermissionLevelOverrides[permission]
: localized;
}
2022-01-26 11:32:16 -05:00
public static async Task<string> ProcessMessageToken(this Server server, IList<MessageToken> tokens, string str)
{
2022-01-26 11:32:16 -05:00
var RegexMatches = Regex.Matches(str, @"\{\{[A-Z]+\}\}", RegexOptions.IgnoreCase);
foreach (Match M in RegexMatches)
{
2022-01-26 11:32:16 -05:00
var Match = M.Value;
var Identifier = M.Value.Substring(2, M.Length - 4);
var found = tokens.FirstOrDefault(t => t.Name.ToLower() == Identifier.ToLower());
if (found != null)
{
2019-02-19 20:39:09 -05:00
str = str.Replace(Match, await found.ProcessAsync(server));
}
}
return str;
}
public static bool IsBroadcastCommand(this string str, string broadcastCommandPrefix)
{
return str.StartsWith(broadcastCommandPrefix);
}
2015-08-23 17:58:48 -04:00
/// <summary>
2022-01-26 11:32:16 -05:00
/// Get the full gametype name
2015-08-23 17:58:48 -04:00
/// </summary>
/// <param name="input">Shorthand gametype reported from server</param>
/// <returns></returns>
2022-01-26 11:32:16 -05:00
public static string GetLocalizedGametype(string input)
{
switch (input)
{
case "dm":
return "Deathmatch";
case "war":
return "Team Deathmatch";
case "koth":
return "Headquarters";
case "ctf":
return "Capture The Flag";
case "dd":
return "Demolition";
case "dom":
return "Domination";
case "sab":
return "Sabotage";
case "sd":
return "Search & Destroy";
case "vip":
return "Very Important Person";
case "gtnw":
return "Global Thermonuclear War";
case "oitc":
return "One In The Chamber";
case "arena":
return "Arena";
case "dzone":
return "Drop Zone";
case "gg":
return "Gun Game";
case "snipe":
return "Sniping";
case "ss":
return "Sharp Shooter";
case "m40a3":
return "M40A3";
case "fo":
return "Face Off";
case "dmc":
return "Deathmatch Classic";
case "killcon":
return "Kill Confirmed";
case "oneflag":
return "One Flag CTF";
default:
return input;
}
}
2023-01-23 17:38:16 -05:00
public static long ConvertGuidToLong(this string str, NumberStyles numberStyle, long? fallback = null)
{
return ConvertGuidToLong(str, numberStyle, true, fallback);
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// converts a string to numerical guid
/// </summary>
/// <param name="str">source string for guid</param>
/// <param name="numberStyle">how to parse the guid</param>
/// <param name="fallback">value to use if string is empty</param>
2023-01-23 17:38:16 -05:00
/// <param name="convertSigned">convert signed values to unsigned</param>
/// <returns></returns>
2023-01-23 17:38:16 -05:00
public static long ConvertGuidToLong(this string str, NumberStyles numberStyle, bool convertSigned, long? fallback = null)
{
2021-06-03 11:51:03 -04:00
// added for source games that provide the steam ID
var match = Regex.Match(str, @"^STEAM_(\d):(\d):(\d+)$");
if (match.Success)
{
var x = int.Parse(match.Groups[1].ToString());
var y = int.Parse(match.Groups[2].ToString());
var z = long.Parse(match.Groups[3].ToString());
2021-07-01 11:14:58 -04:00
return z * 2 + 0x0110000100000000 + y;
}
2022-01-26 11:32:16 -05:00
2023-01-23 17:38:16 -05:00
str = str.Substring(0, Math.Min(str.Length, str.StartsWith("-") ? 20 : 19));
var parsableAsNumber = Regex.Match(str, @"([A-F]|[a-f]|[0-9])+").Value;
2019-02-10 21:05:50 -05:00
if (string.IsNullOrWhiteSpace(str) && fallback.HasValue)
{
return fallback.Value;
}
long id;
if (!string.IsNullOrEmpty(parsableAsNumber))
{
if (numberStyle == NumberStyles.Integer)
{
long.TryParse(str, numberStyle, CultureInfo.InvariantCulture, out id);
2023-01-23 17:38:16 -05:00
if (id < 0 && convertSigned)
{
id = (uint)id;
}
}
else
2019-06-15 09:52:59 -04:00
{
2022-01-26 11:32:16 -05:00
long.TryParse(str.Length > 16 ? str.Substring(0, 16) : str, numberStyle,
CultureInfo.InvariantCulture, out id);
2019-06-15 09:52:59 -04:00
}
}
else
{
// this is a special case for when a real guid is not provided, so we generated it from another source
id = str.GenerateGuidFromString();
}
if (id == 0)
{
2019-06-15 09:52:59 -04:00
throw new FormatException($"Could not parse client GUID - {str}");
}
return id;
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// determines if the guid provided appears to be a bot guid
/// "1277538174" - (Pluto?)WaW (T4)
/// </summary>
/// <param name="guid">value of the guid</param>
/// <returns>true if is bot guid, otherwise false</returns>
public static bool IsBotGuid(this string guid)
{
return guid.Contains("bot") || guid == "0" || guid == "1277538174";
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// generates a numerical hashcode from a string value
/// </summary>
/// <param name="value">value string</param>
/// <returns></returns>
2022-01-26 11:32:16 -05:00
public static long GenerateGuidFromString(this string value)
{
return string.IsNullOrEmpty(value) ? -1 : GetStableHashCode(value.StripColors());
}
/// https://stackoverflow.com/questions/36845430/persistent-hashcode-for-strings
public static int GetStableHashCode(this string str)
{
unchecked
{
2022-01-26 11:32:16 -05:00
var hash1 = 5381;
var hash2 = hash1;
2022-01-26 11:32:16 -05:00
for (var i = 0; i < str.Length && str[i] != '\0'; i += 2)
{
hash1 = ((hash1 << 5) + hash1) ^ str[i];
if (i == str.Length - 1 || str[i + 1] == '\0')
2022-01-26 11:32:16 -05:00
{
break;
2022-01-26 11:32:16 -05:00
}
hash2 = ((hash2 << 5) + hash2) ^ str[i + 1];
}
2022-01-26 11:32:16 -05:00
return hash1 + hash2 * 1566083941;
}
}
public static int? ConvertToIP(this string str)
{
2022-01-26 11:32:16 -05:00
var success = IPAddress.TryParse(str, out var ip);
return success && ip.GetAddressBytes().Count(_byte => _byte == 0) != 4
2022-07-09 21:57:00 -04:00
? BitConverter.ToInt32(ip.GetAddressBytes(), 0)
2022-01-26 11:32:16 -05:00
: null;
}
public static string ConvertIPtoString(this int? ip)
{
return !ip.HasValue ? "" : new IPAddress(BitConverter.GetBytes(ip.Value)).ToString();
}
public static Game GetGame(string gameName)
{
2019-02-01 20:49:25 -05:00
if (string.IsNullOrEmpty(gameName))
{
return Game.UKN;
}
if (gameName.Contains("IW4"))
{
return Game.IW4;
}
if (gameName.Contains("CoD4"))
{
return Game.IW3;
}
if (gameName.Contains("COD_WaW"))
{
return Game.T4;
}
if (gameName.Contains("T5"))
{
return Game.T5;
}
if (gameName.Contains("IW5"))
{
return Game.IW5;
}
if (gameName.Contains("COD_T6_S"))
{
return Game.T6;
}
return Game.UKN;
}
public static TimeSpan ParseTimespan(this string input)
{
var expressionMatch = Regex.Match(input, @"([0-9]+)(\w+)");
if (!expressionMatch.Success) // fallback to default tempban length of 1 hour
{
return new TimeSpan(1, 0, 0);
}
2022-01-26 11:32:16 -05:00
var lengthDenote = expressionMatch.Groups[2].ToString()[0];
var length = int.Parse(expressionMatch.Groups[1].ToString());
var loc = CurrentLocalization.LocalizationIndex;
if (lengthDenote == char.ToLower(loc["GLOBAL_TIME_MINUTES"][0]))
{
return new TimeSpan(0, length, 0);
}
if (lengthDenote == char.ToLower(loc["GLOBAL_TIME_HOURS"][0]))
{
return new TimeSpan(length, 0, 0);
}
if (lengthDenote == char.ToLower(loc["GLOBAL_TIME_DAYS"][0]))
{
return new TimeSpan(length, 0, 0, 0);
}
if (lengthDenote == char.ToLower(loc["GLOBAL_TIME_WEEKS"][0]))
{
return new TimeSpan(length * 7, 0, 0, 0);
}
if (lengthDenote == char.ToLower(loc["GLOBAL_TIME_YEARS"][0]))
{
return new TimeSpan(length * 365, 0, 0, 0);
}
return new TimeSpan(1, 0, 0);
}
public static bool HasPermission<TEntity, TPermission>(this IEnumerable<string> permissionsSet, TEntity entity,
TPermission permission) where TEntity : Enum where TPermission : Enum
{
2022-04-19 19:43:58 -04:00
if (permissionsSet == null)
{
2022-04-19 19:43:58 -04:00
return false;
}
var requiredPermission = $"{entity.ToString()}.{permission.ToString()}";
var hasAllPermissions = permissionsSet.Any(p => p.Equals("*"));
var permissionCheckResult = permissionsSet.Select(p =>
{
if (p.Equals(requiredPermission, StringComparison.InvariantCultureIgnoreCase))
{
return true;
}
2022-04-19 19:43:58 -04:00
if (p.Equals($"-{requiredPermission}", StringComparison.InvariantCultureIgnoreCase))
{
return false;
}
2022-04-19 19:43:58 -04:00
return (bool?)null;
}).ToList();
2022-04-19 19:43:58 -04:00
var permissionNegated = permissionCheckResult.Any(result => result.HasValue && !result.Value);
if (permissionNegated)
{
return false;
}
2022-04-19 19:43:58 -04:00
return hasAllPermissions || permissionCheckResult.Any(result => result.HasValue && result.Value);
}
public static bool HasPermission<TEntity, TPermission>(this ApplicationConfiguration appConfig,
Permission permissionLevel, TEntity entity,
TPermission permission) where TEntity : Enum where TPermission : Enum
{
return appConfig.PermissionSets.ContainsKey(permissionLevel.ToString()) &&
HasPermission(appConfig.PermissionSets[permissionLevel.ToString()], entity, permission);
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// returns a list of penalty types that should be shown across all profiles
/// </summary>
/// <returns></returns>
public static PenaltyType[] LinkedPenaltyTypes()
{
2019-07-17 13:29:51 -04:00
return new[]
{
PenaltyType.Ban,
PenaltyType.Unban,
PenaltyType.TempBan,
PenaltyType.Flag,
2022-01-26 11:32:16 -05:00
PenaltyType.Unflag
};
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// Helper extension that determines if a user is a privileged client
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public static bool IsPrivileged(this EFClient p)
{
2022-01-26 11:32:16 -05:00
return p.Level > Permission.Flagged;
}
2018-03-06 02:22:19 -05:00
/// <summary>
2022-01-26 11:32:16 -05:00
/// prompt user to answer a yes/no question
/// </summary>
/// <param name="question">question to prompt the user with</param>
/// <param name="description">description of the question's value</param>
/// <param name="defaultValue">default value to set if no input is entered</param>
/// <returns></returns>
public static bool PromptBool(this string question, string description = null, bool defaultValue = true)
{
Console.Write($"{question}?{(string.IsNullOrEmpty(description) ? " " : $" ({description}) ")}[y/n]: ");
2022-07-09 21:57:00 -04:00
var response = Console.ReadLine()?.ToLower().FirstOrDefault();
return response != 0 ? response == 'y' : defaultValue;
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// prompt user to make a selection
/// </summary>
/// <typeparam name="T">type of selection</typeparam>
/// <param name="question">question to prompt the user with</param>
/// <param name="defaultValue">default value to set if no input is entered</param>
/// <param name="description">description of the question's value</param>
/// <param name="selections">array of possible selections (should be able to convert to string)</param>
/// <returns></returns>
2022-01-26 11:32:16 -05:00
public static Tuple<int, T> PromptSelection<T>(this string question, T defaultValue, string description = null,
params T[] selections)
{
2022-01-26 11:32:16 -05:00
var hasDefault = false;
if (defaultValue != null)
{
hasDefault = true;
2022-01-26 11:32:16 -05:00
selections = new[] { defaultValue }.Union(selections).ToArray();
}
2022-01-26 11:32:16 -05:00
Console.WriteLine($"{question}{(string.IsNullOrEmpty(description) ? "" : $" [{description}:]")}");
Console.WriteLine(new string('=', 52));
2022-01-26 11:32:16 -05:00
for (var index = 0; index < selections.Length; index++)
Console.WriteLine($"{(hasDefault ? index : index + 1)}] {selections[index]}");
Console.WriteLine(new string('=', 52));
2022-01-26 11:32:16 -05:00
var selectionIndex = PromptInt(CurrentLocalization.LocalizationIndex["SETUP_PROMPT_MAKE_SELECTION"], null,
2022-07-09 21:57:00 -04:00
hasDefault ? 0 : 1, selections.Length, hasDefault ? 0 : null);
if (!hasDefault)
{
selectionIndex--;
}
2022-01-26 11:32:16 -05:00
var selection = selections[selectionIndex];
return Tuple.Create(selectionIndex, selection);
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// prompt user to enter a number
/// </summary>
/// <param name="question">question to prompt with</param>
/// <param name="maxValue">maximum value to allow</param>
/// <param name="minValue">minimum value to allow</param>
/// <param name="defaultValue">default value to set the return value to</param>
/// <param name="description">a description of the question's value</param>
/// <returns>integer from user's input</returns>
2022-01-26 11:32:16 -05:00
public static int PromptInt(this string question, string description = null, int minValue = 0,
int maxValue = int.MaxValue, int? defaultValue = null)
{
2022-01-26 11:32:16 -05:00
Console.Write(
$"{question}{(string.IsNullOrEmpty(description) ? "" : $" ({description})")}{(defaultValue == null ? "" : $" [{CurrentLocalization.LocalizationIndex["SETUP_PROMPT_DEFAULT"]} {defaultValue.Value.ToString()}]")}: ");
int response;
2022-07-09 21:57:00 -04:00
string InputOrDefault()
{
2022-01-26 11:32:16 -05:00
var input = Console.ReadLine();
return string.IsNullOrEmpty(input) && defaultValue != null ? defaultValue.ToString() : input;
}
2022-07-09 21:57:00 -04:00
while (!int.TryParse(InputOrDefault(), out response) ||
2022-01-26 11:32:16 -05:00
response < minValue ||
response > maxValue)
{
2022-01-26 11:32:16 -05:00
var range = "";
if (minValue != 0 || maxValue != int.MaxValue)
{
range = $" [{minValue}-{maxValue}]";
}
2022-01-26 11:32:16 -05:00
Console.Write($"{CurrentLocalization.LocalizationIndex["SETUP_PROMPT_INT"]}{range}: ");
}
return response;
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// prompt use to enter a string response
/// </summary>
/// <param name="question">question to prompt with</param>
/// <param name="description">description of the question's value</param>
/// <param name="defaultValue">default value to set the return value to</param>
/// <returns></returns>
public static string PromptString(this string question, string description = null, string defaultValue = null)
{
2022-07-09 21:57:00 -04:00
string InputOrDefault()
{
2022-01-26 11:32:16 -05:00
var input = Console.ReadLine();
return string.IsNullOrEmpty(input) && defaultValue != null ? defaultValue : input;
}
string response;
do
{
2022-01-26 11:32:16 -05:00
Console.Write(
$"{question}{(string.IsNullOrEmpty(description) ? "" : $" ({description})")}{(defaultValue == null ? "" : $" [{CurrentLocalization.LocalizationIndex["SETUP_PROMPT_DEFAULT"]} {defaultValue}]")}: ");
2022-07-09 21:57:00 -04:00
response = InputOrDefault();
} while (string.IsNullOrWhiteSpace(response) && response != defaultValue);
return response;
}
public static Dictionary<string, string> DictionaryFromKeyValue(this string eventLine)
{
2023-04-05 10:54:57 -04:00
var values = eventLine[1..].Split('\\');
Dictionary<string, string> dict = new();
2023-04-05 10:54:57 -04:00
if (values.Length <= 1)
{
return dict;
}
2023-04-05 10:54:57 -04:00
for (var i = values.Length % 2 == 0 ? 0 : 1; i < values.Length; i += 2)
{
2023-04-05 10:54:57 -04:00
if (!dict.ContainsKey(values[i]))
{
dict.Add(values[i], values[i + 1]);
2023-04-05 10:54:57 -04:00
}
}
return dict;
}
/* https://loune.net/2017/06/running-shell-bash-commands-in-net-core/ */
public static string GetCommandLine(int pId)
{
2022-01-26 11:32:16 -05:00
var cmdProcess = new Process
{
2022-01-26 11:32:16 -05:00
StartInfo = new ProcessStartInfo
{
FileName = "cmd.exe",
Arguments = $"/c wmic process where processid={pId} get CommandLine",
RedirectStandardOutput = true,
UseShellExecute = false,
2022-01-26 11:32:16 -05:00
CreateNoWindow = true
}
};
cmdProcess.Start();
cmdProcess.WaitForExit();
2022-01-26 11:32:16 -05:00
var cmdLine = cmdProcess.StandardOutput.ReadToEnd().Split("\r\n", StringSplitOptions.RemoveEmptyEntries);
2019-07-27 16:23:45 -04:00
cmdProcess.Dispose();
return cmdLine.Length > 1 ? cmdLine[1] : cmdLine[0];
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// indicates if the given log path is a remote (http) uri
/// </summary>
/// <param name="log"></param>
/// <returns></returns>
2019-02-10 21:05:50 -05:00
public static bool IsRemoteLog(this string log)
{
return (log ?? "").StartsWith("http");
}
public static string ToBase64UrlSafeString(this string src)
{
2022-01-26 11:32:16 -05:00
return Convert.ToBase64String(src.Select(c => Convert.ToByte(c)).ToArray()).Replace('+', '-')
.Replace('/', '_');
}
public static async Task<Dvar<T>> GetDvarAsync<T>(this Server server, string dvarName,
T fallbackValue = default, CancellationToken token = default)
{
return await server.RconParser.GetDvarAsync(server.RemoteConnection, dvarName, fallbackValue, token);
}
public static async Task<Dvar<T>> GetDvarAsync<T>(this Server server, string dvarName,
T fallbackValue = default)
{
return await GetDvarAsync(server, dvarName, fallbackValue, default);
}
2022-01-26 11:32:16 -05:00
public static async Task<Dvar<T>> GetMappedDvarValueOrDefaultAsync<T>(this Server server, string dvarName,
string infoResponseName = null, IDictionary<string, string> infoResponse = null,
T overrideDefault = default, CancellationToken token = default)
{
// todo: unit test this
2022-01-26 11:32:16 -05:00
var mappedKey = server.RconParser.GetOverrideDvarName(dvarName);
var defaultValue = server.RconParser.GetDefaultDvarValue<T>(mappedKey) ?? overrideDefault;
2022-01-26 11:32:16 -05:00
var foundKey = infoResponse?.Keys
.Where(_key => new[] { mappedKey, dvarName, infoResponseName ?? dvarName }.Contains(_key))
.FirstOrDefault();
if (!string.IsNullOrEmpty(foundKey))
{
return new Dvar<T>
{
Value = (T)Convert.ChangeType(infoResponse[foundKey], typeof(T)),
Name = foundKey
};
}
return await server.GetDvarAsync(mappedKey, defaultValue, token: token);
}
2023-04-05 10:54:57 -04:00
public static async Task SetDvarAsync(this Server server, string dvarName, object dvarValue,
CancellationToken token)
{
await server.RconParser.SetDvarAsync(server.RemoteConnection, dvarName, dvarValue, token);
}
public static async Task SetDvarAsync(this Server server, string dvarName, object dvarValue)
{
await SetDvarAsync(server, dvarName, dvarValue, default);
}
2023-04-05 10:54:57 -04:00
public static async Task<string[]> ExecuteCommandAsync(this Server server, string commandName,
CancellationToken token)
{
2023-04-05 10:54:57 -04:00
var response = await server.RconParser.ExecuteCommandAsync(server.RemoteConnection, commandName, token);
server.Manager.QueueEvent(new ServerCommandExecuteEvent
{
Server = server,
Source = server,
Command = commandName,
Output = response
});
return response;
}
2023-04-05 10:54:57 -04:00
public static async Task<string[]> ExecuteCommandAsync(this Server server, string commandName)
{
2023-04-05 10:54:57 -04:00
return await ExecuteCommandAsync(server, commandName, default);
}
public static async Task<IStatusResponse> GetStatusAsync(this Server server, CancellationToken token)
{
try
{
return await server.RconParser.GetStatusAsync(server.RemoteConnection, token);
}
catch (TaskCanceledException)
{
return null;
}
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// Retrieves the key value pairs for server information usually checked after map rotation
/// </summary>
/// <param name="server"></param>
/// <param name="delay">How long to wait after the map has rotated to query</param>
/// <returns></returns>
public static async Task<IDictionary<string, string>> GetInfoAsync(this Server server, TimeSpan? delay = null)
{
if (delay != null)
{
await Delay(delay.Value);
}
2022-01-26 11:32:16 -05:00
var response = await server.RemoteConnection.SendQueryAsync(StaticHelpers.QueryType.GET_INFO);
var combinedResponse = response.Length > 1
? string.Join('\\', response.Where(r => r.Length > 0 && r[0] == '\\'))
: response[0];
return combinedResponse.DictionaryFromKeyValue();
2018-05-10 01:34:29 -04:00
}
public static double GetVersionAsDouble()
{
2022-01-26 11:32:16 -05:00
var version = Assembly.GetCallingAssembly().GetName().Version.ToString();
version = version.Replace(".", "");
return double.Parse(version) / 1000.0;
}
public static string GetVersionAsString()
{
return Assembly.GetCallingAssembly().GetName().Version.ToString();
}
public static string FormatExt(this string input, params object[] values)
{
var matches = Regex.Matches(Regex.Unescape(input), @"{{\w+}}");
2022-01-26 11:32:16 -05:00
var output = input;
var index = 0;
foreach (Match match in matches)
{
2022-01-26 11:32:16 -05:00
output = output.Replace(match.Value, $"{{{index.ToString()}}}");
index++;
}
try
{
return string.Format(output, values);
}
2022-01-26 11:32:16 -05:00
catch
{
return input;
}
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// https://stackoverflow.com/questions/8113546/how-to-determine-whether-an-ip-address-in-private/39120248
/// An extension method to determine if an IP address is internal, as specified in RFC1918
/// </summary>
/// <param name="toTest">The IP address that will be tested</param>
/// <returns>Returns true if the IP is internal, false if it is external</returns>
public static bool IsInternal(this IPAddress toTest)
{
if (toTest.ToString().StartsWith("127.0.0"))
{
return true;
}
2022-01-26 11:32:16 -05:00
var bytes = toTest.GetAddressBytes();
switch (bytes[0])
{
case 0:
return bytes[1] == 0 && bytes[2] == 0 && bytes[3] == 0;
case 10:
return true;
case 172:
return bytes[1] < 32 && bytes[1] >= 16;
case 192:
return bytes[1] == 168;
default:
return false;
}
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// retrieves the external IP address of the current running machine
/// </summary>
/// <returns></returns>
public static async Task<string> GetExternalIP()
{
try
{
2022-01-26 11:32:16 -05:00
using var wc = new HttpClient();
return await wc.GetStringAsync("https://api.ipify.org");
}
catch
{
return null;
}
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// Determines if the given message is a quick message
/// </summary>
/// <param name="message"></param>
/// <returns>true if the </returns>
public static bool IsQuickMessage(this string message)
{
return Regex.IsMatch(message, @"^\u0014(?:\w|_|!|\s)+$");
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// trims new line and whitespace from string
/// </summary>
/// <param name="str">source string</param>
/// <returns></returns>
2022-01-26 11:32:16 -05:00
public static string TrimNewLine(this string str)
{
return str.Trim().TrimEnd('\r', '\n');
}
2019-06-30 14:37:59 -04:00
public static Vector3 FixIW4Angles(this Vector3 vector)
{
2022-01-26 11:32:16 -05:00
var X = vector.X >= 0 ? vector.X : 360.0f + vector.X;
var Y = vector.Y >= 0 ? vector.Y : 360.0f + vector.Y;
var Z = vector.Z >= 0 ? vector.Z : 360.0f + vector.Z;
2019-06-30 14:37:59 -04:00
return new Vector3(Y, X, Z);
}
2022-01-26 11:32:16 -05:00
public static float ToRadians(this float value)
{
return (float)Math.PI * value / 180.0f;
}
2019-06-30 14:37:59 -04:00
2022-01-26 11:32:16 -05:00
public static float ToDegrees(this float value)
{
return value * 180.0f / (float)Math.PI;
}
2019-06-30 14:37:59 -04:00
public static double[] AngleStuff(Vector3 a, Vector3 b)
{
2022-01-26 11:32:16 -05:00
var deltaX = 180.0 - Math.Abs(Math.Abs(a.X - b.X) - 180.0);
var deltaY = 180.0 - Math.Abs(Math.Abs(a.Y - b.Y) - 180.0);
2019-06-30 14:37:59 -04:00
return new[] { deltaX, deltaY };
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// attempts to create and persist a penalty
/// </summary>
/// <param name="penalty"></param>
/// <param name="penaltyService"></param>
/// <param name="logger"></param>
/// <returns>true of the create succeeds, false otherwise</returns>
2022-01-26 11:32:16 -05:00
public static async Task<bool> TryCreatePenalty(this EFPenalty penalty,
IEntityService<EFPenalty> penaltyService, ILogger logger)
{
try
{
await penaltyService.Create(penalty);
return true;
}
catch (Exception ex)
{
logger.LogError(ex, "Could not create penalty of type {PenaltyType}", penalty.Type.ToString());
}
return false;
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// https://www.planetgeek.ch/2016/12/08/async-method-without-cancellation-support-do-it-my-way/
/// </summary>
public static async Task WithWaitCancellation(this Task task,
2022-01-26 11:32:16 -05:00
CancellationToken cancellationToken)
{
var completedTask = await WhenAny(task, Delay(Timeout.Infinite, cancellationToken));
if (completedTask == task)
{
await task;
}
else
{
cancellationToken.ThrowIfCancellationRequested();
throw new InvalidOperationException("Infinite delay task completed.");
}
}
2022-02-13 22:38:40 -05:00
public static async Task<T> WithWaitCancellation<T>(this Task<T> task,
CancellationToken cancellationToken)
{
var completedTask = await WhenAny(task, Delay(Timeout.Infinite, cancellationToken));
2022-02-13 22:38:40 -05:00
if (completedTask == task)
{
return await task;
}
cancellationToken.ThrowIfCancellationRequested();
throw new InvalidOperationException("Infinite delay task completed.");
}
public static async Task<T> WithTimeout<T>(this Task<T> task, TimeSpan timeout)
2022-01-26 11:32:16 -05:00
{
await WhenAny(task, Delay(timeout));
2022-01-26 11:32:16 -05:00
return await task;
}
2022-01-26 11:32:16 -05:00
public static async Task WithTimeout(this Task task, TimeSpan timeout)
2022-01-26 11:32:16 -05:00
{
await WhenAny(task, Delay(timeout));
}
2022-01-26 11:32:16 -05:00
public static bool ShouldHideLevel(this Permission perm)
{
return perm == Permission.Flagged;
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// parses translation string into tokens that are able to be formatted by the webfront
/// </summary>
/// <param name="translationKey">key for translation lookup</param>
/// <returns></returns>
public static WebfrontTranslationHelper[] SplitTranslationTokens(string translationKey)
{
2022-01-26 11:32:16 -05:00
var translationString = CurrentLocalization.LocalizationIndex[translationKey];
var builder = new StringBuilder();
var results = new List<WebfrontTranslationHelper>();
2022-01-26 11:32:16 -05:00
foreach (var word in translationString.Split(' '))
{
2022-01-26 11:32:16 -05:00
var finalWord = word;
2022-01-26 11:32:16 -05:00
if (word.StartsWith("{{") && !word.EndsWith("}}") ||
builder.Length > 0 && !word.EndsWith("}}"))
{
builder.Append($"{word} ");
continue;
}
if (builder.Length > 0)
{
builder.Append(word);
finalWord = builder.ToString();
builder.Clear();
}
var match = Regex.Match(finalWord, @"{{([^}|^-]+)(?:->)([^}]+)}}|{{([^}]+)}}");
2022-01-26 11:32:16 -05:00
var isInterpolation = match.Success;
results.Add(new WebfrontTranslationHelper
{
IsInterpolation = isInterpolation,
2022-01-26 11:32:16 -05:00
MatchValue = isInterpolation
? match.Groups[3].Length > 0 ? match.Groups[3].ToString() : match.Groups[1].ToString()
: finalWord,
TranslationValue = isInterpolation && match.Groups[2].Length > 0 ? match.Groups[2].ToString() : ""
});
}
return results.ToArray();
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// indicates if running in development mode
/// </summary>
/// <returns></returns>
2022-01-26 11:32:16 -05:00
public static bool IsDevelopment =>
Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development" || AppContext.TryGetSwitch("IsDevelop", out _);
/// <summary>
2022-01-26 11:32:16 -05:00
/// replaces any directory separator chars with the platform specific character
/// </summary>
/// <param name="path">original file path</param>
/// <returns></returns>
public static string FixDirectoryCharacters(this string path)
{
2022-01-26 11:32:16 -05:00
foreach (var separator in DirectorySeparatorChars)
path = (path ?? "").Replace(separator, Path.DirectorySeparatorChar);
return path;
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// wrapper method for humanizee that uses current current culture
/// </summary>
2022-01-26 11:32:16 -05:00
public static string HumanizeForCurrentCulture(this TimeSpan timeSpan, int precision = 1,
TimeUnit maxUnit = TimeUnit.Week,
TimeUnit minUnit = TimeUnit.Second, string collectionSeparator = ", ", bool toWords = false)
{
2022-01-26 11:32:16 -05:00
return timeSpan.Humanize(precision, CurrentLocalization.Culture, maxUnit, minUnit, collectionSeparator,
toWords);
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// wrapper method for humanizee that uses current current culture
/// </summary>
2022-01-26 11:32:16 -05:00
public static string HumanizeForCurrentCulture(this DateTime input, bool utcDate = true,
DateTime? dateToCompareAgainst = null, CultureInfo culture = null)
{
return input.Humanize(utcDate, dateToCompareAgainst, CurrentLocalization.Culture);
}
public static string ToTranslatedName(this MetaType metaType)
{
return CurrentLocalization.LocalizationIndex[$"META_TYPE_{metaType.ToString().ToUpper()}_NAME"];
}
public static EFClient ToPartialClient(this Data.Models.Client.EFClient client)
{
2022-01-26 11:32:16 -05:00
return new EFClient
{
ClientId = client.ClientId,
NetworkId = client.NetworkId,
Connections = client.Connections,
TotalConnectionTime = client.TotalConnectionTime,
FirstConnection = client.FirstConnection,
LastConnection = client.LastConnection,
Masked = client.Masked,
AliasLinkId = client.AliasLinkId,
AliasLink = client.AliasLink,
Level = client.Level,
CurrentAliasId = client.CurrentAliasId,
CurrentAlias = client.CurrentAlias,
Password = client.Password,
PasswordSalt = client.PasswordSalt,
Meta = client.Meta,
ReceivedPenalties = client.ReceivedPenalties,
AdministeredPenalties = client.AdministeredPenalties,
Active = client.Active,
GameName = client.GameName
};
}
public static string ToNumericalString(this int? value)
{
return value?.ToNumericalString();
}
public static string ToNumericalString(this int value)
{
return value.ToString("#,##0", CurrentLocalization.Culture);
}
2022-01-26 11:32:16 -05:00
public static string ToNumericalString(this double value, int precision = 0)
{
2022-01-26 11:32:16 -05:00
return value.ToString(
"#,##0" + $"{(precision > 0 ? "." : "")}" + new string(Enumerable.Repeat('0', precision).ToArray()),
CurrentLocalization.Culture);
}
public static string ToNumericalString(this double? value, int precision = 0)
{
return value?.ToNumericalString(precision);
}
2021-07-08 22:12:09 -04:00
public static string[] FragmentMessageForDisplay(this string message)
{
var messages = new List<string>();
var length = 48;
if (message.Length <= length)
{
2022-01-26 11:32:16 -05:00
return new[] { message };
2021-07-08 22:12:09 -04:00
}
2022-01-26 11:32:16 -05:00
2021-07-08 22:12:09 -04:00
int i;
for (i = 0; i < message.Length - length; i += length)
messages.Add(new string(message.Skip(i).Take(length).ToArray()));
var left = message.Length - length;
if (left > 0)
{
messages.Add(new string(message.Skip(i).Take(left).ToArray()));
}
return messages.ToArray();
}
public static string FindRuleForReason(this string reason, ApplicationConfiguration appConfig, Server server)
{
// allow for penalty presets
if (appConfig.PresetPenaltyReasons?.ContainsKey(reason.ToLower()) ?? false)
{
return appConfig.PresetPenaltyReasons[reason.ToLower()];
}
2022-01-26 11:32:16 -05:00
var regex = Regex.Match(reason, @"rule(\d+)", RegexOptions.IgnoreCase);
if (!regex.Success)
{
return reason;
}
var serverConfig = appConfig.Servers?
.FirstOrDefault(configServer =>
configServer.IPAddress == server.ListenAddress && configServer.Port == server.ListenPort);
var allRules = appConfig.GlobalRules?.ToList() ?? new List<string>();
if (serverConfig?.Rules != null)
{
allRules.AddRange(serverConfig.Rules);
}
var index = int.Parse(regex.Groups[1].ToString()) - 1;
if (!allRules.Any() || index > allRules.Count - 1 || index < 0)
{
return reason;
}
return allRules[index];
}
public static string MakeAbbreviation(string gameName) => string.Join("",
gameName.Split(' ').Select(word => char.ToUpper(word.First())).ToArray());
2023-04-05 10:54:57 -04:00
public static IServiceCollection AddConfiguration<TConfigurationType>(
this IServiceCollection serviceCollection, string fileName = null, TConfigurationType defaultConfig = null)
where TConfigurationType : class
{
serviceCollection.AddSingleton(serviceProvider =>
{
var configurationHandler =
serviceProvider.GetRequiredService<IConfigurationHandlerV2<TConfigurationType>>();
var configuration =
Run(() => configurationHandler.Get(fileName ?? typeof(TConfigurationType).Name, defaultConfig))
2023-04-05 10:54:57 -04:00
.GetAwaiter().GetResult();
if (typeof(TConfigurationType).GetInterface(nameof(IBaseConfiguration)) is not null &&
defaultConfig is null && configuration is null)
{
defaultConfig =
(TConfigurationType)((IBaseConfiguration)Activator.CreateInstance<TConfigurationType>())
.Generate();
}
if (defaultConfig is not null && configuration is null)
{
Run(() => configurationHandler.Set(defaultConfig)).GetAwaiter().GetResult();
2023-04-05 10:54:57 -04:00
configuration = defaultConfig;
}
if (configuration is null)
{
throw new ConfigurationException(
$"Could not register configuration {typeof(TConfigurationType).Name}. Configuration file does not exist and no default configuration was provided.");
}
return configuration;
});
return serviceCollection;
}
2023-04-05 23:26:42 -04:00
public static void ExecuteAfterDelay(TimeSpan duration, Func<CancellationToken, Task> action, CancellationToken token = default) =>
ExecuteAfterDelay((int)duration.TotalMilliseconds, action, token);
2023-04-05 23:26:42 -04:00
public static void ExecuteAfterDelay(int delayMs, Func<CancellationToken, Task> action, CancellationToken token = default)
2023-04-05 23:26:42 -04:00
{
// ReSharper disable once MethodSupportsCancellation
#pragma warning disable CA2016
_ = Run(async () =>
#pragma warning restore CA2016
2023-04-05 23:26:42 -04:00
{
try
{
await Delay(delayMs, token);
await action(token);
2023-04-05 23:26:42 -04:00
}
catch
{
// ignored
}
});
}
public static void ExecuteAfterDelay(this Func<CancellationToken, Task> action, int delayMs,
CancellationToken token = default) => ExecuteAfterDelay(delayMs, action, token);
}
2022-01-27 22:18:35 -05:00
}