private void AddTypeInner(Type t)
{
if (t.GetInterface("IList") != null)
{
t = ReflectionX.ElementType(t);
}
if (TypeProperties.ContainsKey(t.AssemblyQualifiedName))
{
return;
}
var typeDict = new Dictionary <string, string>();
TypeProperties.Add(t.AssemblyQualifiedName, typeDict);
foreach (var prop in t.GetPersistedProperties())
{
if (typeDict.ContainsKey(prop.Name))
{
log.Error("Property " + prop.Name + " repeated on type " + t.FullName);
continue;
}
typeDict.Add(prop.Name, prop.PropertyType.AssemblyQualifiedName);
if (!prop.PropertyType.FullName.StartsWith("System."))
{
AddTypeInner(prop.PropertyType);
}
}
}
/// <summary>
/// Reverts part of the schema relevant to a problem to the state which when compared to its current
/// state, regenerates the problem. The inverse of ResolveProblem.
/// </summary>
/// <param name="oldSchema">the old schema which generated the problem when compared to the current schema</param>
/// <param name="problem">the problem it generated</param>
public void ApplyProblem(ContentModelSchema oldSchema, ChangeProblem problem)
{
string aqTypeName = problem.GetAssemblyQualifiedTypeName();
switch (problem.ProblemType)
{
case ChangeProblemType.DeletionNeeded:
// copy the deleted type to the new schema
TypeProperties.Add(aqTypeName, oldSchema.TypeProperties[aqTypeName]);
break;
case ChangeProblemType.PropertyDropped:
// copy the dropped property to the new schema
TypeProperties[aqTypeName].Add(problem.PropertyName, oldSchema.TypeProperties[aqTypeName][problem.PropertyName]);
break;
case ChangeProblemType.PropertyDroppedFromSummary:
Type contentType = ContentTypeHierarchy.GetContentType(problem.TypeName);
string aqSummaryTypeName = ContentTypeHierarchy.SummaryTypes[contentType].AssemblyQualifiedName;
TypeProperties[aqTypeName].Add(problem.PropertyName, oldSchema.TypeProperties[aqTypeName][problem.PropertyName]);
TypeProperties[aqSummaryTypeName].Add(problem.PropertyName, oldSchema.TypeProperties[aqSummaryTypeName][problem.PropertyName]);
break;
// Problems not requiring data modification
case ChangeProblemType.NullObjectValue:
break;
}
}
public static object GetResult(this Task task)
{
try
{
if (!task.IsCompleted)
{
task.Wait();
}
if (task is Task <object> taskObj)
{
return(taskObj.Result);
}
var taskType = task.GetType();
if (!taskType.IsGenericType || taskType.FullName.Contains("VoidTaskResult"))
{
return(null);
}
var props = TypeProperties.Get(taskType);
var fn = props.GetPublicGetter("Result");
return(fn?.Invoke(task));
}
catch (TypeAccessException)
{
return(null); //return null for void Task's
}
catch (Exception ex)
{
throw ex.UnwrapIfSingleException();
}
}
public void Can_access_ModelWithComplexTypes()
{
var idAccessor = TypeProperties <ModelWithComplexTypes> .GetAccessor("Id");
var stringListAccessor = TypeProperties <ModelWithComplexTypes> .GetAccessor("StringList");
var intListAccessor = TypeProperties <ModelWithComplexTypes> .GetAccessor("IntList");
var stringMapAccessor = TypeProperties <ModelWithComplexTypes> .GetAccessor("StringMap");
var intMapAccessor = TypeProperties <ModelWithComplexTypes> .GetAccessor("IntMap");
var childAccessor = TypeProperties <ModelWithComplexTypes> .GetAccessor("Child");
var original = ModelWithComplexTypesFactory.Instance.CreateInstance(1);
Assert.That(idAccessor.PublicGetter(original), Is.EqualTo(original.Id));
Assert.That(stringListAccessor.PublicGetter(original), Is.EqualTo(original.StringList));
Assert.That(intListAccessor.PublicGetter(original), Is.EqualTo(original.IntList));
Assert.That(stringMapAccessor.PublicGetter(original), Is.EqualTo(original.StringMap));
Assert.That(intMapAccessor.PublicGetter(original), Is.EqualTo(original.IntMap));
Assert.That(childAccessor.PublicGetter(original), Is.EqualTo(original.Child));
var to = ModelWithComplexTypesFactory.Instance.CreateInstance(2);
idAccessor.PublicSetter(original, to.Id);
stringListAccessor.PublicSetter(original, to.StringList);
intListAccessor.PublicSetter(original, to.IntList);
stringMapAccessor.PublicSetter(original, to.StringMap);
intMapAccessor.PublicSetter(original, to.IntMap);
childAccessor.PublicSetter(original, to.Child);
ModelWithComplexTypesFactory.Instance.AssertIsEqual(original, to);
}
private void SetTypeTemplateProperty(string domainID, TypeProperties propertyName, object value)
{
var template = this.GetDomainHost <ITypeTemplate>(domainID);
var authentication = this.Context.GetAuthentication(this);
template.Dispatcher.Invoke(() =>
{
if (propertyName == TypeProperties.Name)
{
template.SetTypeName(authentication, (string)value);
}
else if (propertyName == TypeProperties.IsFlag)
{
template.SetIsFlag(authentication, (bool)value);
}
else if (propertyName == TypeProperties.Comment)
{
template.SetComment(authentication, (string)value);
}
else
{
throw new NotImplementedException();
}
});
}
protected virtual TExtensibleTypeProperties DeserializeTypeProperties(
string typeName,
string json,
out Type type)
{
TExtensibleTypeProperties typeProperties;
if (this.TryGetRegisteredType(typeName, out type))
{
if (string.IsNullOrEmpty(json))
{
// No typeProperties exist to deserialize, just initialize a default instance
typeProperties = (TExtensibleTypeProperties)Activator.CreateInstance(type);
}
else
{
typeProperties = (TExtensibleTypeProperties)TypeProperties.DeserializeObject(json, type);
}
}
else
{
Dictionary <string, JToken> serviceExtraProperties =
JsonConvert.DeserializeObject <Dictionary <string, JToken> >(
json,
ConversionCommon.DefaultSerializerSettings);
typeProperties = new TGenericTypeProperties()
{
ServiceExtraProperties = serviceExtraProperties
};
type = typeof(TGenericTypeProperties);
}
return(typeProperties);
}
public void Can_access_ModelWithFieldsOfDifferentTypes()
{
var idAccessor = TypeProperties <ModelWithFieldsOfDifferentTypes> .GetAccessor("Id");
var nameAccessor = TypeProperties <ModelWithFieldsOfDifferentTypes> .GetAccessor("Name");
var longIdAccessor = TypeProperties <ModelWithFieldsOfDifferentTypes> .GetAccessor("LongId");
var guidAccessor = TypeProperties <ModelWithFieldsOfDifferentTypes> .GetAccessor("Guid");
var boolAccessor = TypeProperties <ModelWithFieldsOfDifferentTypes> .GetAccessor("Bool");
var dateTimeAccessor = TypeProperties <ModelWithFieldsOfDifferentTypes> .GetAccessor("DateTime");
var original = ModelWithFieldsOfDifferentTypesFactory.Instance.CreateInstance(1);
Assert.That(idAccessor.PublicGetter(original), Is.EqualTo(original.Id));
Assert.That(nameAccessor.PublicGetter(original), Is.EqualTo(original.Name));
Assert.That(longIdAccessor.PublicGetter(original), Is.EqualTo(original.LongId));
Assert.That(guidAccessor.PublicGetter(original), Is.EqualTo(original.Guid));
Assert.That(boolAccessor.PublicGetter(original), Is.EqualTo(original.Bool));
Assert.That(dateTimeAccessor.PublicGetter(original), Is.EqualTo(original.DateTime));
var to = ModelWithFieldsOfDifferentTypesFactory.Instance.CreateInstance(2);
idAccessor.PublicSetter(original, to.Id);
nameAccessor.PublicSetter(original, to.Name);
longIdAccessor.PublicSetter(original, to.LongId);
guidAccessor.PublicSetter(original, to.Guid);
boolAccessor.PublicSetter(original, to.Bool);
dateTimeAccessor.PublicSetter(original, to.DateTime);
ModelWithFieldsOfDifferentTypesFactory.Instance.AssertIsEqual(original, to);
}
private static void InitUserFieldDefinition(Type modelType, FieldDefinition fieldDef)
{
if (fieldDef.PropertyInfo == null)
{
fieldDef.PropertyInfo = TypeProperties.Get(modelType).GetPublicProperty(fieldDef.Name);
}
}
public ApiParameterModel(ApiParameterDescription apiParameterDescription)
{
Type = apiParameterDescription.ParameterDescriptor.ParameterType.Name;
TypeProperties = apiParameterDescription.ParameterDescriptor.ParameterType.GetProperties().Select(k => k.Name).ToList();
TypePropertiesLower = TypeProperties.Select(a => a[0].ToString().ToLower() + a.Substring(1)).ToList();
Name = apiParameterDescription.Name;
IsUriParameter = apiParameterDescription.Source == ApiParameterSource.FromUri;
IsClass = !apiParameterDescription.ParameterDescriptor.ParameterType.FullName.Contains("System");
IsArray = apiParameterDescription.ParameterDescriptor.ParameterType.IsArray;
}
internal TypeResponse(Dictionary <string, string> body, TypeProperties properties)
{
if ((body == null) || (properties == null))
{
throw new ArgumentNullException(nameof(body) + " || " + nameof(properties));
}
Body = body;
Properties = properties;
}
static IEnumerable <PropertyInfo> GetTypeProperties(Type type)
{
IEnumerable <PropertyInfo> props;
if (!TypeProperties.TryGetValue(type, out props))
{
TypeProperties[type] = props =
type.GetProperties(PropertyBinding)
.Where(p => p.GetCustomAttributes(IgnoreAttribute, true).Length < 1)
.OrderBy(p => p.Name);
}
return(props);
}
public void Can_use_getter_and_setter_on_ValueTypeProps()
{
var typeFields = TypeProperties.Get(typeof(ValueTypeProps));
var o = (object)new ValueTypeProps {
S = "foo", I = 1
};
typeFields.GetPublicSetter("S")(o, "bar");
Assert.That(typeFields.GetPublicGetter("S")(o), Is.EqualTo("bar"));
typeFields.GetPublicSetter("I")(o, 2);
Assert.That(typeFields.GetPublicGetter("I")(o), Is.EqualTo(2));
}
public static void Init()
{
// Use reflection to avoid tfm builds and binary dependency on .NET Framework v4.7.2+
sameSiteFn = TypeProperties <HttpCookie> .GetAccessor("SameSite")?.PublicSetter;
if (sameSiteFn != null)
{
var sameSiteMode = typeof(HttpCookie).Assembly.GetType("System.Web.SameSiteMode");
if (sameSiteMode != null)
{
sameSiteNone = (Enum)Enum.Parse(sameSiteMode, "None");
sameSiteStrict = (Enum)Enum.Parse(sameSiteMode, "Strict");
}
}
}
public void Can_get_result_of_Task()
{
var tcs = new TaskCompletionSource <string>();
var task = tcs.Task;
tcs.SetResult("foo");
var fn = TypeProperties.Get(task.GetType()).GetPublicGetter("Result");
var value = fn(task);
Assert.That(value, Is.EqualTo("foo"));
fn = TypeProperties.Get(task.GetType()).GetPublicGetter("Result");
value = fn(task);
Assert.That(value, Is.EqualTo("foo"));
}
public object GetValue(object instance)
{
var type = instance.GetType();
if (PropertyInfo.DeclaringType?.IsAssignableFrom(type) != true)
{
if (instance is IDictionary d)
{
return(d[Name]);
}
var accessor = TypeProperties.Get(type).GetAccessor(Name);
return(accessor?.PublicGetter(instance));
}
return(this.GetValueFn?.Invoke(instance));
}
public void Can_use_TypedProperties_accessor()
{
var runtimeType = typeof(MyType);
var typeProps = TypeProperties.Get(runtimeType); //Equivalent to:
// typeProps = TypeProperties<MyType>.Instance;
var instance = runtimeType.CreateInstance();
var propAccessor = typeProps.GetAccessor("LongProp");
propAccessor.PublicSetter(instance, 1L);
Assert.That(propAccessor.PublicGetter(instance), Is.EqualTo(1));
typeProps.GetPublicSetter("StringProp")(instance, "foo");
var value = typeProps.GetPublicGetter("StringProp")(instance);
Assert.That(value, Is.EqualTo("foo"));
}
/// <summary>
/// Determines whether the specified type has a given set of properties such as being public, sealed, etc.
/// The method asserts if one or more of the properties are not satisfied.
/// </summary>
/// <param name="type">The type to test for properties.</param>
/// <param name="typeProperties">The set of type properties to test for.</param>
/// <param name="isAssignableFrom">Verify that the type to test is assignable from this type.</param>
public void HasProperties(Type type, TypeProperties typeProperties, Type isAssignableFrom)
{
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsAbstract) > 0, type.GetTypeInfo().IsAbstract, "abstract");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsClass) > 0, type.GetTypeInfo().IsClass, "a class");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsDisposable) > 0, typeof(IDisposable).IsAssignableFrom(type), "disposable");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsEnum) > 0, type.GetTypeInfo().IsEnum, "an enum");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsGenericType) > 0, type.GetTypeInfo().IsGenericType, "a generic type");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsGenericTypeDefinition) > 0, type.GetTypeInfo().IsGenericTypeDefinition, "a generic type definition");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsInterface) > 0, type.GetTypeInfo().IsInterface, "an interface");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsNestedPrivate) > 0, type.GetTypeInfo().IsNestedPrivate, "nested private");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsNestedPublic) > 0, type.GetTypeInfo().IsNestedPublic, "nested public");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsPublic) > 0, type.GetTypeInfo().IsPublic, "public");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsSealed) > 0, type.GetTypeInfo().IsSealed, "sealed");
TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsVisible) > 0, type.GetTypeInfo().IsVisible, "visible");
if (isAssignableFrom != null)
{
TypeAssert.CheckProperty(type, true, isAssignableFrom.GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()), String.Format("assignable from {0}", isAssignableFrom.FullName));
}
}
/// <summary>
/// Updates this schema so it can no longer generate a given problem when compared to another schema.
/// </summary>
/// <param name="problem">The change problem</param>
public void ResolveProblem(ChangeProblem problem)
{
switch (problem.ProblemType)
{
case ChangeProblemType.DeletionNeeded:
// Remove the problem for which deletion was needed
TypeProperties.Remove(problem.TypeName);
break;
case ChangeProblemType.PropertyDropped:
case ChangeProblemType.PropertyDroppedFromSummary:
// Remove the property which was dropped
TypeProperties[problem.TypeName].Remove(problem.PropertyName);
break;
// Problems not requiring data modification
case ChangeProblemType.NotBinarySerializable:
case ChangeProblemType.NullObjectValue:
break;
}
}
private static object PropValue(object targetValue, Type targetType, string name)
{
var memberFn = TypeProperties.Get(targetType).GetPublicGetter(name)
?? TypeFields.Get(targetType).GetPublicGetter(name);
if (memberFn != null)
{
return(memberFn(targetValue));
}
var indexerMethod = targetType.GetInstanceMethod("get_Item");
if (indexerMethod != null)
{
var fn = indexerMethod.GetInvoker();
var ret = fn(targetValue, name);
return(ret ?? JsNull.Value);
}
throw new ArgumentException($"'{targetType.Name}' does not have a '{name}' property or field");
}
/// <summary>
/// Reverts part of the schema relevant to a problem to the state which when compared to its current
/// state, regenerates the problem. The inverse of ResolveProblem.
/// </summary>
/// <param name="oldSchema">the old schema which generated the problem when compared to the current schema</param>
/// <param name="problem">the problem it generated</param>
public void ApplyProblem(ContentModelSchema oldSchema, ChangeProblem problem)
{
switch (problem.ProblemType)
{
case ChangeProblemType.DeletionNeeded:
// copy the deleted type to the new schema
TypeProperties.Add(problem.TypeName, oldSchema.TypeProperties[problem.TypeName]);
break;
case ChangeProblemType.PropertyDropped:
case ChangeProblemType.PropertyDroppedFromSummary:
// copy the dropped property to the new schema
TypeProperties[problem.TypeName].Add(problem.PropertyName, oldSchema.TypeProperties[problem.TypeName][problem.PropertyName]);
break;
// Problems not requiring data modification
case ChangeProblemType.NotBinarySerializable:
case ChangeProblemType.NullObjectValue:
break;
}
}
private object GetTypeTemplateProperty(string domainID, TypeProperties propertyName)
{
var template = this.GetDomainHost <ITypeTemplate>(domainID);
return(template.Dispatcher.Invoke(() =>
{
if (propertyName == TypeProperties.Name)
{
return (object)template.TypeName;
}
else if (propertyName == TypeProperties.IsFlag)
{
return (object)template.IsFlag;
}
else if (propertyName == TypeProperties.Comment)
{
return (object)template.Comment;
}
throw new NotImplementedException();
}));
}
/// <summary>
/// Updates this schema so it can no longer generate a given problem when compared to another schema.
/// </summary>
/// <param name="problem">The change problem</param>
public void ResolveProblem(ChangeProblem problem)
{
string aqTypeName = problem.GetAssemblyQualifiedTypeName();
switch (problem.ProblemType)
{
case ChangeProblemType.DeletionNeeded:
// Remove the problem for which deletion was needed
TypeProperties.Remove(aqTypeName);
break;
case ChangeProblemType.PropertyDropped:
case ChangeProblemType.PropertyDroppedFromSummary:
// Remove the property which was dropped
TypeProperties[aqTypeName].Remove(problem.PropertyName);
break;
// Problems not requiring data modification
case ChangeProblemType.NullObjectValue:
break;
}
}
public void Can_cache_ValueTuple_field_accessors()
{
var typeProperties = TypeProperties.Get(typeof(RefTypeProps));
var oTuple = (object)CreateTypedTuple();
typeProperties.GetPublicSetter("S")(oTuple, "bar");
typeProperties.GetPublicSetter("I")(oTuple, 10);
typeProperties.GetPublicSetter("L")(oTuple, 20L);
typeProperties.GetPublicSetter("D")(oTuple, 4.4d);
Assert.That(typeProperties.GetPublicGetter("S")(oTuple), Is.EqualTo("bar"));
Assert.That(typeProperties.GetPublicGetter("I")(oTuple), Is.EqualTo(10));
Assert.That(typeProperties.GetPublicGetter("L")(oTuple), Is.EqualTo(20));
Assert.That(typeProperties.GetPublicGetter("D")(oTuple), Is.EqualTo(4.4));
var tuple = (RefTypeProps)oTuple;
Assert.That(tuple.S, Is.EqualTo("bar"));
Assert.That(tuple.I, Is.EqualTo(10));
Assert.That(tuple.L, Is.EqualTo(20));
Assert.That(tuple.D, Is.EqualTo(4.4));
}
private static object PropValue(object targetValue, Type targetType, string name)
{
var memberFn = TypeProperties.Get(targetType).GetPublicGetter(name)
?? TypeFields.Get(targetType).GetPublicGetter(name);
if (memberFn != null)
{
return(memberFn(targetValue));
}
var methods = targetType.GetInstanceMethods();
var indexerMethod =
methods.FirstOrDefault(x => x.Name == "get_Item" && x.GetParameters().Any(p => p.ParameterType == typeof(string))) ??
methods.FirstOrDefault(x => x.Name == "get_Item" && x.GetParameters().Any(p => p.ParameterType != typeof(string)));
if (indexerMethod != null)
{
var fn = indexerMethod.GetInvoker();
var ret = fn(targetValue, name);
return(ret);
}
throw new ArgumentException($"'{targetType.Name}' does not have a '{name}' property or field");
}
internal TypeResponse(Dictionary <string, string> body, TypeProperties properties)
{
Body = body ?? throw new ArgumentNullException(nameof(body));
Properties = properties ?? throw new ArgumentNullException(nameof(properties));
}
public async Task Any(ModifyValidationRules request)
{
var appHost = HostContext.AssertAppHost();
var feature = appHost.AssertPlugin <ValidationFeature>();
await RequestUtils.AssertAccessRoleAsync(base.Request, accessRole : feature.AccessRole, authSecret : request.AuthSecret);
var utcNow = DateTime.UtcNow;
var userName = (await base.GetSessionAsync()).GetUserAuthName();
var rules = request.SaveRules;
if (!rules.IsEmpty())
{
foreach (var rule in rules)
{
if (rule.Type == null)
{
throw new ArgumentNullException(nameof(rule.Type));
}
var existingType = appHost.Metadata.FindDtoType(rule.Type);
if (existingType == null)
{
throw new ArgumentException(@$ "{rule.Type} does not exist", nameof(rule.Type));
}
if (rule.Validator == "")
{
rule.Validator = null;
}
if (rule.Condition == "")
{
rule.Condition = null;
}
if (rule.Field == "")
{
rule.Field = null;
}
if (rule.ErrorCode == "")
{
rule.ErrorCode = null;
}
if (rule.Message == "")
{
rule.Message = null;
}
if (rule.Notes == "")
{
rule.Notes = null;
}
if (rule.Field != null && TypeProperties.Get(existingType).GetAccessor(rule.Field) == null)
{
throw new ArgumentException(@$ "{rule.Field} does not exist on {rule.Type}", nameof(rule.Field));
}
if (rule.Validator != null)
{
object validator;
try
{
validator = appHost.EvalExpression(rule.Validator);
if (validator == null)
{
throw new ArgumentException(@$ "Validator does not exist", nameof(rule.Validator));
}
}
catch (Exception e)
{
throw new ArgumentException(@$ "Invalid Validator: " + e.Message, nameof(rule.Validator));
}
var validators = (validator as List <object>) ?? TypeConstants.EmptyObjectList;
var firstValidator = validator is IPropertyValidator pv
? pv
: validator is ITypeValidator tv
? tv
: validators?.FirstOrDefault() ?? validator;
if (rule.Field != null && !(firstValidator is IPropertyValidator && validators.All(v => v is IPropertyValidator)))
{
throw new ArgumentException(@$ "{nameof(IPropertyValidator)} is expected but was {(validators?.FirstOrDefault(v => !(v is IPropertyValidator)) ?? firstValidator).GetType().Name}", nameof(rule.Validator));
}
if (rule.Field == null && !(firstValidator is ITypeValidator && validators.All(v => v is ITypeValidator)))
{
throw new ArgumentException(@$ "{nameof(ITypeValidator)} is expected but was {(validators?.FirstOrDefault(v => !(v is IPropertyValidator)) ?? firstValidator).GetType().Name}", nameof(rule.Validator));
}
if (rule.Condition != null)
{
throw new ArgumentException(@$ "Only {nameof(rule.Validator)} or {nameof(rule.Condition)} can be specified, not both", nameof(rule.Condition));
}
}
else
{
if (rule.Condition == null)
{
throw new ArgumentNullException(nameof(rule.Validator), @$ "{nameof(rule.Validator)} or {nameof(rule.Condition)} is required");
}
try
{
var ast = Validators.ParseCondition(appHost.ScriptContext, rule.Condition);
await ast.Init().ConfigAwait();
}
catch (Exception e)
{
var useEx = e is ScriptException se ? se.InnerException ?? e : e;
throw new ArgumentException(useEx.Message, nameof(rule.Condition));
}
}
if (rule.CreatedBy == null)
{
rule.CreatedBy = userName;
rule.CreatedDate = utcNow;
}
rule.ModifiedBy = userName;
rule.ModifiedDate = utcNow;
}
await ValidationSource.SaveValidationRulesAsync(rules).ConfigAwait();
}
if (!request.SuspendRuleIds.IsEmpty())
{
var suspendRules = await ValidationSource.GetValidateRulesByIdsAsync(request.SuspendRuleIds).ConfigAwait();
foreach (var suspendRule in suspendRules)
{
suspendRule.SuspendedBy = userName;
suspendRule.SuspendedDate = utcNow;
}
await ValidationSource.SaveValidationRulesAsync(suspendRules).ConfigAwait();
}
if (!request.UnsuspendRuleIds.IsEmpty())
{
var unsuspendRules = await ValidationSource.GetValidateRulesByIdsAsync(request.UnsuspendRuleIds).ConfigAwait();
foreach (var unsuspendRule in unsuspendRules)
{
unsuspendRule.SuspendedBy = null;
unsuspendRule.SuspendedDate = null;
}
await ValidationSource.SaveValidationRulesAsync(unsuspendRules).ConfigAwait();
}
if (!request.DeleteRuleIds.IsEmpty())
{
await ValidationSource.DeleteValidationRulesAsync(request.DeleteRuleIds.ToArray()).ConfigAwait();
}
if (request.ClearCache.GetValueOrDefault())
{
await ValidationSource.ClearCacheAsync().ConfigAwait();
}
}
internal static IDbCommand SetParameters(this IDbCommand dbCmd, Type type, object anonType, bool excludeDefaults, ref string sql)
{
if (anonType == null)
{
return(dbCmd);
}
dbCmd.Parameters.Clear();
var modelDef = type.GetModelDefinition();
var dialectProvider = dbCmd.GetDialectProvider();
var fieldMap = type.IsUserType() //Ensure T != Scalar<int>()
? dialectProvider.GetFieldDefinitionMap(modelDef)
: null;
var sqlCopy = sql; //C# doesn't allow changing ref params in lambda's
Dictionary <string, PropertyAccessor> anonTypeProps = null;
var paramIndex = 0;
anonType.ToObjectDictionary().ForEachParam(modelDef, excludeDefaults, (propName, columnName, value) =>
{
var propType = value?.GetType() ?? ((anonTypeProps ??= TypeProperties.Get(anonType.GetType()).PropertyMap)
.TryGetValue(propName, out var pType)
? pType.PropertyInfo.PropertyType
: typeof(object));
var inValues = GetMultiValues(value);
if (inValues != null)
{
var sb = StringBuilderCache.Allocate();
foreach (var item in inValues)
{
var p = dbCmd.CreateParameter();
p.ParameterName = "v" + paramIndex++;
if (sb.Length > 0)
{
sb.Append(',');
}
sb.Append(dialectProvider.ParamString + p.ParameterName);
p.Direction = ParameterDirection.Input;
dialectProvider.InitDbParam(p, item.GetType());
dialectProvider.SetParamValue(p, item, item.GetType());
dbCmd.Parameters.Add(p);
}
var sqlIn = StringBuilderCache.ReturnAndFree(sb);
if (string.IsNullOrEmpty(sqlIn))
{
sqlIn = "NULL";
}
sqlCopy = sqlCopy?.Replace(dialectProvider.ParamString + propName, sqlIn);
if (dialectProvider.ParamString != "@")
{
sqlCopy = sqlCopy?.Replace("@" + propName, sqlIn);
}
}
else
{
var p = dbCmd.CreateParameter();
p.ParameterName = propName;
p.Direction = ParameterDirection.Input;
dialectProvider.InitDbParam(p, propType);
FieldDefinition fieldDef = null;
fieldMap?.TryGetValue(columnName, out fieldDef);
dialectProvider.SetParamValue(p, value, propType, fieldDef);
dbCmd.Parameters.Add(p);
}
});
/// <summary>
/// Determines whether the specified type has a given set of properties such as being public, sealed, etc.
/// The method asserts if one or more of the properties are not satisfied.
/// </summary>
/// <typeparam name="T">The type to test for properties.</typeparam>
/// <param name="typeProperties">The set of type properties to test for.</param>
public void HasProperties <T>(TypeProperties typeProperties)
{
HasProperties(typeof(T), typeProperties);
}
/// <summary>
/// Determines whether the specified type has a given set of properties such as being public, sealed, etc.
/// The method asserts if one or more of the properties are not satisfied.
/// </summary>
/// <param name="type">The type to test for properties.</param>
/// <param name="typeProperties">The set of type properties to test for.</param>
public void HasProperties(Type type, TypeProperties typeProperties)
{
HasProperties(type, typeProperties, null);
}
/// <summary>
/// Determines whether the specified type has a given set of properties such as being public, sealed, etc.
/// The method asserts if one or more of the properties are not satisfied.
/// </summary>
/// <typeparam name="T">The type to test for properties.</typeparam>
/// <typeparam name="TIsAssignableFrom">Verify that the type to test is assignable from this type.</typeparam>
/// <param name="typeProperties">The set of type properties to test for.</param>
public void HasProperties <T, TIsAssignableFrom>(TypeProperties typeProperties)
{
HasProperties(typeof(T), typeProperties, typeof(TIsAssignableFrom));
}