private static string SerializeState <TState>(TState state) { var hash = new Dictionary <string, object>(); if (state is IReadOnlyList <KeyValuePair <string, object> > list) { foreach (var(k, v) in list) { hash.Add(k, v); } } else { var accessor = ReadAccessor.Create(state, AccessorMemberTypes.Properties, AccessorMemberScope.Public, out var members); foreach (var member in members) { if (accessor.TryGetValue(state, member.Name, out var value)) { hash.Add(member.Name, value); } } } var stateJson = JsonSerializer.Serialize(hash); return(stateJson); }
public JsonMergePatch(Type type) { _reads = ReadAccessor.Create(type, AccessorMemberTypes.Properties, AccessorMemberScope.Public, out _members); _writes = WriteAccessor.Create(type); _data = Activator.CreateInstance <T>(); _changed = new HashSet <string>(); }
public Type GetTypeFor(object instance) { var baseType = instance.GetType(); var members = AccessorMembers.Create(baseType, AccessorMemberTypes.Properties, AccessorMemberScope.Public); if (!members.TryGetValue("Type", out _)) { return(baseType); // no type discriminator } if (!IsTypeDiscriminated(baseType, out var subTypes)) { return(baseType); // no matching subTypes } var read = ReadAccessor.Create(instance, AccessorMemberTypes.Properties, AccessorMemberScope.Public); var typeKey = read[instance, "Type"]?.ToString(); if (string.IsNullOrWhiteSpace(typeKey)) { return(baseType); // missing type discriminant } var subType = subTypes.SingleOrDefault(x => x.Name == typeKey) ?? subTypes.SingleOrDefault(x => x.Name == $"{typeKey}{baseType.Name}"); if (subType == null) { return(baseType); // sub-type error } return(subType); }
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 static string Compute(object @this, string expression) { // // Pass 1: Resolve any {{ Member }} against self. var code = StringBuilderPool.Scoped(sb => { var accessor = ReadAccessor.Create(@this.GetType()); foreach (Match match in Regex.Matches(expression, @"{{([a-zA-Z\s]+)}}", RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled)) { var key = match.Groups[1].Value; if (accessor.TryGetValue(@this, key, out var value)) { expression = expression.Replace(match.Groups[0].Value, value.ToString()); } } sb.Append($"return \"{expression}\";"); }); // // Pass 2: Execute script in context. var script = CSharpScript.Create(code, Options, typeof(ScriptContext)); var context = new ScriptContext { @this = @this }; var state = script.RunAsync(context).ConfigureAwait(false).GetAwaiter().GetResult(); return(state.ReturnValue.ToString()); }
public static object GetField(this object model, string field) { var accessor = ReadAccessor.Create(model); Assert.True(accessor.TryGetValue(model, field, out var id)); return(id); }
private static QueryAndParameters BuildSelectQueryAndParameters(IDataDescriptor descriptor, List <string> columnFilter, dynamic where) { object instance = where ?? new { }; var accessor = ReadAccessor.Create(instance.GetType()); var whereHash = accessor.AsReadOnlyDictionary(instance); var hashKeysRewrite = whereHash.Keys.ToDictionary(k => Dialect.ResolveColumnName(descriptor, k), v => v); var tableName = Dialect.ResolveTableName(descriptor); var columnNames = Dialect.ResolveColumnNames(descriptor).OrderBy(x => x).ToList(); var whereFilter = columnNames.Intersect(hashKeysRewrite.Keys).ToList(); var parameters = whereFilter.ToDictionary(key => $"{hashKeysRewrite[key]}", key => whereHash[hashKeysRewrite[key]]); var parameterKeys = parameters.Keys.ToList(); var columns = Dialect.SupportsSelectStar ? new List <string> { "*" } : columnNames; var sql = Dialect.Select(descriptor, tableName, descriptor.Schema, columnFilter ?? columns, whereFilter, parameterKeys); parameters = parameters.ToDictionary(k => $"{Dialect.Parameter}{k.Key}", v => v.Value); return(new QueryAndParameters(sql, parameters)); }
public DocumentDbRepository(string slot, IOptionsMonitor <DocumentDbOptions> options, ISafeLogger <DocumentDbRepository <T> > logger) { _reads = ReadAccessor.Create(typeof(T)); _writes = WriteAccessor.Create(typeof(T)); _slot = slot; _options = options; _logger = logger; var defaultSettings = new JsonSerializerSettings(); var documentDbOptions = options.Get(_slot); _client = new DocumentClient(EndpointUri, documentDbOptions.AccountKey, defaultSettings); _client2 = new CosmosClient(EndpointUri.ToString(), documentDbOptions.AccountKey, new CosmosClientOptions { AllowBulkExecution = true, ConnectionMode = ConnectionMode.Gateway, MaxRetryAttemptsOnRateLimitedRequests = 100 }); CreateDatabaseIfNotExistsAsync().Wait(); CreateCollectionIfNotExistsAsync().Wait(); }
public IDictionary <string, EntityProperty> WriteEntity(OperationContext operationContext) { var map = new Dictionary <string, EntityProperty>(); var accessor = ReadAccessor.Create(_entity, AccessorMemberTypes.Properties, AccessorMemberScope.Public, out var members); foreach (var member in members) { if (ShouldSkipProperty(member, operationContext)) { continue; } if (!accessor.TryGetValue(_entity, member.Name, out var value)) { continue; } var entityValue = EntityProperty.CreateEntityPropertyFromObject(value); if (entityValue != null) { map.Add(member.Name, entityValue); } } return(map); }
public JsonNextLinkConverter() { var collectionType = typeof(T); _reader = ReadAccessor.Create(collectionType, AccessorMemberTypes.Properties, AccessorMemberScope.Public, out _members); _writer = WriteAccessor.Create(collectionType, AccessorMemberTypes.Properties, AccessorMemberScope.Public); }
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); }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { var present = BaseIsValid(value, validationContext) == null; var accessor = ReadAccessor.Create(validationContext.ObjectType, out var members); return(ValidateSiblings(validationContext, members, accessor, present)); }
public static IUserStore <TUser> Store <TUser>(this UserManager <TUser> userManager) where TUser : class { var accessor = ReadAccessor.Create(typeof(UserManager <TUser>)); var userStore = accessor[userManager, "Store"]; return(userStore as IUserStore <TUser>); }
public static Query Update <T>(T instance, dynamic where = null) { var descriptor = GetDescriptor <T>(); var set = Dialect.ResolveColumnNames(descriptor, ColumnScope.Updated).ToList(); var hash = ReadAccessor.Create(instance.GetType()).AsReadOnlyDictionary(instance); var hashKeysRewrite = hash.Keys.ToDictionary(k => Dialect.ResolveColumnName(descriptor, k), v => v); IReadOnlyDictionary <string, object> whereHash; List <string> whereFilter; if (where == null) { // WHERE is derived from the instance's primary key var keys = Dialect.ResolveKeyNames(descriptor); whereFilter = keys.Intersect(hashKeysRewrite.Keys).ToList(); whereHash = hash; } else { // WHERE is explicitly provided var accessor = ReadAccessor.Create(where.GetType()); whereHash = ReadAccessorExtensions.AsReadOnlyDictionary(accessor, where); var whereHashKeysRewrite = whereHash.Keys.ToDictionary(k => Dialect.ResolveColumnName(descriptor, k), v => v); whereFilter = Dialect.ResolveColumnNames(descriptor).Intersect(whereHashKeysRewrite.Keys).ToList(); } var setFilter = set.Intersect(hashKeysRewrite.Keys).ToList(); return(Update(descriptor, setFilter, whereFilter, hash, whereHash)); }
private static Query Delete(IDataDescriptor descriptor, object instance) { var accessor = ReadAccessor.Create(instance); var whereHash = accessor.AsReadOnlyDictionary(instance); return(Delete(descriptor, whereHash)); }
public static IRoleStore <TRole> GetStore <TRole>(this RoleManager <TRole> roleManager) where TRole : class { var accessor = ReadAccessor.Create(typeof(RoleManager <TRole>)); var roleStore = accessor[roleManager, "Store"]; return(roleStore as IRoleStore <TRole>); }
private static string BuildTable <T>(this IReadOnlyList <T> rows, string @null, params string[] columnNames) { var accessor = ReadAccessor.Create(typeof(T), AccessorMemberTypes.Fields | AccessorMemberTypes.Properties, AccessorMemberScope.Public, out var members); var columns = members.ToArray(); var table = new string[rows.Count + 1, columnNames.Length]; for (var i = 0; i < table.GetLength(1); i++) { table[0, i] = columnNames[i]; } for (var i = 1; i < table.GetLength(0); i++) { for (var j = 0; j < table.GetLength(1); j++) { accessor.TryGetValue(rows[i - 1], columns[j].Name, out var value); table[i, j] = value?.ToString() ?? @null ?? "?"; } } return(RenderTable(table)); }
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) { var property = base.CreateProperty(member, memberSerialization); if (property.PropertyName == "Id") { property.ShouldDeserialize = instance => { // WARNING: // Azure inserts metadata into documents after all other properties, so this workaround // will only opt-in to deserialize "Id" if it hasn't been set yet; this gets around // the case where the mapped object's key is "Id", but it is a different type than "id" var accessor = ReadAccessor.Create(instance.GetType()); var value = accessor[instance, property.PropertyName]; var @default = property.PropertyType.IsValueType ? Activator.CreateInstance(property.PropertyType) : null; return(value == null && @default == null || value != null && value.Equals(@default)); } } ; return(property); } }
private static bool IsNotEmpty(MemberInfo member, object instance) { var accessor = ReadAccessor.Create(instance.GetType()); IEnumerable enumerable = null; switch (member.MemberType) { case MemberTypes.Property: case MemberTypes.Field: enumerable = accessor[instance, member.Name] as IEnumerable; break; case MemberTypes.All: case MemberTypes.Constructor: case MemberTypes.Custom: case MemberTypes.Event: case MemberTypes.Method: case MemberTypes.NestedType: case MemberTypes.TypeInfo: break; default: throw new ArgumentOutOfRangeException(); } return(enumerable == null || enumerable.GetEnumerator().MoveNext()); }
public static Query Update(IDataDescriptor descriptor, object instance) { var hash = ReadAccessor.Create(instance.GetType()).AsReadOnlyDictionary(instance); var setFilter = descriptor.Updated.Select(c => c.ColumnName).Intersect(hash.Keys).ToList(); var whereFilter = descriptor.Keys.Select(c => c.ColumnName).Intersect(hash.Keys).ToList(); return(Update(descriptor, setFilter, whereFilter, hash, hash)); }
private static void ThrowIfDisposed <TUser>(this RoleManager <TUser> roleManager) where TUser : class { var accessor = ReadAccessor.Create(typeof(RoleManager <TUser>)); var disposedField = accessor[roleManager, "_disposed"]; if (disposedField is bool disposed && disposed) { throw new ObjectDisposedException(roleManager.GetType().Name); } }
/// <summary> /// Provides an <see cref="IdentityResult" /> in a failed state, with errors. /// This prevents an allocation by forcing the error collection to an array. /// </summary> /// <param name="errors"></param> /// <returns></returns> public static IdentityResult Failed(ICollection <IdentityError> errors) { var read = ReadAccessor.Create(typeof(IdentityResult)); var write = WriteAccessor.Create(typeof(IdentityResult)); var result = new IdentityResult(); var list = read[result, "_errors"] as List <IdentityError>; list?.AddRange(errors); write[result, "Succeeded"] = false; return(result); }
public SqliteResourceDataService(IStringLocalizer <SqliteResourceDataService <T> > localizer, string filePath, int revision, ChangeLogBuilder changeLog, ILogger <SqliteResourceDataService <T> > logger) { _revision = revision; _changeLog = changeLog; _localizer = localizer; _logger = logger; _reads = ReadAccessor.Create(typeof(T), AccessorMemberTypes.Properties, AccessorMemberScope.Public, out _members); CreateIfNotExists(filePath); FilePath = filePath; }
public static object GetId(this object model) { if (model is IResource resource) { return(resource.Id); } var accessor = ReadAccessor.Create(model); Assert.True(accessor.TryGetValue(model, nameof(IResource.Id), out var id)); return(id); }
private static Query Select <T>(IDataDescriptor descriptor, dynamic data, List <string> columnFilter, List <Filter> filters, List <Projection> projections, Expression <Func <T, object> >[] orderBy) { var columns = columnFilter ?? Dialect.ResolveColumnNames(descriptor).ToList(); var sql = Dialect.Query(descriptor.Table, descriptor.Schema, columns, filters, projections, orderBy); IDictionary <string, object> whereHash = ReadAccessor.Create(data.GetType()).AsReadOnlyDictionary(data); var whereFilter = Dialect.ResolveColumnNames(descriptor).Intersect(whereHash.Keys).ToList(); var parameters = whereFilter.ToDictionary(key => $"{Dialect.Parameter}{key}", key => whereHash[key]); return(new Query(sql, parameters)); }
public static Query Insert(object instance, IDataDescriptor descriptor, bool returnKeys = false) { var columns = Dialect.ResolveColumnNames(descriptor, ColumnScope.Inserted).ToList(); var sql = Dialect.InsertInto(descriptor, Dialect.ResolveTableName(descriptor), descriptor.Schema, columns, returnKeys); var hash = ReadAccessor.Create(instance.GetType()).AsReadOnlyDictionary(instance); var hashKeysRewrite = hash.Keys.ToDictionary(k => Dialect.ResolveColumnName(descriptor, k), v => v); var keys = columns.Intersect(hashKeysRewrite.Keys); var parameters = keys.ToDictionary(key => $"{Dialect.Parameter}{key}", key => hash[hashKeysRewrite[key]]); return(new Query(sql, parameters)); }
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 Query Delete <T>(T instance) { var accessor = ReadAccessor.Create(instance); var descriptor = GetDescriptor <T>(); var where = new Dictionary <string, object>(); foreach (var key in descriptor.Keys) { if (accessor.TryGetValue(instance, key.Property.Name, out var value)) { where.Add(key.ColumnName, value); } } return(Delete(descriptor, where)); }
public static void Serialize <T>(this T subject, Stream stream) { var accessor = ReadAccessor.Create(typeof(T), AccessorMemberTypes.Properties, out var members); var buffer = Pool.Rent(4096); try { var offset = 0; var span = buffer.AsSpan(); foreach (var member in members) { if (!member.CanWrite) { continue; } var value = accessor[subject, member.Name]; switch (value) { case string v: span.WriteString(ref offset, v); break; case StringValues v: span.WriteString(ref offset, v); break; case int v: span.WriteInt32(ref offset, v); break; case bool v: span.WriteBoolean(ref offset, v); break; } } stream.Write(buffer, 0, offset); } finally { Pool.Return(buffer); } }
public override async void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options) { var reader = ReadAccessor.Create(value, AccessorMemberTypes.Properties, AccessorMemberScope.Public, out var members); writer.WriteStartObject(); foreach (var member in members) { if (!member.CanRead) { continue; } if (member.TryGetAttribute <ProtectedByPolicyAttribute>(out var attribute)) { var user = _http.ResolveCurrentPrincipal(); if (!user.Claims.Any()) { continue; } var result = await _authorization.AuthorizeAsync(user, value, attribute.PolicyName); if (result.Succeeded) { WriteNameAndValue(member); } } else { WriteNameAndValue(member); } } writer.WriteEndObject(); void WriteNameAndValue(AccessorMember member) { // key: var propertyName = options.PropertyNamingPolicy?.ConvertName(member.Name) ?? member.Name; writer.WritePropertyName(propertyName); // value (can be null): reader.TryGetValue(value, member.Name, out var item); JsonSerializer.Serialize(writer, item, options); } }