Fixed missing type func conversion for cmdsys

Author: Splamy

TS3AudioBot/CommandSystem/CommandSystemTypes.cs

@@ -8,7 +8,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using TS3AudioBot.CommandSystem.CommandResults;
+using TSLib;
 
 namespace TS3AudioBot.CommandSystem
 {
@@ -35,6 +37,6 @@ public static class CommandSystemTypes
 			typeof(ResourceFactories.AudioResource),
 			typeof(History.AudioLogEntry),
 			typeof(Playlists.PlaylistItem),
-		});
+		}.Concat(TsTypes.All));
 	}
 }

TS3AudioBot/CommandSystem/Commands/FunctionCommand.cs

@@ -14,6 +14,7 @@
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
+using System.Reflection.Emit;
 using System.Threading.Tasks;
 using TS3AudioBot.CommandSystem.CommandResults;
 using TS3AudioBot.Dependency;
@@ -22,6 +23,7 @@
 using TS3AudioBot.Web.Api;
 using TSLib.Helper;
 using static TS3AudioBot.CommandSystem.CommandSystemTypes;
+using TryFromFn = System.Func<object?, object?>;
 
 namespace TS3AudioBot.CommandSystem.Commands
 {
@@ -158,7 +160,7 @@ public FunctionCommand(Func<string, string> command) : this(command.Method, comm
 					if (arg.Kind == ParamKind.NormalTailString && argResultP is TailString tailString)
 						parameters[p] = tailString.Tail;
 					else
-						parameters[p] = ConvertParam(argResultP, argType, filterLazy);
+						parameters[p] = ConvertParam(argResultP, argType, arg, filterLazy);
 
 					takenArguments++;
 					break;
@@ -171,7 +173,7 @@ public FunctionCommand(Func<string, string> command) : this(command.Method, comm
 					for (int i = 0; i < args.Length; i++, takenArguments++)
 					{
 						var argResultA = await arguments[takenArguments].Execute(info, Array.Empty<ICommand>());
-						var convResult = ConvertParam(argResultA, typeArr, filterLazy);
+						var convResult = ConvertParam(argResultA, typeArr, arg, filterLazy);
 						args.SetValue(convResult, i);
 					}
 
@@ -222,14 +224,63 @@ private static ParamInfo[] PrecomputeTypes(ParameterInfo[] parameterInfos)
 					kind = ParamKind.NormalArray;
 				else if (arg.IsEnum
 					|| BasicTypes.Contains(arg)
-					|| BasicTypes.Contains(UnwrapParamType(arg)))
+					|| BasicTypes.Contains(UnwrapParamType(arg))
+					|| AdvancedTypes.Contains(arg)
+					|| AdvancedTypes.Contains(UnwrapParamType(arg)))
 					kind = ParamKind.NormalParam;
 				// TODO How to distinguish between special type and dependency?
-				else if (AdvancedTypes.Contains(arg))
-					kind = ParamKind.NormalParam;
 				else
 					kind = ParamKind.Dependency;
 
+				TryFromFn? tryFrom = null;
+				if (kind == ParamKind.NormalParam || kind == ParamKind.NormalArray)
+				{
+					var finalType = arg;
+					if (kind == ParamKind.NormalArray)
+						finalType = finalType.GetElementType() ?? throw new InvalidOperationException("Not an array?");
+					finalType = UnwrapParamType(finalType);
+					var method = finalType.GetMethod("TryFrom", BindingFlags.Public | BindingFlags.Static);
+					if (method != null)
+					{
+						if (method.ReturnType == typeof(object))
+						{
+							// return directly: (object) -> object
+							tryFrom = (TryFromFn)method.CreateDelegate(typeof(TryFromFn));
+						}
+						else if (method.ReturnType.IsClass)
+						{
+							// have: [object]->class
+							// can be casted with covariance to [object]->object
+							tryFrom = (TryFromFn)method.CreateDelegate(typeof(Func<,>).MakeGenericType(typeof(object), method.ReturnType));
+						}
+						else if(method.ReturnType.IsValueType)
+						{
+							static TryFromFn? TryCreateWith(MethodInfo method, Type retType)
+							{
+								if (method.ReturnType != retType) return null;
+								try
+								{
+									var tryFromToObjectWrapper = new DynamicMethod(
+										"TryFromToObjectWrapper", typeof(object), new[] { typeof(object) }, typeof(FunctionCommand).Module);
+									var il = tryFromToObjectWrapper.GetILGenerator();
+									il.Emit(OpCodes.Ldarg_0);
+									il.Emit(OpCodes.Call, method);
+									il.Emit(OpCodes.Box, retType);
+									il.Emit(OpCodes.Ret);
+									return (TryFromFn)tryFromToObjectWrapper.CreateDelegate(typeof(TryFromFn));
+								}
+								catch { return null; }
+							}
+							// have: [object]->value
+							// box with (object)([object]->value)
+							tryFrom ??= TryCreateWith(method, method.ReturnType);
+							// have: [object]->value?
+							// box with (object)([object]->value?)
+							tryFrom ??= TryCreateWith(method, typeof(Nullable<>).MakeGenericType(method.ReturnType));
+						}
+					}
+				}
+
 				if (kind.IsNormal())
 				{
 					// If we have the last normal parameter, check if it fits the criteria
@@ -244,7 +295,8 @@ private static ParamInfo[] PrecomputeTypes(ParameterInfo[] parameterInfos)
 				precomputed[i] = new ParamInfo(
 					parameterInfo,
 					kind,
-					parameterInfo.IsOptional || parameterInfo.GetCustomAttribute<ParamArrayAttribute>() != null);
+					parameterInfo.IsOptional || parameterInfo.GetCustomAttribute<ParamArrayAttribute>() != null,
+					tryFrom);
 			}
 
 			return precomputed;
@@ -307,7 +359,7 @@ public static CommandException ThrowAtLeastNArguments(int count)
 		}
 
 		[return: NotNullIfNotNull("value")]
