/// <summary>
/// add role to current task
/// </summary>
/// <param name="currentTaskId"></param>
/// <param name="validationRuleInfo"></param>
public void AddRule(int?currentTaskId, BaseValidationRuleInfoAttribute validationRuleInfo)
{
if (!currentTaskId.HasValue)
{
return;
}
int currentId = currentTaskId.GetValueOrDefault();
if (CurrentValidationRules.TryGetValue(currentId, out List <BaseValidationRuleInfoAttribute> items))
{
items.Add(validationRuleInfo);
}
else
{
items = new List <BaseValidationRuleInfoAttribute>
{
validationRuleInfo
};
CurrentValidationRules.TryAdd(currentId, items);
}
}
private static void Main(string[] args)
{
//create instace of server provider
ServerProvider serverProvider = new ServerProvider();
//register your service class
serverProvider.RegisterServerService <ExampleService>();
//customize your validation resutl to client
serverProvider.ValidationResultHandlingFunction = (validations, service, method) =>
{
StringBuilder stringBuilder = new StringBuilder();
foreach (BaseValidationRuleInfoAttribute item in validations)
{
stringBuilder.AppendLine(BaseValidationRuleInfoAttribute.GetErrorValue(item).ToString());
}
return(stringBuilder.ToString());
};
//start server with port 4521
serverProvider.Start("http://localhost:4521/any");
InitializeValidationRules(serverProvider);
//example start in your browser
//invalid login
StartProcess("http://localhost:4521/Example/Login?userName=&password="******"http://localhost:4521/Example/Login?userName=test&password=testpass");
//valid addcontact
StartProcess("http://localhost:4521/Example/AddContact?contact=" + Uri.EscapeDataString("{\"Name\":\"test\"}"));
//invalid addcontact
StartProcess("http://localhost:4521/Example/AddContact?contact={}");
Console.WriteLine("Server started!");
Console.ReadLine();
}
private IEnumerable <BaseValidationRuleInfoAttribute> GetPropertyFluentBaseValidationRuleInfoAttributes(Type type, PropertyInfo propertyInfo, object instance, object currentValue, int?currentTaskId)
{
if (propertyInfo != null)
{
if (FluentValidationRules.TryGetValue(type, out Dictionary <string, List <object> > validations))
{
if (validations.TryGetValue(propertyInfo.Name, out List <object> attributes))
{
foreach (object attribute in attributes)
{
BaseValidationRuleInfoAttribute attributeInstance = null;
if (attribute is Type attributeType)
{
try
{
attributeInstance = (BaseValidationRuleInfoAttribute)Activator.CreateInstance(attributeType);
}
catch (Exception ex)
{
throw new Exception($"I went to create instance of your attribute by type {attributeType.FullName} but it had Exception, are you made constructor for that? see the inner exception for more details", ex);
}
}
else
{
attributeInstance = (BaseValidationRuleInfoAttribute)attribute;
}
attributeInstance.PropertyInfo = propertyInfo;
attributeInstance.Object = instance;
attributeInstance.CurrentValue = currentValue;
AddRule(currentTaskId, attributeInstance);
yield return(attributeInstance);
}
}
}
}
}
private IEnumerable <BaseValidationRuleInfoAttribute> CalculateObject(object instance, List <string> properties, int?currentTaskId)
{
foreach (System.Reflection.PropertyInfo property in instance.GetType().GetListOfProperties())
{
if (properties.Contains(property.Name))
{
continue;
}
object currentValue = property.GetValue(instance, null);
foreach (BaseValidationRuleInfoAttribute validation in GetPropertyBaseValidationRuleInfoAttributes(instance.GetType(), property, instance, currentValue, currentTaskId))
{
if (validation.TaskType == ValidationRuleInfoTaskType.Error)
{
if (!BaseValidationRuleInfoAttribute.CheckIsValidate(validation))
{
validation.PropertyInfo = property;
validation.Object = instance;
validation.CurrentValue = currentValue;
yield return(validation);
}
}
else if (validation.TaskType == ValidationRuleInfoTaskType.ChangeValue)
{
if (!BaseValidationRuleInfoAttribute.CheckIsValidate(validation))
{
object changedValue = BaseValidationRuleInfoAttribute.GetChangedValue(validation);
System.Reflection.PropertyInfo findProperty = instance.GetType().GetPropertyInfo(property.Name);
findProperty.SetValue(instance, changedValue, null);
}
}
else
{
throw new NotSupportedException();
}
}
}
}
public static ValidationBuilder Add(this ValidationBuilder validationBuilder, BaseValidationRuleInfoAttribute validation1, BaseValidationRuleInfoAttribute validation2, BaseValidationRuleInfoAttribute validation3, params string[] properties)
{
foreach (string item in properties)
{
AddValidation(validationBuilder, validation1, item);
AddValidation(validationBuilder, validation2, item);
AddValidation(validationBuilder, validation3, item);
}
return(validationBuilder);
}
/// <summary>
/// calculate all validations
/// </summary>
/// <returns>return list of validation errors</returns>
public IEnumerable <BaseValidationRuleInfoAttribute> CalculateValidationsOfTask(Action <string, object> changeParameterValueAction, Action <BaseValidationRuleInfoAttribute> fillValidationParameterAction)
{
if (!Task.CurrentId.HasValue)
{
throw new Exception("cannot calculate rules without any task!");
}
int currentId = Task.CurrentId.GetValueOrDefault();
if (CurrentValidationRules.TryGetValue(currentId, out List <BaseValidationRuleInfoAttribute> validationRuleInfoAttributes))
{
foreach (BaseValidationRuleInfoAttribute validation in validationRuleInfoAttributes)
{
fillValidationParameterAction(validation);
if (validation.TaskType == ValidationRuleInfoTaskType.Error)
{
if (!BaseValidationRuleInfoAttribute.CheckIsValidate(validation))
{
yield return(validation);
}
}
else if (validation.TaskType == ValidationRuleInfoTaskType.ChangeValue)
{
if (!BaseValidationRuleInfoAttribute.CheckIsValidate(validation))
{
object changedValue = BaseValidationRuleInfoAttribute.GetChangedValue(validation);
if (validation.PropertyInfo != null)
{
System.Reflection.PropertyInfo findProperty = validation.Object.GetType().GetPropertyInfo(validation.PropertyInfo.Name);
findProperty.SetValue(validation.Object, changedValue, null);
}
else
{
changeParameterValueAction(validation.ParameterInfo.Name, changedValue);
}
}
}
else
{
throw new NotSupportedException();
}
}
}
if (CurrentDetectedObjects.TryGetValue(currentId, out ConcurrentDictionary <Type, ConcurrentDictionary <object, List <string> > > types))
{
foreach (KeyValuePair <Type, ConcurrentDictionary <object, List <string> > > tkv in types)
{
Type type = tkv.Key;
if (types.TryGetValue(type, out ConcurrentDictionary <object, List <string> > objects))
{
foreach (KeyValuePair <object, List <string> > okv in objects)
{
if (objects.TryGetValue(okv.Key, out List <string> properties))
{
foreach (BaseValidationRuleInfoAttribute item in CalculateArrays(okv.Key, properties, currentId))
{
yield return(item);
}
}
}
}
}
}
}
/// <summary>
/// add object properties as check in current task
/// </summary>
/// <param name="currentTaskId"></param>
/// <param name="type"></param>
/// <param name="instance"></param>
/// <param name="propertyName"></param>
/// <param name="propertyInfo"></param>
public void AddObjectPropertyAsChecked(int?currentTaskId, Type type, object instance, string propertyName, PropertyInfo propertyInfo, object currentValue)
{
if (!currentTaskId.HasValue || instance == null)
{
return;
}
int currentId = currentTaskId.GetValueOrDefault();
if (CurrentDetectedObjects.TryGetValue(currentId, out ConcurrentDictionary <Type, ConcurrentDictionary <object, List <string> > > types))
{
if (types.TryGetValue(type, out ConcurrentDictionary <object, List <string> > objects))
{
if (objects.TryGetValue(instance, out List <string> properties))
{
if (!properties.Contains(propertyName) && !string.IsNullOrEmpty(propertyName))
{
properties.Add(propertyName);
}
}
else
{
properties = new List <string>();
if (!string.IsNullOrEmpty(propertyName))
{
properties.Add(propertyName);
}
objects.TryAdd(instance, properties);
}
}
else
{
objects = new ConcurrentDictionary <object, List <string> >();
List <string> properties = new List <string>();
if (!string.IsNullOrEmpty(propertyName))
{
properties.Add(propertyName);
}
objects.TryAdd(instance, properties);
types.TryAdd(type, objects);
}
}
else
{
types = new ConcurrentDictionary <Type, ConcurrentDictionary <object, List <string> > >();
ConcurrentDictionary <object, List <string> > objects = new ConcurrentDictionary <object, List <string> >();
List <string> properties = new List <string>();
if (!string.IsNullOrEmpty(propertyName))
{
properties.Add(propertyName);
}
objects.TryAdd(instance, properties);
types.TryAdd(type, objects);
CurrentDetectedObjects.TryAdd(currentId, types);
}
if (propertyName != null && FluentValidationRules.TryGetValue(type, out Dictionary <string, List <object> > validations))
{
if (validations.TryGetValue(propertyName, out List <object> attributes))
{
foreach (object attribute in attributes)
{
BaseValidationRuleInfoAttribute attributeInstance = null;
if (attribute is Type attributeType)
{
try
{
attributeInstance = (BaseValidationRuleInfoAttribute)Activator.CreateInstance(attributeType);
}
catch (Exception ex)
{
throw new Exception($"I went to create instance of your attribute by type {attributeType.FullName} but it had Exception, are you made constructor for that? see the inner exception for more details", ex);
}
}
else
{
attributeInstance = (BaseValidationRuleInfoAttribute)attribute;
}
attributeInstance.PropertyInfo = propertyInfo;
attributeInstance.Object = instance;
attributeInstance.CurrentValue = currentValue;
AddRule(currentTaskId, attributeInstance);
}
}
}
}
