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