390 lines
13 KiB
C#
390 lines
13 KiB
C#
namespace Bts.SharedStreams.StreamFactories;
|
|
|
|
using BCG;
|
|
|
|
using bts.api;
|
|
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
using Spark.Core;
|
|
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
class StreamFactoryArgStore {
|
|
readonly IEnumerable<(string? Name, int? Index, object? Value)> args;
|
|
readonly ILogger? logger;
|
|
readonly string streamType;
|
|
|
|
public StreamFactoryArgStore(IEnumerable<(string? Name, int? Index, object? Value)> args, string? streamType = null, ILogger? logger = null) {
|
|
this.args = args;
|
|
this.streamType = streamType ?? "anonStream";
|
|
this.logger = logger;
|
|
}
|
|
|
|
public static bool TryGetParams<T>(
|
|
IEnumerable<(string? Name, int? Index, object? Value)> args,
|
|
[MaybeNull][NotNullWhen(true)] out T result,
|
|
[NotNullWhen(false)] out string? errorMessage
|
|
) =>
|
|
new StreamFactoryArgStore(args).TryGetParams(out result, out errorMessage);
|
|
|
|
public bool TryGetParams<T>([MaybeNull][NotNullWhen(true)] out T result, [NotNullWhen(false)] out string? errorMessage) {
|
|
var props = typeof(T).GetProperties();
|
|
var res = Activator.CreateInstance<T>();
|
|
if (res is null) {
|
|
errorMessage = $"Failed to instantiate {typeof(T)}";
|
|
result = default;
|
|
return false;
|
|
}
|
|
foreach (var p in props) {
|
|
var att = p.GetCustomAttribute<StreamArgumentAttribute>();
|
|
IEnumerable<string> names = att?.Names ?? new[] { p.Name };
|
|
if (att?.AllowCommaSeparatedAliases ?? false) {
|
|
names = names.SelectMany(n => n.Split(','));
|
|
}
|
|
IEnumerable<string> regexNames = att?.RegexNames ?? Enumerable.Empty<string>();
|
|
if (TryGet(names, out var val) || TryGetRegex(regexNames, out val)) {
|
|
SetValue(val);
|
|
} else if (att is not null && att.Position >= 0 && args.Skip(att.Position).TryGetFirst(out var arg)) {
|
|
SetValue(arg.Value);
|
|
} else if (att?.IsRequired ?? false) {
|
|
errorMessage = $"Missing required param '{p.Name}'";
|
|
result = default;
|
|
return false;
|
|
}
|
|
|
|
void SetValue(object? val) {
|
|
var pType = p.PropertyType;
|
|
bool isNullable = pType.IsNullable();
|
|
if (isNullable) {
|
|
pType = pType.GetGenericArguments().Single();
|
|
}
|
|
if (pType == typeof(DateTime)) {
|
|
SetValueType(BlueDataUtility.GetDateTime(val));
|
|
} else if (pType == typeof(TimeSpan)) {
|
|
SetValueType(BlueDataUtility.GetTimeSpan(val));
|
|
} else if (pType == typeof(string)) {
|
|
p.SetValue(res, val as string ?? val?.ToString());
|
|
} else if (pType.IsEnum) {
|
|
p.SetValue(res, BlueDataUtility.GetEnum(pType, val));
|
|
} else if (val?.GetType() == pType || (val is null && (!pType.IsValueType || isNullable))) {
|
|
p.SetValue(res, val);
|
|
} else {
|
|
p.SetValue(res, Convert.ChangeType(val, pType));
|
|
}
|
|
|
|
void SetValueType<TProp>(TProp? pVal) where TProp : struct {
|
|
if (isNullable) {
|
|
p.SetValue(res, pVal);
|
|
} else {
|
|
p.SetValue(res, pVal.assert_value());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
errorMessage = null;
|
|
result = res;
|
|
return true;
|
|
}
|
|
|
|
public Venue GetVenue(bool required = true) {
|
|
var rv = GetVenue(new[] { "venue", "exchange", "exch" });
|
|
if (required && logger is not null && rv == Venue.Unset) {
|
|
logger.LogMissingParam(streamType, "venue");
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
public Venue GetVenue(string[] preferredNames) {
|
|
return preferredNames
|
|
.Select(n => Get(n))
|
|
.Concat(args.Select(a => a.Value))
|
|
.Select(ConvertObj)
|
|
.SelectWhereValues()
|
|
.FirstOrDefault(Venue.Unset);
|
|
|
|
static Venue? ConvertObj(object? obj) {
|
|
if (obj is Venue res) {
|
|
return res;
|
|
}
|
|
var str = obj as string ?? obj?.ToString();
|
|
if (tryParseVenue(str, out res)) {
|
|
return res;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public string? GetVenueString(bool required = true) =>
|
|
GetVenueString(required, "venue", "exchange", "exch");
|
|
|
|
public bool GetVenueString([NotNullWhen(true)] out string? venue, bool required = true) {
|
|
venue = GetVenueString(required, "venue", "exchange", "exch");
|
|
return venue is not null;
|
|
}
|
|
|
|
public string? GetVenueString(bool required, params string[] preferredNames) {
|
|
var obj = Get(preferredNames);
|
|
var str = obj as string ?? obj?.ToString();
|
|
str = str?.ToUpper()?.Replace("VENUE_", "");
|
|
if (required && logger is not null && string.IsNullOrEmpty(str)) {
|
|
logger.LogMissingParam(streamType, "venue");
|
|
}
|
|
return str;
|
|
}
|
|
|
|
public SecurityType GetSecurityType() =>
|
|
GetSecurityType(new[] { "secType", "securityType", "type" });
|
|
|
|
public SecurityType GetSecurityType(params string[] preferredNames) {
|
|
return preferredNames
|
|
.Select(n => Get(n))
|
|
.Concat(args.Select(a => a.Value))
|
|
.Select(ConvertObj)
|
|
.SelectWhereValues()
|
|
.FirstOrDefault(SecurityType.Unset);
|
|
|
|
static SecurityType? ConvertObj(object? obj) {
|
|
if (obj is SecurityType res) {
|
|
return res;
|
|
}
|
|
var str = obj as string ?? obj?.ToString();
|
|
if (tryParseSecurityType(str, out res)) {
|
|
return res;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public bool GetSymbol([NotNullWhen(true)] out string? symbol, bool required = true) {
|
|
symbol = GetSymbol(required);
|
|
return symbol is not null;
|
|
}
|
|
|
|
public string? GetSymbol(bool required = true) {
|
|
var rv = Get("symbol", "product", "productCode", "asset")?.ToString();
|
|
if (required && logger is not null && string.IsNullOrEmpty(rv)) {
|
|
logger.LogMissingParam(streamType, "symbol");
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
public bool GetInt32(string name, [NotNullWhen(true)] out int? result) =>
|
|
GetInt32(out result, true, name);
|
|
|
|
public bool GetInt32([NotNullWhen(true)] out int? result, bool required, params string[] names) {
|
|
result = GetInt32(names);
|
|
return result.HasValue;
|
|
}
|
|
|
|
public int? GetInt32(params string[] names) =>
|
|
GetInt32(true, names);
|
|
|
|
public int? GetInt32(bool required, params string[] names) {
|
|
if (names.Length == 0) {
|
|
return null;
|
|
}
|
|
var obj = Get(names);
|
|
if (obj is int i) {
|
|
return i;
|
|
}
|
|
var s = obj as string ?? obj?.ToString();
|
|
if (int.TryParse(s, out i)) {
|
|
return i;
|
|
}
|
|
if (required && logger is not null) {
|
|
logger.LogMissingParam(streamType, names[0]);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public bool GetTimeSpan(string name, out TimeSpan? result) {
|
|
result = GetTimeSpan(true, new[] { name });
|
|
return result.HasValue;
|
|
}
|
|
|
|
public TimeSpan? GetTimeSpan(string name) =>
|
|
GetTimeSpan(true, new[] { name });
|
|
|
|
public TimeSpan? GetTimeSpan(bool required, string[] preferredNames) =>
|
|
preferredNames
|
|
.Select(n => BlueDataUtility.GetTimeSpan(Get(n)))
|
|
.Where(ts => ts.HasValue)
|
|
.FirstOrDefault();
|
|
|
|
public IEnumerable<string> GetStrings() =>
|
|
args.Select(a => a.Value).OfType<string>();
|
|
|
|
// First, parses the args associated with preferredNames and returns the first successful
|
|
// parse result. If none were successful, tries to parse every arg.
|
|
public T? GetEnum<T>(params string[] preferredNames) where T : struct {
|
|
var candidateObjs = preferredNames.Select(n => Get(n)).Concat(args.Select(a => a.Value));
|
|
foreach (var obj in candidateObjs) {
|
|
if (obj is T res) {
|
|
return res;
|
|
}
|
|
if (obj is string s && Enum.TryParse(s, true, out res)) {
|
|
return res;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public IEnumerable<DateTime> GetDateTimes() =>
|
|
args.Select(a => convertToDateTime(a.Value)).SelectWhereValues();
|
|
|
|
public bool GetDateTime(string name, [NotNullWhen(true)] out DateTime? result) {
|
|
result = GetDateTime(true, name);
|
|
return result.HasValue;
|
|
}
|
|
|
|
public bool GetDateTime([NotNullWhen(true)] out DateTime? result, params string[] names) {
|
|
result = GetDateTime(names);
|
|
return result.HasValue;
|
|
}
|
|
|
|
public DateTime? GetDateTime(params string[] names) =>
|
|
GetDateTime(true, names);
|
|
|
|
public DateTime? GetDateTime(bool required, params string[] names) =>
|
|
names.Select(n => Get(n)).Select(convertToDateTime).Where(dt => dt.HasValue).FirstOrDefault();
|
|
|
|
public object? Get(params string[] names) =>
|
|
Get(true, names);
|
|
|
|
public object? Get(bool required, params string[] names) {
|
|
if (names.Length == 0) {
|
|
return null;
|
|
}
|
|
if (!TryGet(names, out var result) && required && logger is not null) {
|
|
logger.LogMissingParam(streamType, names[0]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public bool TryGet(string name, out object? result) =>
|
|
TryGet(new[] { name }, out result);
|
|
|
|
public bool TryGetRegex(string name, out object? result) =>
|
|
TryGet(new[] { name }, out result, checkDefaultMatch: false, checkRegexMatch: true);
|
|
|
|
public bool TryGetRegex(IEnumerable<string> names, out object? result) =>
|
|
TryGet(names, out result, checkDefaultMatch: false, checkRegexMatch: true);
|
|
|
|
public bool TryGet(IEnumerable<string> names, out object? result, bool checkDefaultMatch = true, bool checkRegexMatch = false) {
|
|
if (checkDefaultMatch) {
|
|
foreach (var name in names.SelectMany(Variants)) {
|
|
if (args.TryGetFirst(a => a.Name == name, out var a)) {
|
|
result = a.Value;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (checkRegexMatch) {
|
|
foreach (var name in names) {
|
|
if (args.TryGetFirst(a => Regex.IsMatch(a.Name ?? string.Empty, name), out var a)) {
|
|
result = a.Value;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
result = null;
|
|
return false;
|
|
|
|
IEnumerable<string> Variants(string s) {
|
|
if (string.IsNullOrEmpty(s)) {
|
|
yield break;
|
|
}
|
|
yield return s;
|
|
// Convert to snake_case
|
|
var bd = new StringBuilder(char.ToLower(s[0]));
|
|
for (int i = 1; i < s.Length; i++) {
|
|
if (i > 1 && char.IsUpper(s[i]) && char.IsLower(s[i - 1])) {
|
|
bd.Append('_');
|
|
}
|
|
bd.Append(char.ToLower(s[i]));
|
|
}
|
|
yield return bd.ToString();
|
|
// Convert to camelCase
|
|
bd.Clear();
|
|
for (int i = 0; i < s.Length; i++) {
|
|
int numUnderscores = 0;
|
|
while (s[i + numUnderscores] == '_' & (i + numUnderscores < s.Length)) {
|
|
numUnderscores++;
|
|
}
|
|
if (numUnderscores > 0) {
|
|
i += numUnderscores;
|
|
if (i >= s.Length) {
|
|
break;
|
|
}
|
|
bd.Append(char.ToUpper(s[i]));
|
|
} else {
|
|
bd.Append(s[i]);
|
|
}
|
|
}
|
|
yield return bd.ToString();
|
|
}
|
|
}
|
|
|
|
static bool tryParseVenue(string? str, out Venue v) {
|
|
if (str is null) {
|
|
v = Venue.Unset;
|
|
return false;
|
|
}
|
|
if (Enum.TryParse(str, true, out v) || Enum.TryParse("VENUE_" + str, true, out v)) {
|
|
return true;
|
|
}
|
|
v = str.ToUpper() switch {
|
|
"CME" or "XCME" or "CEC" or "XCEC" => Venue.Glbx,
|
|
"CBOT" or "CBT" or "XCBT" => Venue.Cboe,
|
|
_ => Venue.Unset,
|
|
};
|
|
return v != Venue.Unset;
|
|
}
|
|
|
|
static bool tryParseSecurityType(string? str, out SecurityType t) {
|
|
if (str is null) {
|
|
// bbo(symbol: "ZN", venue: "GLBX", begin: "2024-10-03T18:00:00-00:05", end: "2024-10-03T19:00:00-00:05", interval: "PT1S")
|
|
t = SecurityType.Unset;
|
|
return false;
|
|
}
|
|
return Enum.TryParse(str, true, out t) || Enum.TryParse("SECURITYTYPE_" + str, true, out t);
|
|
}
|
|
|
|
static DateTime? convertToDateTime(object? obj) =>
|
|
tryConvert(obj, out DateTime dt) ? dt : null;
|
|
|
|
static bool tryConvert(object? obj, out DateTime res) {
|
|
if (obj is DateTime dt) {
|
|
res = dt;
|
|
return true;
|
|
}
|
|
if (obj is string s) {
|
|
// if (OffsetDateTimePattern)
|
|
if (DateTimeOffset.TryParseExact(s, "yyyy-MM-ddTHH:mm:ssK", null, System.Globalization.DateTimeStyles.None, out var dto)) {
|
|
res = dto.ToUniversalTime().DateTime;
|
|
return true;
|
|
}
|
|
if (DateTimeOffset.TryParseExact(s, "yyyy-MM-ddTHH:mm:ss.fffffffffK", null, System.Globalization.DateTimeStyles.None, out dto)) {
|
|
res = dto.ToUniversalTime().DateTime;
|
|
return true;
|
|
}
|
|
if (DateTime.TryParse(s, null, System.Globalization.DateTimeStyles.RoundtripKind, out res)) {
|
|
return true;
|
|
}
|
|
if (DateTimeOffset.TryParse(s, out var resOff)) {
|
|
res = resOff.ToUniversalTime().DateTime;
|
|
return true;
|
|
}
|
|
return DateTime.TryParse(s, out res);
|
|
}
|
|
res = default;
|
|
return false;
|
|
}
|
|
|
|
}
|