static Member GetMemberOrThrow(Type objectType, TypeAccessor accessor, string property)
{
return(accessor.GetMembers().FirstOrDefault(m => m.Name == property)
?? throw new ArgumentException($@"Weird! Could not find member named '{property}' among these:
{string.Join(Environment.NewLine, accessor.GetMembers().Select(m => $" {m.Name}"))}
from type {objectType}"));
}
static IEnumerable <string> GetProperties(TypeAccessor typeAccessor)
{
return(typeAccessor.GetMembers()
.Where(m => m.GetAttribute(typeof(XmlIgnoreAttribute), true) == null)
.Where(m => m.GetAttribute(typeof(IgnoreDataMemberAttribute), true) == null)
.Select(m => m.Name));
}
static bool IsReferenceType(TypeAccessor accessor)
{
var members = accessor.GetMembers().ToArray();
return(members.Any(m => m.Name == nameof(PowerSystemResourceAssets.referenceType)) &&
members.Any(m => m.Name == nameof(PowerSystemResourceAssets.@ref)));
}
private List <QueryParameter> GetInMemoryFilterQueryParameters()
{
var modelMembers = new List <ModelMember>();
_expressions.ForEach(expression =>
{
MemberExpression memberExpression = expression.Body as MemberExpression ?? (expression.Body as UnaryExpression)?.Operand as MemberExpression;
if (memberExpression != null)
{
// Find the member.
var rawMemberExpression = memberExpression.ToString();
var depth = rawMemberExpression.Count(x => x == '.');
string path = depth > 1 ? rawMemberExpression.Substring(rawMemberExpression.IndexOf('.') + 1) : memberExpression.Member.Name;
var member = _accessor.GetMembers().ToList().Single(x =>
x.Name == (depth > 1 ? path.Substring(0, path.IndexOf('.')) : memberExpression.Member.Name));
var modelMember = new ModelMember(_type, _accessor, member, false);
_modelMemberList.Add(modelMember);
modelMembers.Add(modelMember);
}
});
return(modelMembers.Select(m => new QueryParameter {
MemberModel = m
}).ToList());
}
private IList <PropertyMapper> CreatePropertyMappers(IDataRecord dataRecord)
{
var list = new List <PropertyMapper>();
var members = _typeAccessor
.GetMembers()
.Where(m => m.CanWrite);
for (var i = 0; i < dataRecord.FieldCount; i++)
{
var columnName = dataRecord.GetName(i);
var columnNameVariants = GetVariants(columnName);
var member = members.FirstOrDefault(m =>
{
var propertyVariants = GetVariants(m.Name);
return(propertyVariants.Intersect(columnNameVariants).Any());
});
if (member == default(Member))
{
continue;
}
list.Add(new PropertyMapper()
.WithColumnIndex(i)
.WithPropertyName(member.Name)
.WithPropertyType(member.Type));
}
return(list);
}
/// <summary>Gets a dictionary containing the objects property and field names and values.</summary>
/// <param name="obj">Object to get names and values from.</param>
/// <param name="accessor">The type accessor to use.</param>
/// <returns>Dictionary containing property and field names and values.</returns>
public static IDictionary <string, object> GetPropertyAndFieldNamesAndValuesDictionary(this object obj, TypeAccessor accessor)
{
var props = accessor.GetMembers().ToDictionary(
p => p.Name,
p => accessor[obj, p.Name]);
return(props);
}
public ModelType()
{
var type = typeof(TSourceType);
_typeAccessor = TypeAccessor.Create(type);
_members = _typeAccessor.GetMembers().ToList();
Name = type.Name;
}
private static T ClonePoco <T>(TypeAccessor accessor, T defaultPoco) where T : class
{
// Copy the values of the POCO passed in to a new POCO.
var clonedPoco = New <T> .Instance();
accessor.GetMembers()
.ForEach(c => accessor[clonedPoco, c.Name] = accessor[defaultPoco, c.Name]);
return(clonedPoco);
}
private static T NullStringsToEmpty <T>(TypeAccessor accessor, T poco) where T : class
{
// Set null strings in the POCO should to empty strings.
accessor.GetMembers()
.Where(p => p.Type == typeof(string))
.Where(p => accessor[poco, p.Name] == null)
.ForEach(p => accessor[poco, p.Name] = string.Empty);
return(poco);
}
static bool IsValueType(TypeAccessor accessor)
{
var members = accessor.GetMembers().ToList();
var isValueType = members.Any(m => m.Name == nameof(KiloActivePower.Value)) &&
members.Any(m => m.Name == nameof(KiloActivePower.unit)) &&
members.Any(m => m.Name == nameof(KiloActivePower.multiplier));
return(isValueType);
}
public DocumentDbRepositoryQueryTests()
{
Expression <Func <DocumentDbFoo3, string> > expression = x => x.Category;
var configurations = GetBaseConfigurations <DocumentDbFoo3>((MemberExpression)expression.Body);
DocumentDbRepository.Configure(typeof(DocumentDbFoo3), configurations);
_accessor = TypeAccessor.Create(_type);
_members = _accessor.GetMembers();
}
public InMemoryRepositoryQueryTests()
{
var list = new List <IInMemoryCompare> {
new InMemoryCompareInt(), new InMemoryCompareString()
};
_inMemoryRepository = new InMemoryRepository(new InMemoryComparerProvider(list));
_accessor = TypeAccessor.Create(_type);
_members = _accessor.GetMembers();
}
public void GetMembers_DoesNotReturnEventPrivateFields_IfSerializeOptionIsFields()
{
var type = typeof(ClassD);
var typeAccessor = new TypeAccessor(type, null);
var members = typeAccessor.GetMembers();
Assert.AreEqual(1, members.Length);
Assert.AreEqual("fieldB", members[0].Name);
}
public void GetMembers_OnlyReturnsPrivateFields_IfSerializeOptionIsFields()
{
var type = typeof(ClassB);
var typeAccessor = new TypeAccessor(type, null);
var members = typeAccessor.GetMembers();
Assert.AreEqual(2, members.Length);
Assert.AreEqual("fieldA", members[0].Name);
Assert.AreEqual("fieldB", members[1].Name);
}
private void AddQueryParameterWithValidModelMember(ContextValue contextValue)
{
var member = _searchModeltypeAccessor.GetMembers().Single(m => m.Name == "Filters");
var queryParameter = new QueryParameter
{
MemberModel = new ModelMember(_searchModelType, _searchModeltypeAccessor, member, false),
ContextValue = contextValue
};
_queryParams.Add(queryParameter);
}
public void CanHandleSearchModelFilters()
{
Type t = typeof(SearchModel);
TypeAccessor ta = TypeAccessor.Create(t);
var member = ta.GetMembers().ToList().Single(x => x.Name == "Filters");
var filtersMemberModel = new ModelMember(null, null, member, false);
var qa = new SearchFilterModelQueryArgument();
qa.CanHandle(filtersMemberModel).ShouldBeTrue();
}
private object ChangeType(object value, string propertyName)
{
var type = _siteVisitorAccessor.GetMembers().Single(p => p.Name.Equals(propertyName, StringComparison.InvariantCultureIgnoreCase)).Type;
if (Nullable.GetUnderlyingType(type) != null && value == null)
{
return(null);
}
return(Convert.ChangeType(value, type));
}
public static string GetKey(this TypeAccessor t, object item)
{
var keys = string.Join("", t.GetMembers().Where(x => x.GetAttribute(typeof(KeyAttribute), false) != null)
.Select(x => t[item, x.Name].ToString()));
if (string.IsNullOrEmpty(keys))
{
throw new InvalidOperationException("Missing Key Attribute");
}
return(keys);
}
//private readonly int _length;
public TupleServiceSlimObjectCaller(TypeAccessor accessor)
{
_objectMembers = new();
_typeAccessor = accessor ?? throw new ArgumentNullException(nameof(accessor));
foreach (var member in accessor.GetMembers())
{
if (CheckItemName(member.Name, out var itemNum))
{
_objectMembers[itemNum - 1] = TupleServiceSlimObjectMember.Of(member);
}
}
}
/// <summary>
/// Use a list entry to create
/// </summary>
/// <param name="name">name of the single entry, if enumerable is a string or struct</param>
/// <param name="data"></param>
/// <param name="tAccessor"></param>
/// <param name="command"></param>
private void CreateRefScalarVariable(string name, object data, TypeAccessor tAccessor, IDbCommand command)
{
if (tAccessor != null)
{
foreach (var item in tAccessor.GetMembers())
{
command.AddParameter(item.Name, tAccessor[data, item.Name]);
}
}
else
{
command.AddParameter(name, data);
}
}
public XLColor ResolveThemeColor(XLThemeColor themeColor)
{
var tc = themeColor.ToString();
var members = accessor.GetMembers();
if (members.Any(m => m.Name.Equals(tc)))
{
return(accessor[this, tc] as XLColor);
}
else
{
return(null);
}
}
public TableReader(RfcDestination conn, string tableName)
{
_conn = conn;
_tableName = tableName;
_accesor = TypeAccessor.Create(_rowType);
_members = _accesor.GetMembers();
_memberByName = _members
.ToDictionary(m => m.Name);
_memberByAlias = _members
.ToDictionary(m => TableReaderExtensions.GetColumnName(m));
_peakConnectionsLimit = Convert.ToInt32(_conn.Parameters[RfcConfigParameters.PeakConnectionsLimit]);
}
public void DateTimeOffsetStringIsODataCompliant()
{
var filter = new NumericSearchFilter();
TypeAccessor ta = TypeAccessor.Create(typeof(TestNumericSearchFilter));
var m = ta.GetMembers().Single(x => x.Name == "MyDateTimeOffset");
var result = filter.GetFilter(new SearchFilterModel
{
Comprison = Comparisons.Equal,
FieldName = "MyDateTimeOffset",
Value = "2017-01-12"
}, m);
result.ShouldBe("MyDateTimeOffset eq 2017-01-12T00:00:00Z");
}
public PropertyAccessor(TypeAccessor accessor, Type type, string name)
{
Type = type;
_accessor = accessor;
Name = name;
Info = accessor.CachedMembers.SingleOrDefault(m => m.Name == name) as PropertyInfo;
var member = accessor.GetMembers().SingleOrDefault(p => p.Name == name);
if (member == null)
{
return;
}
_member = member;
}
public DocumentDbRepositoryQueryTests()
{
Expression <Func <DocumentDbFoo3, string> > expression = x => x.Category;
"DocumentDbRepositoryQueryTests instantiated and loading config.".Log();
var configurations = GetBaseConfigurations <DocumentDbFoo3>((MemberExpression)expression.Body);
"Configuring DocumentDbRepository.".Log();
DocumentDbRepository.Configure(typeof(DocumentDbFoo3), configurations);
"Creating DocumentDbRepositoryQueryTests accessor type.".Log();
_accessor = TypeAccessor.Create(_type);
_members = _accessor.GetMembers();
"DocumentDbRepositoryQueryTests constructor.".Log();
}
private async Task <object> GetValue(
TypeAccessor edgeObjectTypeAccessor,
ConnectionEdge connectionEdge,
IGraphRequestContext graphRequestContext,
List <ConnectionEdgeDestinationFilter> connectionEdgeDestinationFilters,
QueryExecutionContext queryExecutionContext)
{
var member = edgeObjectTypeAccessor.GetMembers().Single(x => x.Name == connectionEdge.MetaFieldName);
var destTypeAccessor = TypeAccessor.Create(member.Type);
var destQueryMember = destTypeAccessor.GetMembers().Single(m => m.GetAttribute(typeof(KeyAttribute), true) != null);
var qp = new QueryStep();
qp.QueryParameters.Add(new QueryParameter
{
ContextValue = new ContextValue {
Comparison = Comparisons.Equal, Values = new List <object> {
connectionEdge.DestinationId
}
},
MemberModel = new ModelMember(member.Type, destTypeAccessor, destQueryMember, false)
});
if (connectionEdgeDestinationFilters != null)
{
connectionEdgeDestinationFilters.Where(x => x.Type == member.Type.AssemblyQualifiedName)
.ToList().ForEach(connectionEdgeDestinationFilter =>
{
qp.QueryParameters.Add(new QueryParameter
{
ContextValue = new ContextValue {
Comparison = Comparisons.Equal, Values = connectionEdgeDestinationFilter.Mapper(queryExecutionContext)
},
MemberModel = connectionEdgeDestinationFilter.ModelMember
});
});
}
var entities = (await _graphQlRepositoryProvider.QueryAsync(EntityQueryName, qp, graphRequestContext)).ToList();
if (entities.Count > 1)
{
throw new InvalidOperationException(MultipleEntitiesDetectedError);
}
return(entities.SingleOrDefault());
}
/// <summary>
///This method loads navigation properties where we find a foreign key set but with a null value in the actual navigation property.
///This happens after an update as we are only setting the foreign key id, and returning the same entity.
/// </summary>
/// <typeparam name="T2">The type of entities</typeparam>
/// <param name="items">The entity or entities to process</param>
/// <returns></returns>
public List <T2> RefreshEntities <T2>(List <T2> items) where T2 : EntityBase
{
//Loop through entities fields and load navigation properties if we have an ID set with no related object field
TypeAccessor accessor = TypeAccessor.Create(typeof(T2));
var memberSet = accessor.GetMembers();
ObjectContext objectContext = ((IObjectContextAdapter)DataContext).ObjectContext;
ObjectSet <T2> set = objectContext.CreateObjectSet <T2>();
var foreignKeys = set.EntitySet.ElementType.NavigationProperties.SelectMany(n => n.GetDependentProperties());
var navProperties = set.EntitySet.ElementType.NavigationProperties.Select(np => np.Name);
foreach (var item in items)
{
foreach (var foreignKey in foreignKeys)
{
var foreignKeyField = foreignKey.Name;
var navProp = set.EntitySet.ElementType.NavigationProperties.SingleOrDefault(np => np.GetDependentProperties().Contains(foreignKey));
if (navProp == null)
{
continue;
}
var navPropField = navProp.Name;
var foreignKeyVal = accessor[item, foreignKeyField];
var isForeignKeyNull = IsNullEquivalent(memberSet.SingleOrDefault(member => member.Name == foreignKeyField), foreignKeyVal);
var navPropVal = accessor[item, navPropField];
if (!isForeignKeyNull && navPropVal == null)
{
var entityBaseItem = (item as EntityBase);
//If the item was unchanged we'll need to attach it first
if (entityBaseItem.State == ObjectState.Unchanged)
{
set.Attach(item);
}
DataContext.Entry(item).Reference(navPropField).Load();
}
}
}
return(items);
}
public async Task TransformAsync(object item, TypeAccessor typeAccessor, IGraphRequestContext context)
{
var keyMembers = typeAccessor.GetMembers().Where(x => x.GetAttribute(typeof(RequestContextValueAttribute), true) != null).ToList();
if (keyMembers.Count > 0)
{
foreach (var keyMember in keyMembers)
{
var value = typeAccessor[item, keyMember.Name];
var attr = (RequestContextValueAttribute)keyMember.GetAttribute(typeof(RequestContextValueAttribute), true);
var gen = _requestContextValueExtractors.SingleOrDefault(x => x.GetType() == attr.Type);
if (gen != null)
{
typeAccessor[item, keyMember.Name] = await gen.GetValueAsync(context, keyMember);
}
}
}
}
public Task TransformAsync(object item, TypeAccessor typeAccessor, IGraphRequestContext context)
{
var autoIdMembers = typeAccessor.GetMembers().Where(x => x.GetAttribute(typeof(AutoIdAttribute), true) != null).ToList();
if (autoIdMembers.Count > 0)
{
autoIdMembers.ForEach(member =>
{
var value = typeAccessor[item, member.Name];
if (value is string key && key == Marker)
{
typeAccessor[item, member.Name] = Guid.NewGuid().ToString("N");
}
});
}
return(Task.CompletedTask);
}
static Member[] GetMemberAccessors(TypeAccessor accessor, Type type)
{
var memberSet = accessor.GetMembers();
try
{
var orderDictionary = type.GetProperties()
.Select((property, index) => new { property, index })
.ToDictionary(a => a.property.Name, a => a.index);
return(memberSet
.OrderBy(m => orderDictionary[m.Name])
.ToArray());
}
catch
{
return(memberSet.ToArray());
}
}
public void Write(object owningObject, ISerialiserNode parentNode, Type type)
{
var typeAccessor = new TypeAccessor(type, null);
var memberInfos = typeAccessor.GetMembers();
foreach (var memberInfo in memberInfos)
{
if (memberInfo.GetCustomAttributes(typeof (NSerializerIgnoreAttribute), false).Length != 1)
{
foreach (var writer in writers)
{
if (writer.CanWrite(owningObject, memberInfo))
{
writer.Write(owningObject, parentNode, memberInfo);
break;
}
}
}
}
}
