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 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 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>();
}
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);
}
}
private ValidationResult ValidateSiblings(ValidationContext validationContext, AccessorMembers members,
ITypeReadAccessor accessor, bool present)
{
var provided = Pooling.HashSetPool.Get();
var all = Pooling.HashSetPool.Get();
try
{
foreach (var member in members)
{
if (member.Name == validationContext.MemberName ||
member.MemberType != AccessorMemberType.Property &&
member.MemberType != AccessorMemberType.Field ||
!member.CanRead || !member.TryGetAttribute <RequiredOnlyOneAttribute>(out var attribute))
{
continue;
}
accessor.TryGetValue(validationContext.ObjectInstance, member.Name, out var memberValue);
var memberContext =
new ValidationContext(validationContext.ObjectInstance)
{
MemberName = member.Name
};
all.Add(memberContext.DisplayName);
var result = attribute.BaseIsValid(memberValue, memberContext);
if (result == null)
{
provided.Add(memberContext.DisplayName);
}
}
switch (provided.Count)
{
case 0 when present:
case 1 when !present:
return(ValidationResult.Success);
case 0:
all.Add(validationContext.DisplayName);
return(new ValidationResult(string.Format(CultureInfo.CurrentCulture, ErrorMessageString,
string.Join(", ", all.OrderBy(x => x)))));
default:
provided.Add(validationContext.DisplayName);
return(new ValidationResult(string.Format(CultureInfo.CurrentCulture, MoreThanOneErrorMessage,
string.Join(", ", provided.OrderBy(x => x)))));
}
}
finally
{
Pooling.HashSetPool.Return(provided);
Pooling.HashSetPool.Return(all);
}
}
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 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 PropertyAccessor(ITypeReadAccessor reads, ITypeWriteAccessor writes, Type type, string name)
{
Type = type;
Name = name;
_reads = reads;
_writes = writes;
var members = AccessorMembers.Create(type);
Info = members.PropertyInfo.SingleOrDefault(m => m.Name == name);
var member = members.SingleOrDefault(p => p.Name == name);
if (member == null)
{
return;
}
_member = member;
}
public static Query Update(IDataDescriptor descriptor, dynamic set, dynamic where = null)
{
ITypeReadAccessor setAccessor = ReadAccessor.Create(set.GetType());
IReadOnlyDictionary <string, object> setHash = ReadAccessorExtensions.AsReadOnlyDictionary(setAccessor, set);
var setFilter = descriptor.Updated.Select(c => c.ColumnName).Intersect(setHash.Keys).ToList();
IReadOnlyDictionary <string, object> whereHash = null;
if (where != null)
{
ITypeReadAccessor whereAccessor = ReadAccessor.Create(where.GetType());
whereHash = ReadAccessorExtensions.AsReadOnlyDictionary(whereAccessor, where);
}
var whereFilter = Dialect.ResolveColumnNames(descriptor);
if (whereHash != null)
{
whereFilter = whereFilter.Intersect(whereHash.Keys);
}
return(Update(descriptor, setFilter, whereFilter.ToList(), setHash, whereHash));
}
public JsonDeltaConverter()
{
_reader = ReadAccessor.Create(typeof(T), AccessorMemberTypes.Properties, AccessorMemberScope.Public, out _members);
_writer = WriteAccessor.Create(typeof(T), AccessorMemberTypes.Properties, AccessorMemberScope.Public);
}
public static Dictionary <string, object> InsertSql <T>(T resource, string resourceName, ITypeReadAccessor reads,
AccessorMembers members, int revision, long?sequence, bool deleted, out string sql)
{
if (resource == null)
{
throw new NullReferenceException();
}
var hash = new Dictionary <string, object> {
{ "Sequence", sequence ! }
};
sql = Pooling.StringBuilderPool.Scoped(sb =>
{
var fields = members.GetValueTypeFields();
sb.Append("INSERT INTO '");
sb.Append(resourceName);
sb.Append("_V");
sb.Append(revision);
sb.Append("' (");
for (var i = 0; i < fields.Length; i++)
{
if (i != 0)
{
sb.Append(", ");
}
var column = fields[i];
sb.Append("\"");
sb.Append(column.Name);
sb.Append("\"");
}
if (deleted)
{
sb.Append(", \"IsDeleted\"");
}
sb.Append(", \"Sequence\") VALUES (");
for (var i = 0; i < fields.Length; i++)
{
if (i != 0)
{
sb.Append(", ");
}
var column = fields[i];
sb.Append(":");
sb.Append(column.Name);
}
if (deleted)
{
sb.Append(", 1");
}
sb.Append(", :Sequence)");
foreach (var member in fields)
{
if (!member.CanRead)
{
continue;
}
if (reads.TryGetValue(resource, member.Name, out var value))
{
hash.Add(member.Name, value);
}
}
});
return(hash);
}
