public T Parse(string rawValue, ITypeParserOptions options)
{
var jsonSettings = new JsonSerializerSettings();
if (MyAppCfg.JsonSerializerSettings != null)
{
jsonSettings = MyAppCfg.JsonSerializerSettings;
}
var iObj = System.Activator.CreateInstance <T>();
if (iObj is IJsonDataTypeWithSetting jsonDataType)
{
var js = jsonDataType.BuildJsonSerializerSettings();
if (js != null)
{
jsonSettings = js;
}
}
if (jsonSettings.ContractResolver == null)
{
jsonSettings.ContractResolver = new PrivateSetterContractResolver();
}
return(JsonConvert.DeserializeObject <T>(rawValue, jsonSettings));
}
// FORMAT: 20:30:01,23:59:02
public RandomTimeSpan Parse(string rawValue, ITypeParserOptions options)
{
var tsRange = rawValue.Split(',');
TimeSpan start;
TimeSpan end;
if (options.InputFormat == null)
{
start = TimeSpan.Parse(tsRange[0], TypeParserSettings.DefaultCulture);
end = TimeSpan.Parse(tsRange[1], TypeParserSettings.DefaultCulture);
}
else
{
start = TimeSpan.ParseExact(tsRange[0], options.InputFormat, TypeParserSettings.DefaultCulture);
end = TimeSpan.ParseExact(tsRange[1], options.InputFormat, TypeParserSettings.DefaultCulture);
}
if (start != null && end != null)
{
if (start <= end)
{
return(new RandomTimeSpan(start, end));
}
else
{
return(new RandomTimeSpan(end, start));
}
}
else
{
throw new Exception("Invail format, START and END timespan values should not null");
}
}
public DateTime Parse(string rawValue, ITypeParserOptions options)
{
// https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings
// Short Date Pattern ("d"): MM/dd/yyyy
// Long Date Pattern ("D"): dddd, dd MMMM yyyy
// Full Date Short Time ("f"): dddd, dd MMMM yyyy HH:mm
// Full Date Long Time ("F"): dddd, dd MMMM yyyy HH:mm:ss
// General Date Short Time ("g"): MM/dd/yyyy HH:mm
// General Date Long Time ("G"): MM/dd/yyyy HH:mm:ss
// Month ("M", "m"): MMMM dd
// Round-Trip ("O", "o"): yyyy-MM-ddTHH:mm:ss.fffffffK
// RFC1123 ("R", "r"): ddd, dd MMM yyyy HH:mm:ss GMT
// Sortable ("s"): yyyy-MM-ddTHH:mm:ss
// Short Time ("t"): HH:mm
// Long Time ("T"): HH:mm:ss
// Universal Sortable ("u"): yyyy-MM-dd HH:mm:ssZ
// Universal Full ("U"): dddd, dd MMMM yyyy HH:mm:ss
// Year Month ("Y", "y"): yyyy MMMM
if (options.InputFormat == null)
{
return(DateTime.Parse(rawValue, TypeParserSettings.DefaultCulture, DateTimeStyles.None));
}
else
{
return(DateTime.ParseExact(rawValue, options.InputFormat, TypeParserSettings.DefaultCulture));
}
}
public List <Guid> Parse(string rawValue, ITypeParserOptions options)
{
var separator = options.Separator ?? ";";
var parser = new GuidParser();
return(new List <Guid>(rawValue.Split(new string[] { separator }, StringSplitOptions.None).Select(s => parser.Parse(s, options))));
}
public T Parse(string rawValue, ITypeParserOptions options) // rawValue is come from GetRawValue()
{
var jsonSettings = new JsonSerializerSettings
{
ContractResolver = new PrivateSetterContractResolver()
};
return(JsonConvert.DeserializeObject <T>(rawValue, jsonSettings));
}
public TimeSpan Parse(string rawValue, ITypeParserOptions options)
{
if (options.InputFormat == null)
{
return(TimeSpan.Parse(rawValue, TypeParserSettings.DefaultCulture));
}
else
{
return(TimeSpan.ParseExact(rawValue, options.InputFormat, TypeParserSettings.DefaultCulture));
}
}
public Guid Parse(string rawValue, ITypeParserOptions options)
{
if (options.InputFormat == null)
{
return(Guid.Parse(rawValue));
}
else
{
return(Guid.ParseExact(rawValue, options.InputFormat));
}
}
public T Parse(string rawValue, ITypeParserOptions options)
{
var isDigit = IsDigit(rawValue.Trim());
if (isDigit)
{
return((T)Enum.ToObject(typeof(T), int.Parse(rawValue)));
}
else
{
if (Enum.TryParse(rawValue, out T result))
{
return(result);
}
}
throw new AppCfgException($"Can not convert [{rawValue}] to enum");
}
// FORMAT: 20:30:01,23:59:02|20:30:01,23:59:02
public TimeToRunItem[] Parse(string rawValue, ITypeParserOptions options)
{
var result = new List <TimeToRunItem>();
var tsRange = rawValue.Split('|');
foreach (var item in tsRange)
{
var arr = item.Split(',');
TimeSpan start;
TimeSpan end;
if (options.InputFormat == null)
{
start = TimeSpan.Parse(arr[0], TypeParserSettings.DefaultCulture);
end = TimeSpan.Parse(arr[1], TypeParserSettings.DefaultCulture);
}
else
{
start = TimeSpan.ParseExact(arr[0], options.InputFormat, TypeParserSettings.DefaultCulture);
end = TimeSpan.ParseExact(arr[1], options.InputFormat, TypeParserSettings.DefaultCulture);
}
if (start != null && end != null)
{
if (start <= end)
{
result.Add(new TimeToRunItem(start, end));
}
else
{
result.Add(new TimeToRunItem(end, start));
}
}
else
{
throw new Exception("Invail format, START and END timespan values should not null");
}
}
return(result.ToArray());
}
public bool Parse(string rawValue, ITypeParserOptions options = null)
{
rawValue = rawValue.Trim().ToLower();
switch (rawValue)
{
case "1":
case "true":
case "yes":
case "y":
return(true);
case "0":
case "false":
case "no":
case "n":
return(false);
default:
return(bool.Parse(rawValue));
}
}
private static string GetRawValue(Type typeOfSetting, string tenantKey, string settingNameKey, ITypeParserOptions parserOpt)
{
switch (parserOpt.StoreType)
{
case SettingStoreType.AppSetting:
return(GetRawValueForAppSettingStore(typeOfSetting, settingNameKey));
case SettingStoreType.Custom:
return(GetRawValueForCustomStore(parserOpt.StoreType, parserOpt.StoreIdentity, tenantKey, typeOfSetting, settingNameKey));;
}
throw new Exception($"Settting store {parserOpt.StoreType} is not supported");
}
public IReadOnlyList <Guid> Parse(string rawValue, ITypeParserOptions options)
{
return(new ListGuidParser().Parse(rawValue, options));
}
public decimal Parse(string rawValue, ITypeParserOptions optionsl)
{
return(decimal.Parse(rawValue, NumberStyles.Any, TypeParserSettings.DefaultCulture));
}
public IReadOnlyList <DateTime> Parse(string rawValue, ITypeParserOptions options)
{
return(new ListDateTimeParser().Parse(rawValue, options));
}
public double Parse(string rawValue, ITypeParserOptions options)
{
return(double.Parse(rawValue, NumberStyles.Any, TypeParserSettings.DefaultCulture));
}
public IReadOnlyList <TimeSpan> Parse(string rawValue, ITypeParserOptions options)
{
return(new ListTimespanParser().Parse(rawValue, options));
}
public IReadOnlyList <bool> Parse(string rawValue, ITypeParserOptions options)
{
return(new ListBooleanParser().Parse(rawValue, options));
}
public string Parse(string rawValue, ITypeParserOptions options)
{
return(rawValue);
}
public IReadOnlyList <long> Parse(string rawValue, ITypeParserOptions options)
{
return(new ListLongParser().Parse(rawValue, options));
}
public List <string> Parse(string rawValue, ITypeParserOptions options)
{
var separator = options.Separator ?? ";";
return(rawValue.Split(new string[] { separator }, StringSplitOptions.None).ToList());
}
public SqlConnectionStringBuilder Parse(string rawValue, ITypeParserOptions options)
{
return(new SqlConnectionStringBuilder(rawValue));
}
/// <summary>
/// Load settings for a specific tenant
/// </summary>
/// <typeparam name="TSetting"></typeparam>
/// <param name="tenantKey"></param>
/// <returns></returns>
public static TSetting Get <TSetting>(string tenantKey)
{
TSetting setting = new AppCfgTypeMixer <object>().ExtendWith <TSetting>();
var props = setting.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var prop in props)
{
if (TypeParsers.Get(prop.PropertyType) == null)
{
object settingObj = null;
if (prop.PropertyType.IsInterface)
{
var myMethod = typeof(MyAppCfg)
.GetMethods()
.Where(m => m.Name == "Get")
.Select(m => new
{
Method = m,
Params = m.GetParameters(),
Args = m.GetGenericArguments()
})
.Where(x => x.Params.Length == 1 && x.Params[0].Name == "tenantKey")
.Select(x => x.Method)
.First();
MethodInfo genericMethod = myMethod.MakeGenericMethod(prop.PropertyType);
settingObj = genericMethod.Invoke(null, new[] { tenantKey });
prop.SetValue(setting, settingObj);
continue;
}
else
{
settingObj = Activator.CreateInstance(prop.PropertyType);
if (settingObj is IJsonDataType) // auto register json parser for types which inherited from IJsonDataType
{
var jsParser = Activator.CreateInstance(typeof(JsonParser <>).MakeGenericType(prop.PropertyType));
TypeParsers.Register(prop.PropertyType, jsParser);
}
}
}
if (TypeParsers.Get(prop.PropertyType) != null)
{
try
{
ITypeParserOptions parserOpt = (ITypeParserOptions)prop.GetCustomAttribute <OptionAttribute>() ?? new OptionAttribute();
ISettingStore storeOpt = (ISettingStore)prop.GetCustomAttribute <StoreOptionAttribute>() ?? new StoreOptionAttribute();
string rawValue = null;
if (parserOpt?.RawValue != null)
{
rawValue = parserOpt.RawValue;
}
else
{
var settingKey = parserOpt?.Alias ?? prop.Name;
if (typeof(ITypeParserRawBuilder <>).MakeGenericType(prop.PropertyType).IsAssignableFrom(TypeParsers.Get(prop.PropertyType).GetType()))
{
rawValue = (string)typeof(ITypeParserRawBuilder <>).MakeGenericType(prop.PropertyType).GetMethod("GetRawValue").Invoke(TypeParsers.Get(prop.PropertyType), new[] { settingKey });
}
else
{
rawValue = GetRawValue(prop.PropertyType, tenantKey, settingKey, parserOpt, storeOpt);
}
}
if (rawValue != null)
{
prop.SetValue(setting, typeof(ITypeParser <>).MakeGenericType(prop.PropertyType).GetMethod("Parse").Invoke(TypeParsers.Get(prop.PropertyType), new[] { rawValue, (object)parserOpt }), null);
}
else
{
prop.SetValue(setting, parserOpt?.DefaultValue);
}
}
catch (Exception ex)
{
var tParserType = TypeParsers.Get(prop.PropertyType) != null?TypeParsers.Get(prop.PropertyType).GetType().ToString() : "null";
throw new AppCfgException($"{ex.InnerException?.Message ?? ex.Message}\n - Setting: {typeof(TSetting)}\n - Property Name: {prop.Name}\n - Property Type: {prop.PropertyType}\n - Parser: {tParserType}", ex);
}
}
else
{
throw new AppCfgException($"There is no type parser for type [{prop.PropertyType}]. You maybe need to create a custom type parser for it");
}
}
return(setting);
}
public IReadOnlyList <decimal> Parse(string rawValue, ITypeParserOptions options)
{
return(new ListDecimalParser().Parse(rawValue, options));
}