-		public static object? ConvertParam(object? value, Type targetType, Lazy<Algorithm.IFilter> filter)
+		public static object? ConvertParam(object? value, Type targetType, ParamInfo param, Lazy<Algorithm.IFilter> filter)
 		{
 			if (value is null)
 				return null;
@@ -322,6 +374,15 @@ public static CommandException ThrowAtLeastNArguments(int count)
 			if (targetType == valueType || targetType.IsAssignableFrom(valueType))
 				return value;
 
+			if (param.TryFrom != null)
+			{
+				var tryResult = param.TryFrom(value);
+				if (tryResult != null)
+				{
+					return tryResult;
+				}
+			}
+
 			if (targetType.IsEnum)
 			{
 				var strValue = value.ToString() ?? throw new ArgumentNullException(nameof(value));
@@ -374,19 +435,21 @@ public enum ParamKind
 	}
 
 	[DebuggerDisplay("{Kind} {Name,nq}{Optional ? \"?\" : \"\",nq} ({Type.Name,nq})")]
-	public readonly struct ParamInfo
+	public class ParamInfo
 	{
 		public ParamKind Kind { get; }
 		public bool Optional { get; }
 		public ParameterInfo Param { get; }
-		public readonly Type Type => Param.ParameterType;
-		public readonly string Name => Param.Name ?? "<no name>";
+		public TryFromFn? TryFrom { get; }
+		public Type Type => Param.ParameterType;
+		public string Name => Param.Name ?? "<no name>";
 
-		public ParamInfo(ParameterInfo param, ParamKind kind, bool optional)
+		public ParamInfo(ParameterInfo param, ParamKind kind, bool optional, TryFromFn? tryFrom)
 		{
 			Param = param;
 			Kind = kind;
 			Optional = optional;
+			TryFrom = tryFrom;
 		}
 	}
 

TS3AudioBot/MainCommands.cs

@@ -1597,14 +1597,13 @@ public static void CommandSubscribeTempChannel(IVoiceTarget targetManager, Clien
 		}
 
 		[Command("subscribe channel")]
-		public static void CommandSubscribeChannel(IVoiceTarget targetManager, ClientCall? invoker = null, params ulong[] channels_ids)
+		public static void CommandSubscribeChannel(IVoiceTarget targetManager, ClientCall? invoker = null, params ChannelId[] channels)
 		{
-			var channels = Array.ConvertAll(channels_ids, item => (ChannelId)item);
-
-			if (channels == null || channels.Length == 0)
+			if (channels.Length == 0)
 			{
-				var subChan = invoker?.ChannelId ?? ChannelId.Null;
-				targetManager.WhisperChannelSubscribe(false, subChan);
+				var subChan = invoker?.ChannelId;
+				if (subChan.HasValue)
+					targetManager.WhisperChannelSubscribe(false, subChan.Value);
 			}
 			else targetManager.WhisperChannelSubscribe(false, channels);
 		}
@@ -1705,16 +1704,18 @@ public static void CommandUnsubscribe(IVoiceTarget targetManager, ClientCall inv
 		}
 
 		[Command("unsubscribe channel")]
-		public static void CommandUnsubscribeChannel(IVoiceTarget targetManager, ClientCall? invoker = null, params ulong[] channels_ids)
+		public static void CommandUnsubscribeChannel(IVoiceTarget targetManager, ClientCall? invoker = null, params ChannelId[] channels)
 		{
-			var channels = Array.ConvertAll(channels_ids, item => (ChannelId)item);
-
-			if (channels == null || channels.Length == 0)
+			if (channels.Length == 0)
+			{
+				var subChan = invoker?.ChannelId;
+				if (subChan.HasValue)
+					targetManager.WhisperChannelUnsubscribe(false, subChan.Value);
+			}
+			else
 			{
-				var subChan = invoker?.ChannelId ?? ChannelId.Null;
-				targetManager.WhisperChannelUnsubscribe(false, subChan);
+				targetManager.WhisperChannelUnsubscribe(false, channels);
 			}
-			else targetManager.WhisperChannelUnsubscribe(false, channels);
 		}
 
 		[Command("unsubscribe temporary")]