public override bool CalculateResult(IPropertyMetadata propertyMetadata, object entity)
{
var entityValue = propertyMetadata.GetValue<TimeSpan>(entity);
switch (SelectedCondition)
{
case Condition.EqualTo:
return entityValue == Value;
case Condition.NotEqualTo:
return entityValue != Value;
case Condition.GreaterThan:
return entityValue > Value;
case Condition.LessThan:
return entityValue < Value;
case Condition.GreaterThanOrEqualTo:
return entityValue >= Value;
case Condition.LessThanOrEqualTo:
return entityValue <= Value;
default:
throw new NotSupportedException(string.Format("Condition '{0}' is not supported.", SelectedCondition));
}
}
public override bool CalculateResult(IPropertyMetadata propertyMetadata, object entity)
{
bool entityValue = propertyMetadata.GetValue<bool>(entity);
switch (SelectedCondition)
{
case Condition.EqualTo:
return entityValue == Value;
default:
throw new NotSupportedException(string.Format("Condition '{0}' is not supported.", SelectedCondition));
}
}
public override bool CalculateResult(IPropertyMetadata propertyMetadata, object entity)
{
var entityValue = propertyMetadata.GetValue<string>(entity);
switch (SelectedCondition)
{
case Condition.Contains:
return entityValue != null && entityValue.IndexOf(Value, StringComparison.CurrentCultureIgnoreCase) != -1;
case Condition.EndsWith:
return entityValue != null && entityValue.EndsWith(Value, StringComparison.CurrentCultureIgnoreCase);
case Condition.EqualTo:
return entityValue == Value;
case Condition.GreaterThan:
return string.Compare(entityValue, Value, StringComparison.InvariantCultureIgnoreCase) > 0;
case Condition.GreaterThanOrEqualTo:
return string.Compare(entityValue, Value, StringComparison.InvariantCultureIgnoreCase) >= 0;
case Condition.IsEmpty:
return entityValue == string.Empty;
case Condition.IsNull:
return entityValue == null;
case Condition.LessThan:
return string.Compare(entityValue, Value, StringComparison.InvariantCultureIgnoreCase) < 0;
case Condition.LessThanOrEqualTo:
return string.Compare(entityValue, Value, StringComparison.InvariantCultureIgnoreCase) <= 0;
case Condition.NotEqualTo:
return entityValue != Value;
case Condition.NotIsEmpty:
return entityValue != string.Empty;
case Condition.NotIsNull:
return entityValue != null;
case Condition.StartsWith:
return entityValue != null && entityValue.StartsWith(Value, StringComparison.CurrentCultureIgnoreCase);
default:
throw new NotSupportedException(string.Format("Condition '{0}' is not supported.", SelectedCondition));
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public bool IsToManyRelationProperty(IPropertyMetadata property, out Type relatedContract)
{
Type elementType;
var isCollection = property.ClrType.IsCollectionType(out elementType);
if ( isCollection && IsDataObjectContract(elementType) )
{
relatedContract = elementType;
return true;
}
else
{
relatedContract = null;
return false;
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void WriteScalarPropertyConfiguration(IPropertyMetadata property, Operand<EntityTypeConfiguration<TT.TImpl>> typeConfig)
{
var m = _method;
using ( TT.CreateScope<TT.TValue>(property.ClrType) )
{
//typeConfig.Func<Expression<Func<TT.TImpl, TT.TValue>>, PrimitivePropertyConfiguration>(x => x.Property<TT.TValue>, WriteNewPropertyExpression(property).CastTo<Expression<Func<TT.TImpl, TT.TValue>>>())
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void WriteOneToManyPropertyConfiguration(IPropertyMetadata property, Operand<EntityTypeConfiguration<TT.TImpl>> typeConfig)
{
throw new NotImplementedException();
}
public override bool CalculateResult(IPropertyMetadata propertyMetadata, object entity)
{
if (IsNullable)
{
var entityValue = propertyMetadata.GetValue <TValue?>(entity);
switch (SelectedCondition)
{
case Condition.EqualTo:
return(object.Equals(entityValue, Value));
case Condition.NotEqualTo:
return(!object.Equals(entityValue, Value));
case Condition.GreaterThan:
return(entityValue != null && _comparer.Compare(entityValue.Value, Value) > 0);
case Condition.LessThan:
return(entityValue != null && _comparer.Compare(entityValue.Value, Value) < 0);
case Condition.GreaterThanOrEqualTo:
return(entityValue != null && _comparer.Compare(entityValue.Value, Value) >= 0);
case Condition.LessThanOrEqualTo:
return(entityValue != null && _comparer.Compare(entityValue.Value, Value) <= 0);
case Condition.IsNull:
return(entityValue == null);
case Condition.NotIsNull:
return(entityValue != null);
default:
throw new NotSupportedException(string.Format(LanguageHelper.GetString("FilterBuilder_Exception_Message_ConditionIsNotSupported_Pattern"), SelectedCondition));
}
}
else
{
var entityValue = propertyMetadata.GetValue <TValue>(entity);
switch (SelectedCondition)
{
case Condition.EqualTo:
return(object.Equals(entityValue, Value));
case Condition.NotEqualTo:
return(!object.Equals(entityValue, Value));
case Condition.GreaterThan:
return(_comparer.Compare(entityValue, Value) > 0);
case Condition.LessThan:
return(_comparer.Compare(entityValue, Value) < 0);
case Condition.GreaterThanOrEqualTo:
return(_comparer.Compare(entityValue, Value) >= 0);
case Condition.LessThanOrEqualTo:
return(_comparer.Compare(entityValue, Value) <= 0);
default:
throw new NotSupportedException(string.Format(LanguageHelper.GetString("FilterBuilder_Exception_Message_ConditionIsNotSupported_Pattern"), SelectedCondition));
}
}
}
/// <summary>
/// Get converter for a type.
/// </summary>
/// <param name="metadata">Property metadata.</param>
/// <returns></returns>
public static TypeConverter GetConverter(IPropertyMetadata metadata)
{
if (metadata == null)
throw new ArgumentNullException("metadata");
TypeConverter converter;
if (metadata.Type == CustomDataType.Other)
converter = GetConverter(metadata.CustomType);
else
converter = GetConverter(metadata.Type);
if (converter == null)
converter = TypeDescriptor.GetConverter(metadata.ClrType);
return converter;
}
private void WhenRequiredFieldIsNotBlankAndSubmitButtonIsClicked(IPropertyMetadata metadata)
{
this.NewTest();
var propertyId = this.GetPropertyId(metadata);
var humanFieldName = this.GetHumanFieldName(metadata);
var value = metadata.PropertyInfo.GetValue(this.ViewModel, null);
var s = this.Scenario();
s[string.Format("Given I am on the registration page")] = p => this.NavigateToRegistrationPage();
s[string.Format("And I have entered my {0}", humanFieldName)] = p => this.Page.SetElement(metadata, value);
s[string.Format("When I submit my registration")] = p => this.Page.Submit();
s[string.Format("Then I will not see required validation message for my {0}", humanFieldName)] = p => this.GetRequiredValidationMesssage(metadata).Displayed.Should().BeFalse();
s.Execute();
}
public override bool CalculateResult(IPropertyMetadata propertyMetadata, object entity)
{
var entityValue = propertyMetadata.GetValue <string>(entity);
if (entityValue is null && propertyMetadata.Type.IsEnumEx())
{
var entityValueAsObject = propertyMetadata.GetValue(entity);
if (entityValueAsObject != null)
{
entityValue = entityValueAsObject.ToString();
}
}
switch (SelectedCondition)
{
case Condition.Contains:
return(entityValue != null && entityValue.IndexOf(Value, StringComparison.CurrentCultureIgnoreCase) != -1);
case Condition.DoesNotContain:
return(entityValue != null && entityValue.IndexOf(Value, StringComparison.CurrentCultureIgnoreCase) == -1);
case Condition.EndsWith:
return(entityValue != null && entityValue.EndsWith(Value, StringComparison.CurrentCultureIgnoreCase));
case Condition.DoesNotEndWith:
return(entityValue != null && !entityValue.EndsWith(Value, StringComparison.CurrentCultureIgnoreCase));
case Condition.EqualTo:
return(entityValue == Value);
case Condition.GreaterThan:
return(string.Compare(entityValue, Value, StringComparison.OrdinalIgnoreCase) > 0);
case Condition.GreaterThanOrEqualTo:
return(string.Compare(entityValue, Value, StringComparison.OrdinalIgnoreCase) >= 0);
case Condition.IsEmpty:
return(entityValue == string.Empty);
case Condition.IsNull:
return(entityValue is null);
case Condition.LessThan:
return(string.Compare(entityValue, Value, StringComparison.OrdinalIgnoreCase) < 0);
case Condition.LessThanOrEqualTo:
return(string.Compare(entityValue, Value, StringComparison.OrdinalIgnoreCase) <= 0);
case Condition.NotEqualTo:
return(entityValue != Value);
case Condition.NotIsEmpty:
return(entityValue != string.Empty);
case Condition.NotIsNull:
return(entityValue != null);
case Condition.StartsWith:
return(entityValue != null && entityValue.StartsWith(Value, StringComparison.CurrentCultureIgnoreCase));
case Condition.DoesNotStartWith:
return(entityValue != null && !entityValue.StartsWith(Value, StringComparison.CurrentCultureIgnoreCase));
case Condition.Matches:
return(entityValue != null &&
_regexIsValidCache.GetFromCacheOrFetch(Value, () => RegexHelper.IsValid(Value)) &&
_regexCache.GetFromCacheOrFetch(Value, () => new Regex(Value, RegexOptions.Compiled)).IsMatch(entityValue));
case Condition.DoesNotMatch:
return(entityValue != null &&
_regexIsValidCache.GetFromCacheOrFetch(Value, () => RegexHelper.IsValid(Value)) &&
!_regexCache.GetFromCacheOrFetch(Value, () => new Regex(Value, RegexOptions.Compiled)).IsMatch(entityValue));
default:
throw new NotSupportedException(string.Format(LanguageHelper.GetString("FilterBuilder_Exception_Message_ConditionIsNotSupported_Pattern"), SelectedCondition));
}
}
public CustomField(IPropertyMetadata property, Type customFieldType) : base(property)
{
CustomType = customFieldType ?? throw new ArgumentNullException(nameof(customFieldType));
}
private PropertyImpl(IPropertyMetadata metadata, Item parent)
{
_metadata = metadata;
Parent = parent;
}
private PropertyImpl(IPropertyMetadata metadata, Object parent)
{
_metadata = metadata;
Parent = parent;
}
protected virtual async Task UpdateProperty(IValueProvider valueProvider, T entity, IPropertyMetadata property)
{
bool handled = false;
bool hasValue = valueProvider.ContainsKey(property.ClrName);
object value;
if (hasValue)
{
if (property.IsFileUpload)
{
value = valueProvider.GetValue <ISelectedFile>(property.ClrName);
}
else if (property.Type == CustomDataType.Password)
{
value = valueProvider.GetValue <string>(property.ClrName);
}
else
{
value = valueProvider.GetValue(property.ClrName, property.ClrType);
}
var arg = new EntityPropertyUpdateEventArgs <T>(entity, valueProvider, property, value);
await RaiseAsyncEvent(EntityPropertyUpdateEvent, arg);
handled = arg.IsHandled;
}
else
{
value = property.GetValue(entity);
}
if (!handled)
{
if (value != null && !property.ClrType.IsAssignableFrom(value.GetType()))
{
throw new NotImplementedException("未处理的属性“" + property.Name + "”。");
}
ValidationContext validationContext = new ValidationContext(entity, Context.DomainContext, null);
validationContext.MemberName = property.ClrName;
validationContext.DisplayName = property.Name;
var error = property.GetAttributes <ValidationAttribute>().Select(t => t.GetValidationResult(value, validationContext)).Where(t => t != ValidationResult.Success).ToArray();
if (error.Length > 0)
{
throw new ValidationException(string.Join("，", error.Select(t => t.ErrorMessage)));
}
if (hasValue)
{
property.SetValue(entity, value);
}
}
}
private Task Service_EntityQuery(IDomainExecutionContext context, EntityQueryEventArgs <T> e)
{
List <EntitySearchItem> searchItems = new List <EntitySearchItem>();
var valueProvider = context.DomainContext.GetRequiredService <IValueProvider>();
if (!valueProvider.GetValue <bool>("Search"))
{
return(Task.CompletedTask);
}
IQueryable <T> queryable = e.Queryable;
var keys = valueProvider.Keys.Where(t => t.StartsWith("Search.", StringComparison.OrdinalIgnoreCase)).Select(t => t.Substring(7).Split('.')).GroupBy(t => t[0], t => t.Length == 1 ? "" : "." + t[1]).ToArray();
for (int i = 0; i < keys.Length; i++)
{
string propertyName = keys[i].Key;
IPropertyMetadata property = Service.Metadata.SearchProperties.FirstOrDefault(t => t.ClrName.Equals(propertyName, StringComparison.OrdinalIgnoreCase));
if (property == null)
{
continue;
}
EntitySearchItem searchItem = new EntitySearchItem();
string[] options = keys[i].ToArray();
switch (property.Type)
{
case CustomDataType.Date:
case CustomDataType.DateTime:
for (int a = 0; a < options.Length; a++)
{
if (options[a].Equals(".Start", StringComparison.OrdinalIgnoreCase))
{
DateTime start;
if (!DateTime.TryParse(valueProvider.GetValue <string>("Search." + keys[i].Key + options[a]), out start))
{
continue;
}
searchItem.MorethanDate = start;
ParameterExpression parameter = Expression.Parameter(Service.Metadata.Type);
queryable = queryable.Where <T>(Expression.Lambda <Func <T, bool> >(Expression.GreaterThanOrEqual(Expression.Property(parameter, property.ClrName), Expression.Constant(start)), parameter));
}
else if (options[a].Equals(".End", StringComparison.OrdinalIgnoreCase))
{
DateTime end;
if (!DateTime.TryParse(valueProvider.GetValue <string>("Search." + keys[i].Key + options[a]), out end))
{
continue;
}
if (property.Type == CustomDataType.Date)
{
end = end.AddDays(1);
}
searchItem.LessthanDate = end;
ParameterExpression parameter = Expression.Parameter(Service.Metadata.Type);
queryable = queryable.Where <T>(Expression.Lambda <Func <T, bool> >(Expression.LessThanOrEqual(Expression.Property(parameter, property.ClrName), Expression.Constant(end)), parameter));
}
}
break;
case CustomDataType.Boolean:
case CustomDataType.Gender:
if (options[0] == "")
{
bool result;
if (!bool.TryParse(valueProvider.GetValue <string>("Search." + keys[i].Key), out result))
{
continue;
}
searchItem.Equal = result;
ParameterExpression parameter = Expression.Parameter(Service.Metadata.Type);
queryable = queryable.Where <T>(Expression.Lambda <Func <T, bool> >(Expression.Equal(Expression.Property(parameter, property.ClrName), Expression.Constant(result)), parameter));
}
break;
case CustomDataType.Currency:
case CustomDataType.Integer:
case CustomDataType.Number:
for (int a = 0; a < options.Length; a++)
{
if (options[a].Equals(".Start", StringComparison.OrdinalIgnoreCase))
{
double start;
if (!double.TryParse(valueProvider.GetValue <string>("Search." + keys[i].Key + options[a]), out start))
{
continue;
}
searchItem.Morethan = start;
ParameterExpression parameter = Expression.Parameter(Service.Metadata.Type);
queryable = queryable.Where <T>(Expression.Lambda <Func <T, bool> >(Expression.GreaterThanOrEqual(Expression.Property(parameter, property.ClrName), Expression.Constant(start)), parameter));
}
else if (options[a].Equals(".End", StringComparison.OrdinalIgnoreCase))
{
double end;
if (!double.TryParse(valueProvider.GetValue <string>("Search." + keys[i].Key + options[a]), out end))
{
continue;
}
searchItem.Lessthan = end;
ParameterExpression parameter = Expression.Parameter(Service.Metadata.Type);
queryable = queryable.Where <T>(Expression.Lambda <Func <T, bool> >(Expression.LessThanOrEqual(Expression.Property(parameter, property.ClrName), Expression.Constant(end)), parameter));
}
}
break;
case CustomDataType.Other:
if (property.CustomType == "Enum")
{
object result;
try
{
result = Enum.Parse(property.ClrType, valueProvider.GetValue <string>("Search." + keys[i].Key));
}
catch
{
continue;
}
searchItem.Enum = new EnumConverter(property.ClrType).ConvertToString(result);
ParameterExpression parameter = Expression.Parameter(Service.Metadata.Type);
queryable = queryable.Where <T>(Expression.Lambda <Func <T, bool> >(Expression.Equal(Expression.Property(parameter, property.ClrName), Expression.Constant(result)), parameter));
}
else if (property.CustomType == "Entity")
{
searchItem.Contains = valueProvider.GetValue <string>("Search." + keys[i].Key);
if (searchItem.Contains == null)
{
continue;
}
var isId = valueProvider.GetValue <bool?>("Search." + keys[i].Key + ".Id");
ParameterExpression parameter = Expression.Parameter(Service.Metadata.Type);
if (isId.HasValue && isId.Value)
{
var keyProperty = EntityDescriptor.GetMetadata(property.ClrType).KeyProperty;
var id = keyProperty.Converter.ConvertFrom(searchItem.Contains);
Expression expression = Expression.Property(Expression.Property(parameter, property.ClrName), keyProperty.ClrName);
expression = Expression.Equal(expression, Expression.Constant(id));
queryable = queryable.Where <T>(Expression.Lambda <Func <T, bool> >(expression, parameter));
}
else
{
Expression expression = Expression.Property(Expression.Property(parameter, property.ClrName), EntityDescriptor.GetMetadata(property.ClrType).DisplayProperty.ClrName);
expression = Expression.Call(expression, typeof(string).GetMethod("Contains", new Type[] { typeof(string) }), Expression.Constant(searchItem.Contains));
queryable = queryable.Where <T>(Expression.Lambda <Func <T, bool> >(expression, parameter));
}
}
break;
default:
if (property.ClrType == typeof(string))
{
searchItem.Contains = valueProvider.GetValue <string>("Search." + keys[i].Key);
if (searchItem.Contains == null)
{
continue;
}
ParameterExpression parameter = Expression.Parameter(Service.Metadata.Type);
Expression expression = Expression.Property(parameter, property.ClrName);
expression = Expression.Call(expression, typeof(string).GetMethod("Contains", new Type[] { typeof(string) }), Expression.Constant(searchItem.Contains));
queryable = queryable.Where <T>(Expression.Lambda <Func <T, bool> >(expression, parameter));
}
break;
}
if (searchItem.Contains != null || searchItem.Enum != null || searchItem.Equal.HasValue || searchItem.Lessthan.HasValue || searchItem.LessthanDate.HasValue || searchItem.Morethan.HasValue || searchItem.MorethanDate.HasValue)
{
searchItem.Name = property.Name;
}
if (searchItem.Name != null)
{
searchItems.Add(searchItem);
}
e.Queryable = queryable;
}
context.DomainContext.DataBag.SearchItem = searchItems.ToArray();
return(Task.CompletedTask);
}
private PropertyState?GetPropertyState(IPropertyMetadata property) => _formState.GetPropertyState(property, false);
/// <summary>
/// Executa um comando de insert no banco de dados.
/// </summary>
/// <param name="commandText">Texto do comando a ser executado.</param>
/// <param name="action">Informação da ação de persistência.</param>
/// <param name="transaction">Transação do comando.</param>
/// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais.</param>
/// <returns>Retorna resultado da ação de persistência.</returns>
protected virtual PersistenceActionResult ExecuteInsertCommand(string commandText, PersistenceAction action, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings)
{
var trans = (PersistenceTransactionExecuter)transaction;
var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName);
bool hasRowVersion = typeMetadata.IsVersioned;
var onlyResultProperties = typeMetadata.GetVolatileProperties().Where(f => action.Parameters.Count(g => g.Name == f.Name) == 0);
int onlyResultCount = onlyResultProperties.Count();
int parameterCount = action.Parameters.Count + onlyResultCount;
if (hasRowVersion)
{
parameterCount++;
}
var resultParameters = new PersistenceParameter[action.Parameters.Count + onlyResultCount];
var parameters = new GDAParameter[parameterCount + onlyResultCount];
for (int i = 0; i < action.Parameters.Count; i++)
{
parameters[i] = CreateParameter('?' + action.Parameters[i].Name, action.Parameters[i].Value);
if (action.Parameters[i].DbType != DbType.AnsiString)
{
parameters[i].DbType = action.Parameters[i].DbType;
}
resultParameters[i] = action.Parameters[i];
}
int index = action.Parameters.Count;
foreach (var property in onlyResultProperties)
{
parameters[index] = CreateParameter('?' + property.Name, "", 0, System.Data.ParameterDirection.InputOutput);
resultParameters[index] = new PersistenceParameter(property.Name, "");
index++;
}
if (hasRowVersion)
{
parameters[index] = CreateParameter('?' + DataAccessConstants.RowVersionPropertyName, action.RowVersion, 0, System.Data.ParameterDirection.Output);
}
int affectedRows = 0;
try
{
var da = new DataAccess(trans.Transaction.ProviderConfiguration);
affectedRows = da.ExecuteCommand(trans.Transaction, CommandType.Text, action.CommandTimeout, commandText, parameters);
}
catch (Exception ex)
{
Exception ex2 = ex;
if (ex.InnerException is System.Data.Common.DbException || ex.InnerException is DataException)
{
ex2 = ex.InnerException;
}
ex = new DataException(ResourceMessageFormatter.Create(() => Properties.Resources.Exception_ExecuteDatabaseCommand, ex2.Message).Format(), ex2);
action.NotifyError(ex);
return(new PersistenceActionResult()
{
Success = false,
AffectedRows = affectedRows,
ActionId = action.ActionId,
FailureMessage = ex.Message,
RowVersion = (hasRowVersion) ? (long)parameters[parameters.Length - 1].Value : 0
});
}
var keyRepository = GetKeyRepository(trans.ProviderName);
if (keyRepository.IsPosCommand(action.EntityFullName))
{
IPropertyMetadata identityMetadata = typeMetadata.GetKeyProperties().FirstOrDefault();
if (identityMetadata != null && identityMetadata.ParameterType == Schema.PersistenceParameterType.IdentityKey)
{
for (int i = 0; i < parameters.Length; i++)
{
if (action.Parameters[i].Name == identityMetadata.Name)
{
int identityValue = 0;
var key = keyRepository.GetPrimaryKey(transaction, typeMetadata.FullName);
if (key is int)
{
identityValue = (int)key;
}
else if (key is uint)
{
identityValue = (int)(uint)key;
}
else
{
identityValue = Convert.ToInt32(key);
}
parameters[i].Value = identityValue;
var virtualIdValue = action.Parameters[i].Value;
int virtualId = 0;
if (virtualIdValue is int)
{
virtualId = (int)virtualIdValue;
}
else if (virtualIdValue is uint)
{
virtualId = (int)(uint)virtualIdValue;
}
else
{
virtualId = Convert.ToInt32(virtualIdValue);
}
action.Parameters[i].Value = identityValue;
primaryKeyMappings.Add(virtualId, identityValue);
break;
}
}
}
}
action.NotifyExecution();
return(new PersistenceActionResult()
{
Success = true,
AffectedRows = affectedRows,
Parameters = resultParameters,
ActionId = action.ActionId,
RowVersion = (hasRowVersion) ? (long)parameters[parameters.Length - 1].Value : 0
});
}
private PropertyImpl(IPropertyMetadata metadata, Item parent)
{
_metadata = metadata;
Parent = parent;
}
/// <summary>
/// Initialize.
/// </summary>
/// <param name="context">Entity descriptor context.</param>
/// <param name="property">Property metadata.</param>
public EntityValueConverterContext(EntityDescriptorContext context, IPropertyMetadata property)
{
_Context = context;
Property = property;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public bool IsKeyProperty(IPropertyMetadata property)
{
return (property.Name.EqualsIgnoreCase("Id") || property.HasContractAttribute<PropertyContract.KeyAttribute>());
}
public Relation(Type relatedEntity, IPropertyMetadata property, IReadOnlyList <IElement> relatedElements)
{
RelatedEntity = relatedEntity ?? throw new ArgumentNullException(nameof(relatedEntity));
Property = property ?? throw new ArgumentNullException(nameof(property));
RelatedElements = relatedElements ?? throw new ArgumentNullException(nameof(relatedElements));
}
private IWebElement GetRequiredValidationMesssage(IPropertyMetadata metadata)
{
var elementId = (metadata.PropertyInfo.Name + "-required-validation-message").ToHtmlNamingConvention();
var element = this.Page.Find.Element(By.Id(elementId));
return element;
}
public ObjectToValueConverter(IPropertyMetadata propertyMetadata)
{
_propertyMetadata = propertyMetadata;
}
/// <summary>
/// Initialize.
/// </summary>
/// <param name="context">Entity descriptor context.</param>
/// <param name="property">Property metadata.</param>
public EntityValueConverterContext(EntityDescriptorContext context, IPropertyMetadata property)
{
_Context = context;
Property = property;
}
public bool IsModified(IPropertyMetadata property)
{
return(GetPropertyState(property) !.IsModified);
}
public ElementConfig(IPropertyMetadata id, params IExpressionMetadata[] labels)
{
IdProperty = id ?? throw new ArgumentNullException(nameof(id));
DisplayProperties = labels?.ToList() ?? throw new ArgumentNullException(nameof(labels));
}
public bool IsValid(IPropertyMetadata property)
{
return(!GetPropertyState(property) !.GetValidationMessages().Any());
}
private object MapPropertyFromObject(object source, PropertyInfo sourceProperty, IPropertyMetadata viewModelProperty,
CultureInfo culture)
{
return(MapProperty(
sourceProperty.Get(source),
sourceProperty.PropertyType,
viewModelProperty.PropertyType,
viewModelProperty.SourcePropertyName,
viewModelProperty.FormattableProperty || viewModelProperty.LocalizableEnumProperty,
culture));
}
public bool WasValidated(IPropertyMetadata property)
{
return(GetPropertyState(property) !.WasValidated);
}
public ObjectToValueConverter(IPropertyMetadata propertyMetadata)
{
_propertyMetadata = propertyMetadata;
}
public void AddValidationMessage(IPropertyMetadata property, string message)
{
GetPropertyState(property, true) !.AddMessage(message);
GetPropertyState(property, true) !.WasValidated = true;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private IOperand<LambdaExpression> WriteNewPropertyExpression(IPropertyMetadata property)
{
throw new NotImplementedException();
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public bool IsToOneRelationProperty(IPropertyMetadata property)
{
return IsDataObjectContract(property.ClrType);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void WriteRelationPropertyConfiguration(IPropertyMetadata property, Operand<EntityTypeConfiguration<TT.TImpl>> typeConfig)
{
if ( property.Relation.RelationKind == RelationKind.ManyToOne && property.Relation.ThisPartyKind == RelationPartyKind.Dependent )
{
WriteManyToOnePropertyConfiguration(property, typeConfig);
}
else if ( property.Relation.RelationKind == RelationKind.OneToMany && property.Relation.ThisPartyKind == RelationPartyKind.Principal )
{
WriteOneToManyPropertyConfiguration(property, typeConfig);
}
}
public abstract bool CalculateResult(IPropertyMetadata propertyMetadata, object entity);
private PropertyImpl(IPropertyMetadata metadata, Item parent)
{
this.metadata = metadata;
this.Parent = parent;
}
private string GetLabel(IPropertyMetadata metadata)
{
var name = metadata.Display.GetName();
if (string.IsNullOrWhiteSpace(name))
{
name = metadata.PropertyInfo.Name.Dehumanize();
}
return name;
}
public void NotifyPropertyIncludedInForm(IPropertyMetadata property)
{
GetPropertyState(property);
}
public override bool CalculateResult(IPropertyMetadata propertyMetadata, object entity)
{
var entityValue = propertyMetadata.GetValue<string>(entity);
if (entityValue == null && propertyMetadata.Type.IsEnumEx())
{
var entityValueAsObject = propertyMetadata.GetValue(entity);
if (entityValueAsObject != null)
{
entityValue = entityValueAsObject.ToString();
}
}
switch (SelectedCondition)
{
case Condition.Contains:
return entityValue != null && entityValue.IndexOf(Value, StringComparison.CurrentCultureIgnoreCase) != -1;
case Condition.DoesNotContain:
return entityValue != null && entityValue.IndexOf(Value, StringComparison.CurrentCultureIgnoreCase) == -1;
case Condition.EndsWith:
return entityValue != null && entityValue.EndsWith(Value, StringComparison.CurrentCultureIgnoreCase);
case Condition.DoesNotEndWith:
return entityValue != null && !entityValue.EndsWith(Value, StringComparison.CurrentCultureIgnoreCase);
case Condition.EqualTo:
return entityValue == Value;
case Condition.GreaterThan:
return string.Compare(entityValue, Value, StringComparison.InvariantCultureIgnoreCase) > 0;
case Condition.GreaterThanOrEqualTo:
return string.Compare(entityValue, Value, StringComparison.InvariantCultureIgnoreCase) >= 0;
case Condition.IsEmpty:
return entityValue == string.Empty;
case Condition.IsNull:
return entityValue == null;
case Condition.LessThan:
return string.Compare(entityValue, Value, StringComparison.InvariantCultureIgnoreCase) < 0;
case Condition.LessThanOrEqualTo:
return string.Compare(entityValue, Value, StringComparison.InvariantCultureIgnoreCase) <= 0;
case Condition.NotEqualTo:
return entityValue != Value;
case Condition.NotIsEmpty:
return entityValue != string.Empty;
case Condition.NotIsNull:
return entityValue != null;
case Condition.StartsWith:
return entityValue != null && entityValue.StartsWith(Value, StringComparison.CurrentCultureIgnoreCase);
case Condition.DoesNotStartWith:
return entityValue != null && !entityValue.StartsWith(Value, StringComparison.CurrentCultureIgnoreCase);
case Condition.Matches:
return entityValue != null
&& _regexIsValidCache.GetFromCacheOrFetch(Value, () => RegexHelper.IsValid(Value))
&& _regexCache.GetFromCacheOrFetch(Value, () => new Regex(Value, RegexOptions.Compiled)).IsMatch(entityValue);
case Condition.DoesNotMatch:
return entityValue != null
&& _regexIsValidCache.GetFromCacheOrFetch(Value, () => RegexHelper.IsValid(Value))
&& !_regexCache.GetFromCacheOrFetch(Value, () => new Regex(Value, RegexOptions.Compiled)).IsMatch(entityValue);
default:
throw new NotSupportedException(string.Format("Condition '{0}' is not supported.", SelectedCondition));
}
}
/// <summary>
/// Render a property editor.
/// </summary>
/// <param name="helper">A htmlhelper.</param>
/// <param name="property">Property metadata.</param>
/// <param name="value">Property value.</param>
public static MvcHtmlString Editor(this HtmlHelper helper, IPropertyMetadata property, object value)
{
if (helper == null)
throw new ArgumentNullException("helper");
if (property == null)
throw new ArgumentNullException("property");
MvcEditorModel model = new MvcEditorModel();
model.Metadata = property;
model.Value = value;
if (property.Type == CustomDataType.Other)
return helper.Partial(property.CustomType + "Editor", model);
else
return helper.Partial(property.Type.ToString() + "Editor", model);
}
public void NotifyPropertyFinished(IPropertyMetadata property)
{
GetPropertyState(property) !.IsBusy = false;
OnValidationStateChanged?.Invoke(this, new ValidationStateChangedEventArgs());
}
private string GetHumanFieldName(IPropertyMetadata metadata)
{
return this.GetLabel(metadata).ToLower();
}
protected virtual void MergeProtected(IPropertyMetadata baseMetadata)
{
}
private string GetPropertyId(IPropertyMetadata metadata)
{
return metadata.PropertyInfo.Name;
}
public override bool CalculateResult(IPropertyMetadata propertyMetadata, object entity)
{
if (IsNullable)
{
var entityValue = propertyMetadata.GetValue <int?>(entity);
switch (SelectedCondition)
{
case Condition.EqualTo:
return(entityValue == Value);
case Condition.NotEqualTo:
return(entityValue != Value);
case Condition.GreaterThan:
return(entityValue > Value);
case Condition.LessThan:
return(entityValue < Value);
case Condition.GreaterThanOrEqualTo:
return(entityValue >= Value);
case Condition.LessThanOrEqualTo:
return(entityValue <= Value);
case Condition.IsNull:
return(entityValue == null);
case Condition.NotIsNull:
return(entityValue != null);
default:
throw new NotSupportedException(string.Format("Condition '{0}' is not supported.", SelectedCondition));
}
}
else
{
var entityValue = propertyMetadata.GetValue <int>(entity);
switch (SelectedCondition)
{
case Condition.EqualTo:
return(entityValue == Value);
case Condition.NotEqualTo:
return(entityValue != Value);
case Condition.GreaterThan:
return(entityValue > Value);
case Condition.LessThan:
return(entityValue < Value);
case Condition.GreaterThanOrEqualTo:
return(entityValue >= Value);
case Condition.LessThanOrEqualTo:
return(entityValue <= Value);
default:
throw new NotSupportedException(string.Format("Condition '{0}' is not supported.", SelectedCondition));
}
}
}
private void WhenRequiredFieldIsNotBlankAndExited(IPropertyMetadata metadata)
{
this.NewTest();
IWebElement element = null;
var propertyId = this.GetPropertyId(metadata);
var humanFieldName = this.GetHumanFieldName(metadata);
var value = metadata.PropertyInfo.GetValue(this.ViewModel, null);
var s = this.Scenario();
s[string.Format("Given I am on the registration page")] = p => { this.NavigateToRegistrationPage(); element = this.Page.GetElement(metadata); };
s[string.Format("And I have not entered my {0}", humanFieldName)] = p => { element.Click(); element.SendKeys(value.ToString()); };
s[string.Format("When I exit the control")] = p => element.SendKeys("\t");
s[string.Format("Then I will see validation message that {0} is required", humanFieldName)] = p => this.GetRequiredValidationMesssage(metadata).Displayed.Should().BeFalse();
s.Execute();
}
public override bool CalculateResult(IPropertyMetadata propertyMetadata, object entity)
{
if (IsNullable)
{
var entityValue = propertyMetadata.GetValue(entity);
double doubleValue = 0d;
if (entityValue != null)
{
doubleValue = Convert.ToDouble(entityValue);
}
switch (SelectedCondition)
{
case Condition.EqualTo:
return entityValue != null && doubleValue == Value;
case Condition.NotEqualTo:
return entityValue != null && doubleValue != Value;
case Condition.GreaterThan:
return entityValue != null && doubleValue > Value;
case Condition.LessThan:
return entityValue != null && doubleValue < Value;
case Condition.GreaterThanOrEqualTo:
return entityValue != null && doubleValue >= Value;
case Condition.LessThanOrEqualTo:
return entityValue != null && doubleValue <= Value;
case Condition.IsNull:
return entityValue == null;
case Condition.NotIsNull:
return entityValue != null;
default:
throw new NotSupportedException(string.Format("Condition '{0}' is not supported.", SelectedCondition));
}
}
else
{
var entityValue = propertyMetadata.GetValue(entity);
var doubleValue = Convert.ToDouble(entityValue);
switch (SelectedCondition)
{
case Condition.EqualTo:
return doubleValue == Value;
case Condition.NotEqualTo:
return doubleValue != Value;
case Condition.GreaterThan:
return doubleValue > Value;
case Condition.LessThan:
return doubleValue < Value;
case Condition.GreaterThanOrEqualTo:
return doubleValue >= Value;
case Condition.LessThanOrEqualTo:
return doubleValue <= Value;
default:
throw new NotSupportedException(string.Format("Condition '{0}' is not supported.", SelectedCondition));
}
}
}
internal ExpressionFieldSetup(FieldConfig field, IPropertyMetadata expression) : base(field)
{
Expression = PropertyMetadataHelper.GetExpressionMetadata(expression ?? throw new ArgumentNullException(nameof(expression)));
DisplayType = field.DisplayType;
}
public CollectionDataValidator(IPropertyMetadata property)
{
_property = property;
}