private static void SetMembers(IConfiguration configuration, object instance, BinderOptions options,
AccessorMembers members, ITypeReadAccessor read, ITypeWriteAccessor write,
IEnumerable <ICustomConfigurationBinder> customBinders)
{
foreach (var member in members)
{
// We don't support set only, non-public, or indexer properties
if (!member.CanRead || member.MemberInfo is MethodInfo method && method.GetParameters().Length > 0)
{
continue;
}
var value = read[instance, member.Name];
if (value == null && !member.CanWrite)
{
// Property doesn't have a value and we cannot set it so there is no
// point in going further down the graph
continue;
}
var config = configuration.GetSection(member.Name);
value = BindInstance(member.Type, value, config, options, customBinders);
if (value == default || !member.CanWrite)
{
continue;
}
write.TrySetValue(instance, member.Name, value);
}
}
public static bool FeatureEnabled <TFeature, TOptions>(this IServiceProvider serviceProvider,
out TFeature feature)
where TFeature : FeatureToggle where TOptions : class, new()
{
var options = serviceProvider.GetService(typeof(IOptions <TOptions>));
if (!(options is IOptions <TOptions> o))
{
feature = default;
return(false);
}
var featureType = AccessorMembers.Create(o.Value.GetType()).SingleOrDefault(x => x.Type == typeof(TFeature));
if (featureType == null)
{
feature = default;
return(false);
}
var accessor = ReadAccessor.Create(featureType.Type);
feature = accessor[o.Value, featureType.Name] as TFeature;
return(feature != null && feature.Enabled);
}
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
DocumentXmlSchemas(schema, context);
if (!typeof(IResource).IsAssignableFrom(context.Type))
{
return;
}
foreach (var member in AccessorMembers.Create(context.Type, AccessorMemberTypes.Properties, AccessorMemberScope.Public))
{
if (!member.TryGetAttribute <ProtectedByPolicyAttribute>(out var attribute))
{
continue;
}
var user = _http.ResolveCurrentPrincipal();
if (!user.Claims.Any() || !_authorization.AuthorizeAsync(user, null, attribute.PolicyName)
.ConfigureAwait(false).GetAwaiter().GetResult().Succeeded)
{
var propertyName = char.ToLowerInvariant(member.Name[0]) + member.Name.Substring(1);
schema.Properties.Remove(propertyName);
}
}
if (_builder.TryGetResourceNameForType(context.Type, out var name))
{
schema.Title = name;
}
}
public static string Up(this ISqlDialect d, AccessorMembers members, long sequence, IDataInfoProvider provider)
{
return(Pooling.StringBuilderPool.Scoped(sb =>
{
AppendCreateIfNotExists(d, members, provider, sb);
}));
}
internal static void WriteInner(AccessorMembers members, IReadAccessor reader, Utf8JsonWriter writer, IShaped value, JsonSerializerOptions options)
{
if (value.Body != null)
{
foreach (var field in value.Fields)
{
if (!members.TryGetValue(field, out var member))
{
continue;
}
if (!member.CanRead)
{
continue;
}
// key:
var propertyName = options.PropertyNamingPolicy?.ConvertName(member.Name) ?? member.Name;
writer.WritePropertyName(propertyName);
// value (can be null):
reader.TryGetValue(value.Body, member.Name, out var item);
JsonSerializer.Serialize(writer, item, options);
}
}
}
public static bool FeatureEnabled <TFeature, TOptions>(this IServiceProvider serviceProvider,
out TFeature feature)
where TFeature : class, IFeatureToggle
where TOptions : class, new()
{
var options = serviceProvider.GetService(typeof(IOptionsMonitor <TOptions>));
if (!(options is IOptionsMonitor <TOptions> o))
{
feature = default;
return(false);
}
var type = o.CurrentValue.GetType();
var members = AccessorMembers.Create(type, AccessorMemberTypes.Properties, AccessorMemberScope.Public);
var featureType = members.SingleOrDefault(x => x.Type == typeof(TFeature));
if (featureType == null)
{
feature = default;
return(false);
}
var accessor = ReadAccessor.Create(type);
feature = accessor[o.CurrentValue, featureType.Name] as TFeature;
return(feature != null && feature.Enabled);
}
public static List <Error> MustExistOnType <T>(FuncEnumerable <T, string> fields)
{
var type = typeof(T);
var list = new List <Error>();
foreach (var field in fields)
{
var valid = false;
foreach (var member in AccessorMembers.Create(type))
{
if (field.Equals(member.Name, StringComparison.OrdinalIgnoreCase))
{
valid = true;
}
}
if (!valid)
{
list.Add(new Error(ErrorEvents.FieldDoesNotMatch,
string.Format(ErrorStrings.FieldToPropertyMismatch, field, type.Name),
HttpStatusCode.BadRequest));
}
}
return(list);
}
public static string InsertInto(this ISqlDialect d, AccessorMembers members, IEnumerable <AccessorMember> columns, int columnCount, bool returnKeys)
{
return(Pooling.StringBuilderPool.Scoped(sb =>
{
sb.Append("INSERT INTO ");
sb.AppendTable(d, members).Append(" (")
// ReSharper disable once PossibleMultipleEnumeration
.AppendColumnNames(d, columns, columnCount)
.Append(") ");
if (returnKeys &&
d.TryFetchInsertedKey(FetchInsertedKeyLocation.BeforeValues, out var fetchBeforeValues))
{
sb.Append(fetchBeforeValues).Append(" ");
}
sb.Append("VALUES (")
// ReSharper disable once PossibleMultipleEnumeration
.AppendColumnParameters(d, columns, columnCount)
.Append(") ");
if (returnKeys && d.TryFetchInsertedKey(FetchInsertedKeyLocation.AfterStatement, out var fetchAfterStatement))
{
sb.Append("; ");
sb.Append(fetchAfterStatement);
}
}));
}
public static string Count(this ISqlDialect d, AccessorMembers members)
{
return(Pooling.StringBuilderPool.Scoped(sb =>
{
sb.Append("SELECT COUNT(1) FROM ");
sb.AppendTable(d, members);
}));
}
public async Task <Operation <ulong> > CountAsync(Type type, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var members = AccessorMembers.Create(type, AccessorMemberTypes.Properties, AccessorMemberScope.Public);
return(await members.CountAsync(_dialect, _connectionString, cancellationToken));
}
public Prototype(TInterface parent, object child)
{
_parent = parent;
_child = child;
_memberNames =
AccessorMembers.Create(typeof(TInterface)).Select(x => x.Name)
.Concat(typeof(TInterface).GetMethods().Select(x => x.Name))
.ToImmutableHashSet();
}
public static async Task <IEnumerable <T> > SelectAsync <T>(this AccessorMembers members, ISqlDialect dialect, string connectionString, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var sql = dialect.Select(members);
var selected = await dialect.QueryAsync <T>(connectionString, sql, cancellationToken : cancellationToken);
return(selected);
}
public static string Select(this ISqlDialect d, AccessorMembers members)
{
return(Pooling.StringBuilderPool.Scoped(sb =>
{
sb.Append("SELECT ");
sb.AppendColumnNames(d, members, members.Count);
sb.Append(" FROM ");
sb.AppendTable(d, members);
}));
}
public static async Task <IEnumerable <T> > SelectAsync <T>(this AccessorMembers members, ISqlDialect dialect, string connectionString, IReadOnlyDictionary <AccessorMember, object> hash, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var sql = dialect.Select(members, hash);
var parameters = hash.Keys.ToDictionary(k => $"{dialect.Parameter}{dialect.ResolveColumnName(k)}", v => hash[v]);
var selected = await dialect.QueryAsync <T>(connectionString, sql, parameters, cancellationToken);
return(selected);
}
public static async Task InsertAsync(this AccessorMembers members, ISqlDialect dialect, string connectionString, IReadOnlyDictionary <AccessorMember, object> hash, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var sql = dialect.InsertInto(members, hash.Keys, hash.Count, false);
var parameters = hash.Keys.ToDictionary(k => $"{dialect.Parameter}{dialect.ResolveColumnName(k)}", v => hash[v]);
var inserted = await dialect.ExecuteAsync(connectionString, sql, parameters, cancellationToken);
Debug.Assert(inserted == 1);
}
private static ResourceQuery DeserializeResourceQuery(byte[] buffer)
{
var query = new ResourceQuery();
var ms = new MemoryStream(buffer);
var br = new BinaryReader(ms);
query.PageOffset = br.ReadNullableInt32();
query.PageSize = br.ReadNullableInt32();
query.MaxPageSize = br.ReadNullableInt32();
query.CountTotalRows = br.ReadBoolean();
query.TotalRows = br.ReadNullableInt32();
if (br.ReadBoolean())
{
var fields = br.ReadInt32();
query.Fields = new List <string>(fields);
for (var i = 0; i < fields; i++)
{
query.Fields.Add(br.ReadString());
}
}
if (br.ReadBoolean())
{
var sorts = br.ReadInt32();
query.Sorting = new List <(AccessorMember, SortDirection)>(sorts);
for (var i = 0; i < sorts; i++)
{
var declaringTypeName = br.ReadNullableString();
if (declaringTypeName != null)
{
var declaringType = Type.GetType(declaringTypeName);
var memberName = br.ReadString();
var direction = (SortDirection)br.ReadByte();
if (declaringType == null)
{
continue;
}
var members = AccessorMembers.Create(declaringType, AccessorMemberTypes.Properties,
AccessorMemberScope.Public);
if (members.TryGetValue(memberName, out var member))
{
query.Sorting.Add((member, direction));
}
}
}
}
return(query);
}
public static async Task <Operation <ulong> > CountAsync(this AccessorMembers members, ISqlDialect dialect, string connectionString, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var sql = dialect.Count(members);
var count = await dialect.QuerySingleAsync <ulong>(connectionString, sql, cancellationToken : cancellationToken);
return(new Operation <ulong> {
Data = count
});
}
public static string Select(this ISqlDialect d, AccessorMembers members, IReadOnlyDictionary <AccessorMember, object> hash)
{
return(Pooling.StringBuilderPool.Scoped(sb =>
{
sb.Append("SELECT ");
sb.AppendColumnNames(d, hash.Keys, hash.Count);
sb.Append(" FROM ");
sb.AppendTable(d, members);
sb.AppendWhereClause(d, hash);
}));
}
public static IEnumerable <T> StreamFrame <T>(string filePath, bool reuseRowObject = false) where T : class, new()
{
// We need to be explicit here because the CSV reader will guess at primitives like `float` when `double` is defined in the mode.
var members = AccessorMembers.Create(typeof(T), AccessorMemberTypes.Fields | AccessorMemberTypes.Properties,
AccessorMemberScope.Public);
var inputFrame = DataFrame.ReadCsv(filePath, columnNames: members.Names.ToArray(),
dataTypes: members.Select(x => x.Type).ToArray());
var context = new MLContext();
var enumerable = context.Data.CreateEnumerable <T>(inputFrame, reuseRowObject);
return(enumerable);
}
public PropertyAccessor(ITypeReadAccessor reads, ITypeWriteAccessor writes, string name)
{
var members = AccessorMembers.Create(reads.Type, AccessorMemberTypes.Properties);
Info = members.PropertyInfo.Single(m => m.Name == name);
Type = Info.PropertyType;
Name = name;
_reads = reads;
_writes = writes;
}
public static IReadOnlyDictionary <AccessorMember, object> ToHash(this AccessorMembers members, object @object, string[] fields, IDataInfoProvider provider, IEnumerable <IFieldTransform> transforms)
{
var accessor = ReadAccessor.Create(@object, members.Types, members.Scope);
var usePool = fields.Length > 0 || provider != null;
// FIXME: remove AsList call
var include = usePool ? Pooling.ListPool <AccessorMember> .Get() : members.AsList();
try
{
if (fields.Length > 0)
{
foreach (var field in fields)
{
if (members.TryGetValue(field, out var member) && !IsIgnored(provider, member) && IsSaved(provider, member))
{
include.Add(member);
}
}
}
else
{
foreach (var member in members)
{
if (IsIgnored(provider, member))
{
include.Remove(member);
continue;
}
if (IsSaved(provider, member))
{
include.Add(member);
}
}
}
return(members.ToDictionary(k => k, v => ResolveValue(@object, transforms, accessor, v)));
}
finally
{
if (usePool)
{
Pooling.ListPool <AccessorMember> .Return((List <AccessorMember>) include);
}
}
}
public static async Task <Operation <TShape> > QueryOneByExampleAsync <TShape>(this ISqlDialect dialect, object example, Func <ISqlDialect, string, IReadOnlyDictionary <string, object>, CancellationToken, Task <TShape> > queryFunc, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var members = AccessorMembers.Create(example, AccessorMemberTypes.Properties, AccessorMemberScope.Public);
var hash = members.ToHash(example);
var sql = dialect.Select(members, hash);
var parameters = hash.ToDictionary(k => $"{dialect.Parameter}{dialect.ResolveColumnName(k.Key)}", v => hash[v.Key]);
var result = await queryFunc(dialect, sql, parameters, cancellationToken);
return(new Operation <TShape> {
Data = result
});
}
private static void AppendCreateIfNotExists(ISqlDialect d, AccessorMembers members, IDataInfoProvider provider, StringBuilder sb)
{
sb.Append($"CREATE TABLE IF NOT EXISTS {d.StartIdentifier}{d.ResolveTableName(members)}{d.EndIdentifier}");
sb.Append("(");
var columns = 0;
foreach (var member in members)
{
if (provider.IsIgnored(member))
{
continue;
}
if (provider.IsSaved(member))
{
columns++;
}
}
var count = 0;
foreach (var member in members)
{
if (provider.IsIgnored(member))
{
continue;
}
if (provider.IsSaved(member))
{
sb.Append($"{d.StartIdentifier}{d.ResolveColumnName(member)}{d.EndIdentifier}")
.Append(' ')
.Append(d.ResolveColumnTypeName(member))
.Append(d.ResolveColumnLimit(member))
.Append(' ')
.Append(d.ResolveColumnNullability(member));
if (++count < columns)
{
sb.Append(", ");
}
}
}
sb.AppendLine(");");
}
public IActionResult GetEmbedded(ApiVersion apiVersion, Guid id, string embeddedCollectionName, CancellationToken cancellationToken)
{
var members = AccessorMembers.Create(typeof(T), AccessorMemberTypes.Properties, AccessorMemberScope.Public);
foreach (var member in members)
{
if (!member.Type.ImplementsGeneric(typeof(IEnumerable <>)) || !member.Type.IsGenericType)
{
continue; // not a collection
}
var arguments = member.Type.GetGenericArguments();
var embeddedCollectionType = arguments[0];
if (!typeof(IResource).IsAssignableFrom(embeddedCollectionType))
{
continue; // not a resource collection
}
if (!_changeLog.TryGetResourceNameForType(embeddedCollectionType, out var name))
{
name = embeddedCollectionType.Name;
}
if (!embeddedCollectionName.Equals(name.Pluralize(), StringComparison.OrdinalIgnoreCase))
{
return(NotFound());
}
var controllerType = typeof(ResourceController <>).MakeGenericType(embeddedCollectionType);
if (!(HttpContext.RequestServices.GetService(controllerType) is IResourceController controller))
{
return(NotFound());
}
if (controller is Controller mvcController)
{
mvcController.ControllerContext = new ControllerContext(ControllerContext);
}
// FIXME: implement filters and add parent ID in the filter
return(controller.Get(apiVersion, cancellationToken));
}
// this is a generic 404, to avoid leaking mappings
return(NotFound());
}
static JsonNextLinkConverter()
{
var page = AccessorMembers.Create(typeof(NextLinkAnnotated <T>), AccessorMemberTypes.Properties, AccessorMemberScope.Public)
?? throw new InvalidOperationException();
if (!page.TryGetValue(nameof(NextLinkAnnotated <T> .NextLink), out var nextLink))
{
throw new InvalidOperationException();
}
if (!nextLink.TryGetAttribute <JsonPropertyNameAttribute>(out var attribute))
{
throw new InvalidOperationException();
}
NextLinkName = attribute.Name;
}
static JsonDeltaConverter()
{
var delta = AccessorMembers.Create(typeof(DeltaAnnotated <T>), AccessorMemberTypes.Properties,
AccessorMemberScope.Public) ?? throw new InvalidOperationException();
if (!delta.TryGetValue(nameof(DeltaAnnotated <T> .DeltaLink), out var deltaLink))
{
throw new InvalidOperationException();
}
if (!deltaLink.TryGetAttribute <JsonPropertyNameAttribute>(out var attribute))
{
throw new InvalidOperationException();
}
DeltaLinkName = attribute.Name;
}
public static IReadOnlyDictionary <AccessorMember, object> ToHash(this AccessorMembers members, object @object, params IFieldTransform[] transforms)
{
var accessor = ReadAccessor.Create(@object, members.Types, members.Scope);
return(members.ToDictionary(k => k, v =>
{
foreach (var field in transforms)
{
if (field.TryTransform(accessor, @object, v, out var transformed))
{
return transformed;
}
}
accessor.TryGetValue(@object, v.Name, out var untransformed);
return untransformed;
}));
}
private static void Header(Ui ui, AccessorMembers members)
{
ui.BeginTable("ui compact celled definition table");
{
ui.BeginElement("thead", new { @class = "full-width" });
{
ui.BeginElement("tr");
ui.Element("th");
foreach (var member in members)
{
ui.Element("th", member.Name);
}
ui.EndElement("tr");
}
ui.EndElement("thead");
}
ui.EndTable();
}
private void MaybeCacheObject(ActionExecutedContext context)
{
if (!(context.Result is OkObjectResult result))
{
return;
}
var body = result.Value;
var cacheKey = context.HttpContext.Request.GetDisplayUrl();
var json = JsonSerializer.Serialize(body, _options);
var etag = _generator.GenerateFromBuffer(Encoding.UTF8.GetBytes(json));
context.HttpContext.Response.Headers.Add(HeaderNames.ETag, new[] { etag });
_cache.Save(cacheKey, etag);
var members = AccessorMembers.Create(body, AccessorMemberTypes.Properties, AccessorMemberScope.Public);
foreach (var member in members)
{
if (member.HasAttribute <CacheTimestampAttribute>())
{
var accessor = ReadAccessor.Create(body);
if (accessor.TryGetValue(body, member.Name, out var lastModifiedDate))
{
switch (lastModifiedDate)
{
case DateTimeOffset timestamp:
context.HttpContext.Response.Headers.Add(HeaderNames.LastModified,
timestamp.ToString("R"));
_cache.Save(cacheKey, timestamp);
break;
case DateTime timestamp:
context.HttpContext.Response.Headers.Add(HeaderNames.LastModified,
timestamp.ToString("R"));
_cache.Save(cacheKey, timestamp);
break;
}
}
}
}
}
public async Task <Operation <IEnumerable <T> > > FetchAsync <T>(CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
var members = AccessorMembers.Create(typeof(T), AccessorMemberTypes.Properties, AccessorMemberScope.Public);
var result = await members.SelectAsync <T>(_dialect, _connectionString, cancellationToken : cancellationToken);
return(Operation.FromResult(result));
}
catch (StorageException e)
{
return(Operation.FromResult(Enumerable.Empty <T>(), new List <Error>
{
new Error(ErrorEvents.AggregateErrors, e.Message)
}));
}
}
