/// <summary>
/// Sets the value of all properties on this <see cref="Response{TModel}"/> that have the given attribute applied to them. If no such properties exist, no action will occur.
/// </summary>
/// <typeparam name="TAttribute">The attribute to match on the properties to set</typeparam>
/// <param name="value">The value to assign to that property</param>
public void Set <TAttribute>(object value) where TAttribute : Attribute
{
PropertyInfo[] Matching = this.Properties.Where(p => p.GetCustomAttribute <TAttribute>(false) != null).ToArray();
foreach (PropertyInfo ToSet in Matching)
{
ToSet.GetSetMethod()?.Invoke(this, new[] { value });
this.SetProperties.Add(ToSet);
}
}
/// <summary>
/// Sets the value of all properties on this <see cref="Response{TModel}"/> that have the given attribute applied to them. If no such properties exist, no action will occur.
/// </summary>
/// <typeparam name="TAttribute">The attribute to match on the properties to set</typeparam>
/// <param name="value">The string value to assign to that property</param>
/// <remarks>
/// This method will attempt to convert the string value to a supported type if the type of the matching property is not string.
/// </remarks>
public void SetString <TAttribute>(string value) where TAttribute : Attribute
{
PropertyInfo[] Matching = this.Properties.Where(p => p.GetCustomAttribute <TAttribute>(false) != null).ToArray();
foreach (PropertyInfo ToSet in Matching)
{
ToSet.GetSetMethod()?.Invoke(
this,
new[] { ParameterResolver.ParseParameter(value, ToSet.PropertyType) });
this.SetProperties.Add(ToSet);
}
}
/// <summary>
/// Sets the value of all properties on this <see cref="Response{TModel}"/> that have the <see cref="ResponseValueAttribute"/> with the given name applied to them. If no such properties exist, no action will occur.
/// </summary>
/// <param name="name">The name given to the <see cref="ResponseValueAttribute"/> on the properties to set</param>
/// <param name="value">The value to assign to that property</param>
public void Set(string name, object value)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
PropertyInfo[] Matching = this.Properties.Where(p => p.GetCustomAttribute <ResponseValueAttribute>()?.Name == name).ToArray();
foreach (PropertyInfo ToSet in Matching)
{
ToSet.GetSetMethod()?.Invoke(this, new[] { value });
this.SetProperties.Add(ToSet);
}
}
/// <summary>
/// Sets parameters from a data form in an object.
/// </summary>
/// <param name="e">IQ Event Arguments describing the request.</param>
/// <param name="EditableObject">Object whose parameters will be set.</param>
/// <param name="Form">Data Form.</param>
/// <param name="OnlySetChanged">If only changed parameters are to be set.</param>
/// <returns>Any errors encountered, or null if parameters was set properly.</returns>
public static async Task <SetEditableFormResult> SetEditableForm(IqEventArgs e, object EditableObject, DataForm Form, bool OnlySetChanged)
{
Type T = EditableObject.GetType();
string DefaultLanguageCode = GetDefaultLanguageCode(T);
List <KeyValuePair <string, string> > Errors = null;
PropertyInfo PropertyInfo;
FieldInfo FieldInfo;
Language Language = await ConcentratorServer.GetLanguage(e.Query, DefaultLanguageCode);
Namespace Namespace = null;
Namespace ConcentratorNamespace = await Language.GetNamespaceAsync(typeof(ConcentratorServer).Namespace);
LinkedList <Tuple <PropertyInfo, FieldInfo, object> > ToSet = null;
ValidationMethod ValidationMethod;
OptionAttribute OptionAttribute;
RegularExpressionAttribute RegularExpressionAttribute;
RangeAttribute RangeAttribute;
DataType DataType;
Type PropertyType;
string NamespaceStr;
string LastNamespaceStr = null;
object ValueToSet;
object ValueToSet2;
object[] Parsed;
bool ReadOnly;
bool Alpha;
bool DateOnly;
bool HasHeader;
bool HasOptions;
bool ValidOption;
bool Nullable;
if (Namespace is null)
{
Namespace = await Language.CreateNamespaceAsync(T.Namespace);
}
if (ConcentratorNamespace is null)
{
ConcentratorNamespace = await Language.CreateNamespaceAsync(typeof(ConcentratorServer).Namespace);
}
foreach (Field Field in Form.Fields)
{
PropertyInfo = T.GetRuntimeProperty(Field.Var);
FieldInfo = PropertyInfo is null?T.GetRuntimeField(Field.Var) : null;
if (PropertyInfo is null && FieldInfo is null)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(1, "Property not found."));
continue;
}
if (PropertyInfo != null && (!PropertyInfo.CanRead || !PropertyInfo.CanWrite))
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(2, "Property not editable."));
continue;
}
NamespaceStr = (PropertyInfo?.DeclaringType ?? FieldInfo.DeclaringType).Namespace;
if (Namespace is null || NamespaceStr != LastNamespaceStr)
{
Namespace = await Language.GetNamespaceAsync(NamespaceStr);
LastNamespaceStr = NamespaceStr;
}
ValidationMethod = null;
ReadOnly = Alpha = DateOnly = HasHeader = HasOptions = ValidOption = false;
foreach (Attribute Attr in (PropertyInfo?.GetCustomAttributes() ?? FieldInfo.GetCustomAttributes()))
{
if (Attr is HeaderAttribute)
{
HasHeader = true;
}
else if ((OptionAttribute = Attr as OptionAttribute) != null)
{
HasOptions = true;
if (Field.ValueString == OptionAttribute.Option.ToString())
{
ValidOption = true;
}
}
else if ((RegularExpressionAttribute = Attr as RegularExpressionAttribute) != null)
{
ValidationMethod = new RegexValidation(RegularExpressionAttribute.Pattern);
}
else if ((RangeAttribute = Attr as RangeAttribute) != null)
{
ValidationMethod = new RangeValidation(RangeAttribute.Min, RangeAttribute.Max);
}
else if (Attr is OpenAttribute)
{
ValidationMethod = new OpenValidation();
}
else if (Attr is ReadOnlyAttribute)
{
ReadOnly = true;
}
else if (Attr is AlphaChannelAttribute)
{
Alpha = true;
}
else if (Attr is DateOnlyAttribute)
{
DateOnly = true;
}
}
if (!HasHeader)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(2, "Property not editable."));
continue;
}
if (ReadOnly)
{
if (Field.ValueString != (PropertyInfo?.GetValue(EditableObject) ?? FieldInfo?.GetValue(EditableObject))?.ToString())
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(3, "Property is read-only."));
}
continue;
}
if (HasOptions && !ValidOption)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(4, "Select a valid option."));
continue;
}
PropertyType = PropertyInfo?.PropertyType ?? FieldInfo.FieldType;
ValueToSet = null;
ValueToSet2 = null;
Parsed = null;
DataType = null;
Nullable = false;
if (PropertyType.GetTypeInfo().IsGenericType)
{
Type GT = PropertyType.GetGenericTypeDefinition();
if (GT == typeof(Nullable <>))
{
Nullable = true;
PropertyType = PropertyType.GenericTypeArguments[0];
}
}
if (Nullable && string.IsNullOrEmpty(Field.ValueString))
{
ValueToSet2 = null;
}
else
{
if (PropertyType == typeof(string[]))
{
if (ValidationMethod is null)
{
ValidationMethod = new BasicValidation();
}
ValueToSet = ValueToSet2 = Parsed = Field.ValueStrings;
DataType = StringDataType.Instance;
}
else if (PropertyType.GetTypeInfo().IsEnum)
{
if (ValidationMethod is null)
{
ValidationMethod = new BasicValidation();
}
try
{
ValueToSet = ValueToSet2 = Enum.Parse(PropertyType, Field.ValueString);
}
catch (Exception)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(4, "Select a valid option."));
continue;
}
}
else if (PropertyType == typeof(bool))
{
if (ValidationMethod is null)
{
ValidationMethod = new BasicValidation();
}
if (!CommonTypes.TryParse(Field.ValueString, out bool b))
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(5, "Invalid boolean value."));
continue;
}
DataType = BooleanDataType.Instance;
ValueToSet = ValueToSet2 = b;
}
else
{
if (PropertyType == typeof(string))
{
DataType = StringDataType.Instance;
}
else if (PropertyType == typeof(sbyte))
{
DataType = ByteDataType.Instance;
}
else if (PropertyType == typeof(short))
{
DataType = ShortDataType.Instance;
}
else if (PropertyType == typeof(int))
{
DataType = IntDataType.Instance;
}
else if (PropertyType == typeof(long))
{
DataType = LongDataType.Instance;
}
else if (PropertyType == typeof(byte))
{
DataType = ShortDataType.Instance;
if (ValidationMethod is null)
{
ValidationMethod = new RangeValidation(byte.MinValue.ToString(), byte.MaxValue.ToString());
}
}
else if (PropertyType == typeof(ushort))
{
DataType = IntDataType.Instance;
if (ValidationMethod is null)
{
ValidationMethod = new RangeValidation(ushort.MinValue.ToString(), ushort.MaxValue.ToString());
}
}
else if (PropertyType == typeof(uint))
{
DataType = LongDataType.Instance;
if (ValidationMethod is null)
{
ValidationMethod = new RangeValidation(uint.MinValue.ToString(), uint.MaxValue.ToString());
}
}
else if (PropertyType == typeof(ulong))
{
DataType = IntegerDataType.Instance;
if (ValidationMethod is null)
{
ValidationMethod = new RangeValidation(ulong.MinValue.ToString(), ulong.MaxValue.ToString());
}
}
else if (PropertyType == typeof(DateTime))
{
if (DateOnly)
{
DataType = DateDataType.Instance;
}
else
{
DataType = DateTimeDataType.Instance;
}
}
else if (PropertyType == typeof(decimal))
{
DataType = DecimalDataType.Instance;
}
else if (PropertyType == typeof(double))
{
DataType = DoubleDataType.Instance;
}
else if (PropertyType == typeof(float))
{
DataType = DoubleDataType.Instance; // Use xs:double anyway
}
else if (PropertyType == typeof(TimeSpan))
{
DataType = TimeDataType.Instance;
}
else if (PropertyType == typeof(Uri))
{
DataType = AnyUriDataType.Instance;
}
else if (PropertyType == typeof(SKColor))
{
if (Alpha)
{
DataType = ColorAlphaDataType.Instance;
}
else
{
DataType = ColorDataType.Instance;
}
}
else
{
DataType = null;
}
if (ValidationMethod is null)
{
ValidationMethod = new BasicValidation();
}
try
{
if (DataType is null)
{
ValueToSet = Field.ValueString;
ValueToSet2 = Activator.CreateInstance(PropertyType, ValueToSet);
}
else
{
ValueToSet = DataType.Parse(Field.ValueString);
if (ValueToSet.GetType() == PropertyType)
{
ValueToSet2 = ValueToSet;
}
else
{
ValueToSet2 = Convert.ChangeType(ValueToSet, PropertyType);
}
}
}
catch (Exception)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(6, "Invalid value."));
continue;
}
}
if (Parsed is null)
{
Parsed = new object[] { ValueToSet }
}
;
ValidationMethod.Validate(Field, DataType, Parsed, Field.ValueStrings);
if (Field.HasError)
{
AddError(ref Errors, Field.Var, Field.Error);
continue;
}
}
if (ToSet is null)
{
ToSet = new LinkedList <Tuple <PropertyInfo, FieldInfo, object> >();
}
ToSet.AddLast(new Tuple <PropertyInfo, FieldInfo, object>(PropertyInfo, FieldInfo, ValueToSet2));
}
if (Errors is null)
{
SetEditableFormResult Result = new SetEditableFormResult()
{
Errors = null,
Tags = new List <KeyValuePair <string, object> >()
};
foreach (Tuple <PropertyInfo, FieldInfo, object> P in ToSet)
{
try
{
if (OnlySetChanged)
{
object Current = P.Item1?.GetValue(EditableObject) ?? P.Item2?.GetValue(EditableObject);
if (Current is null)
{
if (P.Item3 is null)
{
continue;
}
}
else if (P.Item3 != null && Current.Equals(P.Item3))
{
continue;
}
}
if (P.Item1 != null)
{
P.Item1.SetValue(EditableObject, P.Item3);
Result.Tags.Add(new KeyValuePair <string, object>(P.Item1.Name, P.Item3));
}
else
{
P.Item2.SetValue(EditableObject, P.Item3);
Result.Tags.Add(new KeyValuePair <string, object>(P.Item2.Name, P.Item3));
}
}
catch (Exception ex)
{
AddError(ref Errors, P.Item1?.Name ?? P.Item2.Name, ex.Message);
}
}
return(Result);
}
else
{
return(new SetEditableFormResult()
{
Errors = Errors.ToArray(),
Tags = null
});
}
}
/// <summary>
/// Sets parameters from a data form in an object.
/// </summary>
/// <param name="e">IQ Event Arguments describing the request.</param>
/// <param name="EditableObject">Object whose parameters will be set.</param>
/// <param name="Form">Data Form.</param>
/// <returns>Any errors encountered, or null if parameters was set properly.</returns>
public static async Task <KeyValuePair <string, string>[]> SetEditableForm(IqEventArgs e, object EditableObject, DataForm Form)
{
Type T = EditableObject.GetType();
string DefaultLanguageCode = GetDefaultLanguageCode(T);
List <KeyValuePair <string, string> > Errors = null;
PropertyInfo PI;
Language Language = await ConcentratorServer.GetLanguage(e.Query, DefaultLanguageCode);
Namespace Namespace = await Language.GetNamespaceAsync(T.Namespace);
Namespace ConcentratorNamespace = await Language.GetNamespaceAsync(typeof(ConcentratorServer).Namespace);
LinkedList <KeyValuePair <PropertyInfo, object> > ToSet = null;
ValidationMethod ValidationMethod;
OptionAttribute OptionAttribute;
RegularExpressionAttribute RegularExpressionAttribute;
RangeAttribute RangeAttribute;
DataType DataType;
Type PropertyType;
string Header;
object ValueToSet;
object[] Parsed;
bool ReadOnly;
bool Alpha;
bool DateOnly;
bool HasHeader;
bool HasOptions;
bool ValidOption;
if (Namespace == null)
{
Namespace = await Language.CreateNamespaceAsync(T.Namespace);
}
if (ConcentratorNamespace == null)
{
ConcentratorNamespace = await Language.CreateNamespaceAsync(typeof(ConcentratorServer).Namespace);
}
foreach (Field Field in Form.Fields)
{
PI = T.GetRuntimeProperty(Field.Var);
if (PI == null)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(1, "Property not found."));
continue;
}
if (!PI.CanRead || !PI.CanWrite)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(2, "Property not editable."));
continue;
}
Header = null;
ValidationMethod = null;
ReadOnly = Alpha = DateOnly = HasHeader = HasOptions = ValidOption = false;
foreach (Attribute Attr in PI.GetCustomAttributes())
{
if (Attr is HeaderAttribute)
{
HasHeader = true;
}
else if ((OptionAttribute = Attr as OptionAttribute) != null)
{
HasOptions = true;
if (Field.ValueString == OptionAttribute.Option.ToString())
{
ValidOption = true;
}
}
else if ((RegularExpressionAttribute = Attr as RegularExpressionAttribute) != null)
{
ValidationMethod = new RegexValidation(RegularExpressionAttribute.Pattern);
}
else if ((RangeAttribute = Attr as RangeAttribute) != null)
{
ValidationMethod = new RangeValidation(RangeAttribute.Min, RangeAttribute.Max);
}
else if (Attr is OpenAttribute)
{
ValidationMethod = new OpenValidation();
}
else if (Attr is ReadOnlyAttribute)
{
ReadOnly = true;
}
else if (Attr is AlphaChannelAttribute)
{
Alpha = true;
}
else if (Attr is DateOnlyAttribute)
{
DateOnly = true;
}
}
if (Header == null)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(2, "Property not editable."));
continue;
}
if (ReadOnly)
{
if (Field.ValueString != PI.GetValue(EditableObject).ToString())
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(3, "Property is read-only."));
}
continue;
}
if (HasOptions && !ValidOption)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(4, "Select a valid option."));
continue;
}
PropertyType = PI.PropertyType;
ValueToSet = null;
Parsed = null;
DataType = null;
if (PropertyType == typeof(string[]))
{
if (ValidationMethod == null)
{
ValidationMethod = new BasicValidation();
}
ValueToSet = Parsed = Field.ValueStrings;
DataType = StringDataType.Instance;
}
else if (PropertyType == typeof(Enum))
{
if (ValidationMethod == null)
{
ValidationMethod = new BasicValidation();
}
try
{
ValueToSet = Enum.Parse(PropertyType, Field.ValueString);
}
catch (Exception)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(4, "Select a valid option."));
continue;
}
}
else if (PropertyType == typeof(bool))
{
if (ValidationMethod == null)
{
ValidationMethod = new BasicValidation();
}
if (!CommonTypes.TryParse(Field.ValueString, out bool b))
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(5, "Invalid boolean value."));
continue;
}
DataType = BooleanDataType.Instance;
}
else
{
if (PropertyType == typeof(string))
{
DataType = StringDataType.Instance;
}
else if (PropertyType == typeof(byte))
{
DataType = ByteDataType.Instance;
}
else if (PropertyType == typeof(short))
{
DataType = ShortDataType.Instance;
}
else if (PropertyType == typeof(int))
{
DataType = IntDataType.Instance;
}
else if (PropertyType == typeof(long))
{
DataType = LongDataType.Instance;
}
else if (PropertyType == typeof(sbyte))
{
DataType = ShortDataType.Instance;
if (ValidationMethod == null)
{
ValidationMethod = new RangeValidation(sbyte.MinValue.ToString(), sbyte.MaxValue.ToString());
}
}
else if (PropertyType == typeof(ushort))
{
DataType = IntDataType.Instance;
if (ValidationMethod == null)
{
ValidationMethod = new RangeValidation(ushort.MinValue.ToString(), ushort.MaxValue.ToString());
}
}
else if (PropertyType == typeof(uint))
{
DataType = LongDataType.Instance;
if (ValidationMethod == null)
{
ValidationMethod = new RangeValidation(uint.MinValue.ToString(), uint.MaxValue.ToString());
}
}
else if (PropertyType == typeof(ulong))
{
DataType = IntegerDataType.Instance;
if (ValidationMethod == null)
{
ValidationMethod = new RangeValidation(ulong.MinValue.ToString(), ulong.MaxValue.ToString());
}
}
else if (PropertyType == typeof(DateTime))
{
if (DateOnly)
{
DataType = DateDataType.Instance;
}
else
{
DataType = DateTimeDataType.Instance;
}
}
else if (PropertyType == typeof(decimal))
{
DataType = DecimalDataType.Instance;
}
else if (PropertyType == typeof(double))
{
DataType = DoubleDataType.Instance;
}
else if (PropertyType == typeof(float))
{
DataType = DoubleDataType.Instance; // Use xs:double anyway
}
else if (PropertyType == typeof(TimeSpan))
{
DataType = TimeDataType.Instance;
}
else if (PropertyType == typeof(Uri))
{
DataType = AnyUriDataType.Instance;
}
else if (PropertyType == typeof(SKColor))
{
if (Alpha)
{
DataType = ColorAlphaDataType.Instance;
}
else
{
DataType = ColorDataType.Instance;
}
}
else
{
DataType = null;
}
if (ValidationMethod == null)
{
ValidationMethod = new BasicValidation();
}
try
{
ValueToSet = DataType.Parse(Field.ValueString);
}
catch (Exception)
{
AddError(ref Errors, Field.Var, await ConcentratorNamespace.GetStringAsync(6, "Invalid value."));
continue;
}
}
if (Parsed == null)
{
Parsed = new object[] { ValueToSet }
}
;
ValidationMethod.Validate(Field, DataType, Parsed, Field.ValueStrings);
if (Field.HasError)
{
AddError(ref Errors, Field.Var, Field.Error);
continue;
}
if (ToSet == null)
{
ToSet = new LinkedList <KeyValuePair <PropertyInfo, object> >();
}
ToSet.AddLast(new KeyValuePair <PropertyInfo, object>(PI, ValueToSet));
}
if (Errors == null)
{
foreach (KeyValuePair <PropertyInfo, object> P in ToSet)
{
try
{
P.Key.SetValue(EditableObject, P.Value);
}
catch (Exception ex)
{
AddError(ref Errors, P.Key.Name, ex.Message);
}
}
}
if (Errors == null)
{
return(null);
}
else
{
return(Errors.ToArray());
}
}
