Added command exception logs to the server console, added commands for holiday features, fixed commands with more than one argument failing with "MISSING_ARGS"

marchellcx · marchellcx · commit a24ea03ad69f · 2025-11-04T14:43:02.000+01:00
diff --git a/LabExtended/Commands/Custom/Holidays/HolidaysCommand.cs b/LabExtended/Commands/Custom/Holidays/HolidaysCommand.cs
@@ -20,7 +20,7 @@ public class HolidaysCommand : CommandBase, IServerSideCommand
         /// Sets the active status of the Hubert skybox.
         /// </summary>
         /// <param name="status">true to activate the Hubert skybox; otherwise, false.</param>
-        [CommandOverload("hubertskybox", "Sets the Hubert skybox status.")]
+        [CommandOverload("hubert skybox", "Sets the Hubert skybox status.", null)]
         public void HubertSkybox(
             [CommandParameter("Status", "The status of the skybox to set.")] bool status)
         {
@@ -34,7 +34,7 @@ public void HubertSkybox(
         /// </summary>
         /// <remarks>Use this method to create and register a Hubert Moon entity. The method outputs a
         /// confirmation message including the unique network identifier of the spawned instance.</remarks>
-        [CommandOverload("hubertmoon", "Spawns a Hubert Moon instance.")]
+        [CommandOverload("hubert moon", "Spawns a Hubert Moon instance.", null)]
         public void HubertMoon()
         {
             var instance = ExMap.SpawnHubertMoon();
diff --git a/LabExtended/Commands/Parameters/CommandParameter.cs b/LabExtended/Commands/Parameters/CommandParameter.cs
@@ -107,13 +107,19 @@ public CommandParameter(ParameterInfo parameterInfo)
 
             if (optionsAttribute.ParserType != null)
             {
-                if (!CommandParameterParserUtils.Parsers.TryGetFirst(p => p.Value.GetType() == optionsAttribute.ParserType, out var parserInstance))
+                if (CommandParameterParserUtils.TryGetParser(optionsAttribute.ParserType, out var parserInstance))
                 {
-                    ApiLog.Error("LabExtended", $"Parser &3{optionsAttribute.ParserType.FullName}&r has not been registered!");
+                    Parsers[parserInstance] = optionsAttribute.ParserProperty ?? string.Empty;
                     continue;
                 }
 
-                Parsers[parserInstance.Value] = optionsAttribute.ParserProperty ?? string.Empty;
+                if (CommandParameterParserUtils.Parsers.TryGetFirst(p => p.Value.GetType() == optionsAttribute.ParserType, out var parserPair))
+                {
+                    Parsers[parserPair.Value] = optionsAttribute.ParserProperty ?? string.Empty;
+                    continue;
+                }
+
+                ApiLog.Error("LabExtended", $"Parser &3{optionsAttribute.ParserType.FullName}&r has not been registered!");
             }
         }
     }
diff --git a/LabExtended/Commands/Parameters/CommandParameterParserUtils.cs b/LabExtended/Commands/Parameters/CommandParameterParserUtils.cs
@@ -192,27 +192,35 @@ public static string[] CompileParameters(this IEnumerable<CommandParameter> para
     /// <param name="parserResult">The parsing result of the parser.</param>
     /// <typeparam name="T">The type to parse.</typeparam>
     /// <returns>true if the parser was found, otherwise false</returns>
-    public static bool TryParse<T>(CommandContext context, string value, out CommandParameterParserResult parserResult)
+    public static bool TryParse<T>(this CommandContext context, string value, out CommandParameterParserResult parserResult)
     {
+        if (context is null)
+            throw new ArgumentNullException(nameof(context));
+
+        if (string.IsNullOrEmpty(value))
+            throw new ArgumentNullException(nameof(value));
+
         if (!TryGetParser(typeof(T), out var parser))
         {
-            parserResult = default;
-            return false;
+            parserResult = new(false, null, $"Missing parser for type '{typeof(T).Name}'", null, null);
         }
+        else
+        {
+            var token = StringToken.Instance.NewToken<StringToken>();
+            var tokens = ListPool<ICommandToken>.Shared.Rent();
 
-        var token = StringToken.Instance.NewToken<StringToken>();
-        var tokens = ListPool<ICommandToken>.Shared.Rent();
-        
-        tokens.Add(token);
+            tokens.Add(token);
 
-        token.Value = value;
+            token.Value = value;
 
-        parserResult = parser.Parse(tokens, token, 0, context, NullParameter);
-        
-        token.ReturnToken();
-        
-        ListPool<ICommandToken>.Shared.Return(tokens);
-        return true;
+            parserResult = parser.Parse(tokens, token, 0, context, NullParameter);
+
+            token.ReturnToken();
+
+            ListPool<ICommandToken>.Shared.Return(tokens);
+        }
+
+        return parserResult.Success;
     }
     
     /// <summary>
@@ -243,68 +251,42 @@ public static CommandParameterParserResult ParseParameters(CommandContext contex
                 if (index < context.Tokens.Count)
                 {
                     var parameterToken = context.Tokens[index];
-
-                    var parserFound = false;
-                    var parserResult = default(CommandParameterParserResult);
-
-                    var defaultParserResult = default(CommandParameterParserResult);
+                    var parserResult = new CommandParameterParserResult(false, null, null, null, null!);
 
                     foreach (var pair in parameter.Parsers)
                     {
                         if (!pair.Key.AcceptsToken(parameterToken))
                             continue;
 
-                        var parameterResult = pair.Key.Parse(context.Tokens, parameterToken, index, context, parameter);
-
-                        if (!parameterResult.Success)
-                        {
-                            if (pair.Key == parameter.Type.Parser)
-                                defaultParserResult = parameterResult;
-
-                            parserResult = parameterResult;
-                            continue;
-                        }
-                        else
-                        {
-                            parserFound = true;
-                            parserResult = parameterResult;
+                        parserResult = pair.Key.Parse(context.Tokens, parameterToken, index, context, parameter);
 
+                        if (parserResult.Success)
                             break;
-                        }
                     }
 
-                    if (parserFound)
+                    if (parserResult.Success)
                     {
-                        if (parserResult.Success)
-                        {
-                            string? argumentError = null;
+                        string? argumentError = null;
 
-                            foreach (var restriction in parameter.Restrictions)
+                        foreach (var restriction in parameter.Restrictions)
+                        {
+                            if (!restriction.IsValid(parserResult.Value!, context, parameter, out var error))
                             {
-                                if (!restriction.IsValid(parserResult.Value!, context, parameter, out var error))
-                                {
-                                    argumentError = error;
-                                    break;
-                                }
+                                argumentError = error;
+                                break;
                             }
+                        }
 
-                            if (argumentError != null)
-                            {
-                                parserResults.Add(new(false, null, argumentError, parameter, null!));
+                        if (argumentError != null)
+                        {
+                            parserResults.Add(new(false, null, argumentError, parameter, null!));
 
-                                index++;
-                                return;
-                            }
+                            index++;
+                            return;
                         }
-
-                        parserResults.Add(parserResult);
-                        index++;
-                    }
-                    else
-                    {
-                        parserResults.Add(defaultParserResult);
-                        index++;
                     }
+
+                    parserResults.Add(parserResult);
                 }
                 else
                 {
diff --git a/LabExtended/Commands/Runners/AsyncCommandRunner.cs b/LabExtended/Commands/Runners/AsyncCommandRunner.cs
@@ -51,7 +51,7 @@ public void Start()
         }).ContinueWithOnMain(x =>
         {
             if (x.Exception != null)
-                ApiLog.Error("Command API", x.Exception);
+                ApiLog.Error("CommandManager", x.Exception);
             
             isFinished = true;
             isInProgress = false;
diff --git a/LabExtended/Commands/Runners/ContinuableCommandRunner.cs b/LabExtended/Commands/Runners/ContinuableCommandRunner.cs
@@ -9,8 +9,6 @@
 using LabExtended.Core;
 using LabExtended.Utilities.Update;
 
-using MEC;
-
 using NorthwoodLib.Pools;
 
 using UnityEngine;
@@ -73,9 +71,9 @@ public bool ShouldContinue(CommandExecutingEventArgs args, ExPlayer sender)
         }
         catch (Exception ex)
         {
-            ApiLog.Error("Command API", ex);
+            ApiLog.Error("CommandManager", ex);
 
-            newContext.Response = new(false, false, false, null, newContext.FormatExceptionResponse(ex));
+            newContext.Response = new(false, false, false, null!, newContext.FormatExceptionResponse(ex));
         }
 
         HandleResponse(newContext);
@@ -135,7 +133,9 @@ void FinishCommand()
         }
         catch (Exception ex)
         {
-            ctx.Response = new(false, false, false, null, ctx.FormatExceptionResponse(ex));
+            ctx.Response = new(false, false, false, null!, ctx.FormatExceptionResponse(ex));
+
+            ApiLog.Error("CommandManager", ex);
         }
         
         FinishCommand();
@@ -175,7 +175,7 @@ private void HandleResponse(CommandContext ctx)
 
     private void Start()
     {
-        command.RemainingTime = command.CommandData.TimeOut ?? 0f;
+        command!.RemainingTime = command.CommandData.TimeOut ?? 0f;
 
         if (command.RemainingTime > 0f && !eventStatus)
         {
diff --git a/LabExtended/Commands/Runners/InputCommandRunner.cs b/LabExtended/Commands/Runners/InputCommandRunner.cs
@@ -56,7 +56,7 @@ public bool ShouldContinue(CommandExecutingEventArgs ev, ExPlayer sender)
         var args = ListPool<string>.Shared.Rent(ev.Arguments.Array);
         var response = inputCommandRunner.context.Response;
         
-        inputCommandRunner.context.Response = null;
+        inputCommandRunner.context.Response = null!;
         
         inputCommandRunner.context.Args = args;
         inputCommandRunner.context.Line = line;
diff --git a/LabExtended/Commands/Runners/RegularCommandRunner.cs b/LabExtended/Commands/Runners/RegularCommandRunner.cs
@@ -4,6 +4,7 @@
 
 using LabExtended.Commands.Interfaces;
 using LabExtended.Commands.Utilities;
+using LabExtended.Core;
 
 namespace LabExtended.Commands.Runners;
 
@@ -81,7 +82,9 @@ void FinishCommand()
         }
         catch (Exception ex)
         {
-            ctx.Response = new(false, false, false, null, ctx.FormatExceptionResponse(ex));
+            ctx.Response = new(false, false, false, null!, ctx.FormatExceptionResponse(ex));
+
+            ApiLog.Error("CommandManager", ex);
         }
         
         FinishCommand();
diff --git a/LabExtended/Commands/Utilities/CommandResponseFormatter.cs b/LabExtended/Commands/Utilities/CommandResponseFormatter.cs
@@ -37,7 +37,7 @@ internal static bool WriteResponse(this CommandContext ctx, out ContinuableComma
         {
             if (ctx.Type is CommandType.Console or CommandType.RemoteAdmin)
             {
-                ctx.Sender.SendRemoteAdminMessage(ctx.FormatCommandResponse(), ctx.Response is { IsSuccess: true }, true, ctx.Command.Name);
+                ctx.Sender.SendRemoteAdminMessage(ctx.FormatCommandResponse(), ctx.Response is { IsSuccess: true }, true, ctx.Command.Name.ToUpperInvariant());
             }
             else
             {
@@ -51,7 +51,7 @@ internal static bool WriteResponse(this CommandContext ctx, out ContinuableComma
             }
         }
 
-        continuableCommand = null;
+        continuableCommand = null!;
         return false;
     }
 
@@ -74,7 +74,7 @@ internal static string FormatCommandResponse(this CommandContext ctx)
             if (ctx.Type is CommandType.Client)
             {
                 x.Append("[");
-                x.Append(ctx.Command.Name);
+                x.Append(ctx.Command.Name.ToUpperInvariant());
                 x.Append("] ");
             }
 
@@ -89,7 +89,7 @@ internal static string FormatExceptionResponse(this CommandContext ctx, Exceptio
             if (ctx.Type is CommandType.Client)
             {
                 x.Append("[");
-                x.Append(ctx.Command.Name);
+                x.Append(ctx.Command.Name.ToUpperInvariant());
                 x.Append("] ");
             }
 
@@ -105,7 +105,7 @@ internal static string FormatMissingPermissionsFailure(string requiredPermission
             if (type is CommandType.Console)
             {
                 x.Append("[");
-                x.Append(commandName);
+                x.Append(commandName.ToUpperInvariant());
                 x.Append("] ");
             }
 
@@ -131,7 +131,7 @@ internal static string FormatMissingArgumentsFailure(this CommandContext ctx)
             if (ctx.Type is CommandType.Client)
             {
                 x.Append("[");
-                x.Append(ctx.Command.Name);
+                x.Append(ctx.Command.Name.ToUpperInvariant());
                 x.Append("] ");
             }
 
@@ -174,7 +174,7 @@ internal static string FormatInvalidArgumentsFailure(this CommandContext ctx, Li
             if (ctx.Type is CommandType.Client)
             {
                 x.Append("[");
-                x.Append(ctx.Command.Name);
+                x.Append(ctx.Command.Name.ToUpperInvariant());
                 x.Append("] ");
             }
 
@@ -225,7 +225,7 @@ internal static string FormatTokenParserFailure(this CommandContext ctx)
             if (ctx.Type is CommandType.Client)
             {
                 x.Append("[");
-                x.Append(ctx.Command.Name);
+                x.Append(ctx.Command.Name.ToUpperInvariant());
                 x.Append("] ");
             }
 

Original file line number	Diff line number	Diff line change
`@@ -107,13 +107,19 @@ public CommandParameter(ParameterInfo parameterInfo)`
`107`	`107`
`108`	`108`	`if (optionsAttribute.ParserType != null)`
`109`	`109`	`{`
`110`		`- if (!CommandParameterParserUtils.Parsers.TryGetFirst(p => p.Value.GetType() == optionsAttribute.ParserType, out var parserInstance))`
	`110`	`+ if (CommandParameterParserUtils.TryGetParser(optionsAttribute.ParserType, out var parserInstance))`
`111`	`111`	`{`
`112`		`- ApiLog.Error("LabExtended", $"Parser &3{optionsAttribute.ParserType.FullName}&r has not been registered!");`
	`112`	`+ Parsers[parserInstance] = optionsAttribute.ParserProperty ?? string.Empty;`
`113`	`113`	`continue;`
`114`	`114`	`}`
`115`	`115`
`116`		`- Parsers[parserInstance.Value] = optionsAttribute.ParserProperty ?? string.Empty;`
	`116`	`+ if (CommandParameterParserUtils.Parsers.TryGetFirst(p => p.Value.GetType() == optionsAttribute.ParserType, out var parserPair))`
	`117`	`+ {`
	`118`	`+ Parsers[parserPair.Value] = optionsAttribute.ParserProperty ?? string.Empty;`
	`119`	`+ continue;`
	`120`	`+ }`
	`121`	`+`
	`122`	`+ ApiLog.Error("LabExtended", $"Parser &3{optionsAttribute.ParserType.FullName}&r has not been registered!");`
`117`	`123`	`}`
`118`	`124`	`}`
`119`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public void Start()`
`51`	`51`	`}).ContinueWithOnMain(x =>`
`52`	`52`	`{`
`53`	`53`	`if (x.Exception != null)`
`54`		`- ApiLog.Error("Command API", x.Exception);`
	`54`	`+ ApiLog.Error("CommandManager", x.Exception);`
`55`	`55`
`56`	`56`	`isFinished = true;`
`57`	`57`	`isInProgress = false;`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,6 @@`
`9`	`9`	`using LabExtended.Core;`
`10`	`10`	`using LabExtended.Utilities.Update;`
`11`	`11`
`12`		`-using MEC;`
`13`		`-`
`14`	`12`	`using NorthwoodLib.Pools;`
`15`	`13`
`16`	`14`	`using UnityEngine;`
`@@ -73,9 +71,9 @@ public bool ShouldContinue(CommandExecutingEventArgs args, ExPlayer sender)`
`73`	`71`	`}`
`74`	`72`	`catch (Exception ex)`
`75`	`73`	`{`
`76`		`- ApiLog.Error("Command API", ex);`
	`74`	`+ ApiLog.Error("CommandManager", ex);`
`77`	`75`
`78`		`- newContext.Response = new(false, false, false, null, newContext.FormatExceptionResponse(ex));`
	`76`	`+ newContext.Response = new(false, false, false, null!, newContext.FormatExceptionResponse(ex));`
`79`	`77`	`}`
`80`	`78`
`81`	`79`	`HandleResponse(newContext);`
`@@ -135,7 +133,9 @@ void FinishCommand()`
`135`	`133`	`}`
`136`	`134`	`catch (Exception ex)`
`137`	`135`	`{`
`138`		`- ctx.Response = new(false, false, false, null, ctx.FormatExceptionResponse(ex));`
	`136`	`+ ctx.Response = new(false, false, false, null!, ctx.FormatExceptionResponse(ex));`
	`137`	`+`
	`138`	`+ ApiLog.Error("CommandManager", ex);`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`FinishCommand();`
`@@ -175,7 +175,7 @@ private void HandleResponse(CommandContext ctx)`
`175`	`175`
`176`	`176`	`private void Start()`
`177`	`177`	`{`
`178`		`- command.RemainingTime = command.CommandData.TimeOut ?? 0f;`
	`178`	`+ command!.RemainingTime = command.CommandData.TimeOut ?? 0f;`
`179`	`179`
`180`	`180`	`if (command.RemainingTime > 0f && !eventStatus)`
`181`	`181`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`
`5`	`5`	`using LabExtended.Commands.Interfaces;`
`6`	`6`	`using LabExtended.Commands.Utilities;`
	`7`	`+using LabExtended.Core;`
`7`	`8`
`8`	`9`	`namespace LabExtended.Commands.Runners;`
`9`	`10`
`@@ -81,7 +82,9 @@ void FinishCommand()`
`81`	`82`	`}`
`82`	`83`	`catch (Exception ex)`
`83`	`84`	`{`
`84`		`- ctx.Response = new(false, false, false, null, ctx.FormatExceptionResponse(ex));`
	`85`	`+ ctx.Response = new(false, false, false, null!, ctx.FormatExceptionResponse(ex));`
	`86`	`+`
	`87`	`+ ApiLog.Error("CommandManager", ex);`
`85`	`88`	`}`
`86`	`89`
`87`	`90`	`FinishCommand();`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ internal static bool WriteResponse(this CommandContext ctx, out ContinuableComma`
`37`	`37`	`{`
`38`	`38`	`if (ctx.Type is CommandType.Console or CommandType.RemoteAdmin)`
`39`	`39`	`{`
`40`		`- ctx.Sender.SendRemoteAdminMessage(ctx.FormatCommandResponse(), ctx.Response is { IsSuccess: true }, true, ctx.Command.Name);`
	`40`	`+ ctx.Sender.SendRemoteAdminMessage(ctx.FormatCommandResponse(), ctx.Response is { IsSuccess: true }, true, ctx.Command.Name.ToUpperInvariant());`
`41`	`41`	`}`
`42`	`42`	`else`
`43`	`43`	`{`
`@@ -51,7 +51,7 @@ internal static bool WriteResponse(this CommandContext ctx, out ContinuableComma`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`		`- continuableCommand = null;`
	`54`	`+ continuableCommand = null!;`
`55`	`55`	`return false;`
`56`	`56`	`}`
`57`	`57`
`@@ -74,7 +74,7 @@ internal static string FormatCommandResponse(this CommandContext ctx)`
`74`	`74`	`if (ctx.Type is CommandType.Client)`
`75`	`75`	`{`
`76`	`76`	`x.Append("[");`
`77`		`- x.Append(ctx.Command.Name);`
	`77`	`+ x.Append(ctx.Command.Name.ToUpperInvariant());`
`78`	`78`	`x.Append("] ");`
`79`	`79`	`}`
`80`	`80`
`@@ -89,7 +89,7 @@ internal static string FormatExceptionResponse(this CommandContext ctx, Exceptio`
`89`	`89`	`if (ctx.Type is CommandType.Client)`
`90`	`90`	`{`
`91`	`91`	`x.Append("[");`
`92`		`- x.Append(ctx.Command.Name);`
	`92`	`+ x.Append(ctx.Command.Name.ToUpperInvariant());`
`93`	`93`	`x.Append("] ");`
`94`	`94`	`}`
`95`	`95`
`@@ -105,7 +105,7 @@ internal static string FormatMissingPermissionsFailure(string requiredPermission`
`105`	`105`	`if (type is CommandType.Console)`
`106`	`106`	`{`
`107`	`107`	`x.Append("[");`
`108`		`- x.Append(commandName);`
	`108`	`+ x.Append(commandName.ToUpperInvariant());`
`109`	`109`	`x.Append("] ");`
`110`	`110`	`}`
`111`	`111`
`@@ -131,7 +131,7 @@ internal static string FormatMissingArgumentsFailure(this CommandContext ctx)`
`131`	`131`	`if (ctx.Type is CommandType.Client)`
`132`	`132`	`{`
`133`	`133`	`x.Append("[");`
`134`		`- x.Append(ctx.Command.Name);`
	`134`	`+ x.Append(ctx.Command.Name.ToUpperInvariant());`
`135`	`135`	`x.Append("] ");`
`136`	`136`	`}`
`137`	`137`
`@@ -174,7 +174,7 @@ internal static string FormatInvalidArgumentsFailure(this CommandContext ctx, Li`
`174`	`174`	`if (ctx.Type is CommandType.Client)`
`175`	`175`	`{`
`176`	`176`	`x.Append("[");`
`177`		`- x.Append(ctx.Command.Name);`
	`177`	`+ x.Append(ctx.Command.Name.ToUpperInvariant());`
`178`	`178`	`x.Append("] ");`
`179`	`179`	`}`
`180`	`180`
`@@ -225,7 +225,7 @@ internal static string FormatTokenParserFailure(this CommandContext ctx)`
`225`	`225`	`if (ctx.Type is CommandType.Client)`
`226`	`226`	`{`
`227`	`227`	`x.Append("[");`
`228`		`- x.Append(ctx.Command.Name);`
	`228`	`+ x.Append(ctx.Command.Name.ToUpperInvariant());`
`229`	`229`	`x.Append("] ");`
`230`	`230`	`}`
`231`	`231`