/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
protected override Expression VisitMember(MemberExpression node)
{
IExpressionNodeVisitor <EntityType, MemberExpression> visitor = new MemberVisitor <EntityType>(_descriptor);
visitor.Visit(this, node);
return(null);
}
public TValue GetItem <TValue>(Expression <Func <TParameter, TValue> > getItem)
{
var(_, _, itemInfo) = MemberVisitor.GetMemberInfo(getItem);
var itemMetadata = CommandParameterProperty.Create((PropertyInfo)itemInfo);
var(uri, metadata) = ItemRequestFactory.CreateItemRequest(itemMetadata);
var item = _args.GetAsync(uri, metadata).GetAwaiter().GetResult();
if (item.Exists)
{
if (itemMetadata.IsCollection)
{
return(item.DeserializeJsonAsync <TValue>().GetAwaiter().GetResult());
}
else
{
var values = item.DeserializeJsonAsync <List <TValue> >().GetAwaiter().GetResult();
if (((PropertyInfo)itemInfo).PropertyType == typeof(bool))
{
return
(values.Any()
? values.Single()
: itemMetadata.DefaultValue is TValue defaultValue
? defaultValue
: (TValue)(object)true);
}
else
{
return
(values.Any()
? values.Single()
: itemMetadata.DefaultValue is TValue defaultValue
? defaultValue
: default);
public override void AcceptVisitor(MemberVisitor visitor)
{
base.AcceptVisitor(visitor);
switch (this.TypeKind)
{
case TypeMemberKind.Class:
visitor.VisitClassType(this);
break;
case TypeMemberKind.Struct:
visitor.VisitStructType(this);
break;
case TypeMemberKind.Interface:
visitor.VisitInterfaceType(this);
break;
case TypeMemberKind.Enum:
visitor.VisitEnumType(this);
break;
}
foreach (var member in this.Members)
{
member.AcceptVisitor(visitor);
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public override void AcceptVisitor(MemberVisitor visitor)
{
base.AcceptVisitor(visitor);
if (this.Signature != null)
{
if (this.Signature.Parameters != null)
{
foreach (var parameter in this.Signature.Parameters.Where(p => p.Attributes != null))
{
foreach (var attribute in parameter.Attributes)
{
visitor.VisitAttribute(attribute);
}
}
}
if (this.Signature.ReturnValue != null && this.Signature.ReturnValue.Attributes != null)
{
foreach (var attribute in this.Signature.ReturnValue.Attributes)
{
visitor.VisitAttribute(attribute);
}
}
}
}
public static string Find(Expression expression)
{
var visitor = new MemberVisitor();
visitor.Visit(expression);
return(visitor._memberName);
}
public static string GetPropertyName(Expression expression)
{
var visitor = new MemberVisitor();
visitor.Visit(expression);
return(visitor.propertyName);
}
/// <summary>
/// 编织扩展
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
internal Expression <Func <TEntity, T> > Expand <T>(Expression <Func <TEntity, T> > source)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
var adjuster = new ParameterVisitor(node => source.Parameters.Single());
var adjustedExpandables =
from expandable in _expandables
select new
{
From = expandable.From(),
To = (adjuster.Visit(expandable.To()))
};
var propertyReplacer = new MemberVisitor(node =>
{
var query =
from expandable in adjustedExpandables
where (expandable.From == node.Member)
select expandable.To;
return(query.SingleOrDefault() ?? node);
});
return((Expression <Func <TEntity, T> >)propertyReplacer.Visit(source));
}
public static MvcHtmlString AttachmentEditorFor <TModel, TValue>(this HtmlHelper <TModel> html, Expression <Func <TModel, TValue> > expression)
{
string str2 = HttpUtility.UrlEncode(MemberVisitor.GetMember <TModel, TValue>(expression).Name);
StringBuilder builder = new StringBuilder(0x200);
builder.Append("<div class=\"input-attachment\">").Append("<input type=\"hidden\" ").Append("id =\"").Append(str2).Append("\" ").Append("name=\"").Append(str2).Append("\" />").Append("<iframe src=\"/Attachment/Upload").Append("?updateKey=").Append(str2).Append("\"").Append(" ></iframe></div>");
return(MvcHtmlString.Create(builder.ToString()));
}
public override void AcceptVisitor(MemberVisitor visitor)
{
base.AcceptVisitor(visitor);
visitor.VisitProperty(this);
this.Getter?.AcceptVisitor(visitor);
this.Setter?.AcceptVisitor(visitor);
}
/// <summary>
/// Sets the specified model lambda.
/// </summary>
/// <typeparam name="TModel">The type of the model.</typeparam>
/// <typeparam name="TEntity">The type of the entity.</typeparam>
/// <param name="modelLambda">The model lambda.</param>
/// <param name="entityLambda">The entity lambda.</param>
public void Set <TModel, TEntity>(Expression <Func <TModel, dynamic> > modelLambda, Expression <Func <TEntity, dynamic> > entityLambda)
{
var visitor = new MemberVisitor();
visitor.Visit(modelLambda);
ModelMember = visitor.Result;
visitor.Visit(entityLambda);
EntityMember = visitor.Result;
}
private MemberPaths GetMemberPaths <TResult>(Expression <Func <TResult, object> >[] membersToExpand)
{
return(membersToExpand.Select(expr =>
{
var visitor = new MemberVisitor();
visitor.Visit(expr);
return visitor.MemberPath;
}));
}
public virtual void AcceptVisitor(MemberVisitor visitor)
{
if (this.Attributes != null)
{
foreach (var attribute in this.Attributes)
{
visitor.VisitAttribute(attribute);
}
}
}
/// <summary>
/// Gets the property name from the member expression.
/// </summary>
/// <typeparam name="T">Type</typeparam>
/// <typeparam name="TProperty">Property type</typeparam>
/// <param name="property">The expression</param>
/// <returns></returns>
/// <exception cref="ArgumentException">Thrown if <paramref name="property"/> is not a valid member expression.</exception>
public static string GetPropertyName <T, TProperty>(this Expression <Func <T, TProperty> > property)
{
var member = new MemberVisitor().GetMember(property) as MemberExpression;
if (member == null)
{
throw new ArgumentException("Could not get MemberExpression", "property");
}
return(member.Member.Name);
}
private bool IsVersionArgument(MethodCallExpression expression)
{
if (expression.Arguments.Count == 2)
{
var memberVisitor = new MemberVisitor();
memberVisitor.Visit(expression.Arguments[1]);
return memberVisitor.Flag;
}
return false;
}
private bool IsVersionArgument(MethodCallExpression expression)
{
if (expression.Arguments.Count == 2)
{
var memberVisitor = new MemberVisitor();
memberVisitor.Visit(expression.Arguments[1]);
return(memberVisitor.Flag);
}
return(false);
}
/// <summary>
/// 使用表达式来添加一个规则。
/// </summary>
/// <param name="expression">使用表达式来限定添加验证的属性。</param>
/// <param name="attribute">一个 <see cref="ValidationAttribute"/> 实例。</param>
/// <returns></returns>
public MetadataConverter <TEntity> Add(Expression <Func <TEntity, object> > expression, ValidationAttribute attribute)
{
var memberName = MemberVisitor.Find(expression);
if (!string.IsNullOrEmpty(memberName))
{
var attrs = _attrCache.TryGetValue(memberName, () => new List <ValidationAttribute>());
attrs.Add(attribute);
}
return(this);
}
public async Task <object> GetItemAsync(LambdaExpression getItem, string handle = null)
{
if (getItem == null)
{
throw new ArgumentNullException(nameof(getItem));
}
var settingInfo = MemberVisitor.GetMemberInfo(getItem);
var settingMetadata = new SettingMetadata(settingInfo, GetMemberName);
var(uri, metadata) = SettingRequestFactory.CreateSettingRequest(settingMetadata, handle);
return(await _settings.GetItemAsync <object>(uri, metadata.Set(Use <IResourceNamespace> .Namespace, x => x.Type, settingMetadata.MemberType)));
}
/// <summary>
/// 更新绑定目标
/// </summary>
/// <returns></returns>
public BindInfo Update()
{
//创建成员表达式访问者
var visitor = new MemberVisitor();
//获取源的当前值
var sourceVal = visitor.GetValue(Source);
//更新绑定目标
visitor.SetValue(Target, sourceVal);
return(this);
}
public async Task SetItemAsync(LambdaExpression setItem, object newValue, string handle = null)
{
if (setItem == null)
{
throw new ArgumentNullException(nameof(setItem));
}
var settingInfo = MemberVisitor.GetMemberInfo(setItem);
var settingMetadata = new SettingMetadata(settingInfo, GetMemberName);
var(uri, metadata) = SettingRequestFactory.CreateSettingRequest(settingMetadata, handle);
Validate(newValue, settingMetadata.Validations, uri);
await _settings.SetItemAsync(uri, newValue, metadata.Set(Use <IResourceNamespace> .Namespace, x => x.Type, settingMetadata.MemberType));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public override void AcceptVisitor(MemberVisitor visitor)
{
base.AcceptVisitor(visitor);
visitor.VisitProperty(this);
if (this.Getter != null)
{
this.Getter.AcceptVisitor(visitor);
}
if (this.Setter != null)
{
this.Setter.AcceptVisitor(visitor);
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public override void AcceptVisitor(MemberVisitor visitor)
{
base.AcceptVisitor(visitor);
visitor.VisitEvent(this);
if (Adder != null)
{
Adder.AcceptVisitor(visitor);
}
if (Remover != null)
{
Remover.AcceptVisitor(visitor);
}
}
public void Declaration_GET_DisplaysAllSectionContent()
{
WebAppTest(client =>
{
var detail = NewBsgDetail("form123");
detail.PartnerDetails.InheritAddress = true;
ExecutorStub.SetupQuery(It.IsAny<FindBsgSection>(), detail);
var expectedAnswers = new List<string>();
MemberVisitor.Visit(detail, (name, member, type, value) => expectedAnswers.Add(name));
var namesToIgnore = new List<string>
{
"Id",
"Consent.",
"Declaration.",
"PreviousSection",
"IsFinalSection",
};
// the partner details inherit the address, and the guardian and guardian's partner have full addresses
namesToIgnore.Add("PartnerDetails.Address.");
namesToIgnore.Add("GuardianDetails.InheritAddress");
namesToIgnore.Add("GuardianPartnerDetails.InheritAddress");
expectedAnswers = expectedAnswers
.Where(ea => !namesToIgnore.Any(i => ea.StartsWith(i)))
.ToList();
var response = client.Get(BsgActions.Declaration(detail.Id));
var missingAnswers = new List<string>();
foreach (var expectedAnswer in expectedAnswers)
{
var selector = $"[data-answer-for='{expectedAnswer}']";
var output = response.Doc.FindAll(selector);
output.Count.Should().BeLessOrEqualTo(1, "did not expected multiple entries for {0}", expectedAnswer);
if (output.Count < 1)
missingAnswers.Add(expectedAnswer);
}
missingAnswers.Count.Should().Be(0, "all questions should have an answer; could not find answers to the following questions:\n{0}", string.Join("\n", missingAnswers));
});
}
static IEnumerable <ExpectEntry> getExpectEntries(Assembly testAssembly)
{
var expectEntryList = new List <ExpectEntry>();
var memberVisitor = new MemberVisitor((MemberInfo member) =>
{
var expectAttributes = member.GetCustomAttributes(typeof(ExpectAttribute), false);
foreach (ExpectAttribute expectAttribute in expectAttributes)
{
string name = GetName(member);
var expectEntry = new ExpectEntry(name, testAssembly, member, expectAttribute);
expectEntryList.Add(expectEntry);
}
});
memberVisitor.VisitAssembly(testAssembly);
return(expectEntryList);
}
IgnoringNestedSourceProperty <TTarget, TSource>(
this TypeMappingSpec <TTarget, TSource> spec,
Expression sourceExpression)
where TTarget : class
where TSource : class
{
var visitor = new MemberVisitor <TSource>();
visitor.Visit(sourceExpression);
foreach (var expression in visitor.MemberExpressions)
{
spec = spec.IgnoringSourceProperty(expression.Member.Name);
}
return(spec);
}
public Expression Process(Expression expression)
{
RootExpression = expression;
var memberVisitor = new MemberVisitor(MemberMapper, MemberMapper.Options.Safety.PerformNullChecksOnCustomMappings, Variables);
// Pass 1: Transform member access so they do null-checks first, if needed
expression = memberVisitor.Visit(expression);
RootExpression = expression;
var paramVisitor = new ParameterVisitor(this.ParametersToReplace);
// Pass 2: Transform parameter placeholders with their final ones
expression = paramVisitor.Visit(expression);
RootExpression = expression;
var visibilityVisitor = new VisibilityVisitor(this);
// Pass 3: Check visibility of what is accessed, to establish if we can compile to a new dynamic assembly.
visibilityVisitor.Visit(expression);
RootExpression = expression;
this.NonPublicMembersAccessed = visibilityVisitor.NonPublicMembersAccessed;
if (this.NonPublicMembersAccessed)
{
var lambdaVisitor = new LambdaVisitor(this);
expression = lambdaVisitor.Visit(expression);
RootExpression = expression;
}
return(expression);
}
public static MemberPaths GetMemberPaths <TResult>(Expression <Func <TResult, object> >[] membersToExpand) => membersToExpand.Select(expr => MemberVisitor.GetMemberPath(expr));
public MemberPath(Expression destinationExpression) : this(MemberVisitor.GetMemberPath(destinationExpression).Reverse())
{
}
public PathConfigurationExpression(LambdaExpression destinationExpression)
{
_destinationExpression = destinationExpression;
MemberPath = new MemberPath(MemberVisitor.GetMemberPath(destinationExpression).Reverse());
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public override void AcceptVisitor(MemberVisitor visitor)
{
base.AcceptVisitor(visitor);
visitor.VisitConstructor(this);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public override void AcceptVisitor(MemberVisitor visitor)
{
base.AcceptVisitor(visitor);
visitor.VisitField(this);
}
public PathConfigurationExpression(Expression <Func <TDestination, TMember> > destinationExpression)
{
_destinationExpression = destinationExpression;
MemberPath = new MemberPath(MemberVisitor.GetMemberPath(destinationExpression));
}
