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) })); } }