public ArangoXmlRepository(IServiceProvider services, ILoggerFactory loggerFactory,
string database, string collection, ArangoContext context)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_logger = loggerFactory.CreateLogger <ArangoXmlRepository>();
_services = services ?? throw new ArgumentNullException(nameof(services));
_database = database;
_collection = collection;
_context = context ?? services.GetRequiredService <ArangoContext>();
try
{
if (!_context.Database.ExistAsync(_database).Result)
{
_context.Database.CreateAsync(_database).Wait();
}
var collections = _context.Collection.ListAsync(_database).Result;
if (!collections.Contains(collection))
{
_context.Collection.CreateAsync(_database, _collection, ArangoCollectionType.Document).Wait();
}
}
catch (Exception e)
{
var logger = _logger;
logger?.LogError(e, e.Message);
}
}
public ArangoSerilogSink(
ArangoContext arango,
string database = "logs",
string collection = "logs",
int batchPostingLimit = DefaultBatchPostingLimit,
TimeSpan?period = null)
: base(batchPostingLimit, period ?? DefaultPeriod)
{
_arango = arango;
_database = database;
_collection = collection;
try
{
if (!arango.ExistDatabaseAsync(_database).Result)
{
_arango.CreateDatabaseAsync(_database).Wait();
_arango.CreateCollectionAsync(_database, _collection, ArangoCollectionType.Document).Wait();
}
}
catch (Exception)
{
//
}
}
public override async Task InitializeAsync()
{
Arango =
new ArangoContext(UniqueTestRealm(),
new ArangoConfiguration
{
QueryProfile = (query, bindVars, stats) =>
{
var boundQuery = query;
foreach (var p in bindVars.OrderByDescending(x => x.Key.Length))
{
boundQuery = boundQuery.Replace("@" + p.Key, JsonConvert.SerializeObject(p.Value));
}
_output.WriteLine(
$"{boundQuery}\n{JsonConvert.SerializeObject(stats, Formatting.Indented)}");
}
});
await Arango.Database.CreateAsync("test");
}
public override async Task InitializeAsync()
{
Arango = new ArangoContext(UniqueTestRealm());
await Arango.Database.CreateAsync(D);
await Arango.Collection.CreateAsync(D, nameof(Client), ArangoCollectionType.Document);
await Arango.Collection.CreateAsync(D, nameof(Project), ArangoCollectionType.Document);
await Arango.Collection.CreateAsync(D, nameof(Activity), ArangoCollectionType.Document);
await Arango.Document.CreateManyAsync(D, nameof(Client), new List <Client>
{
new()
{
Key = "CA",
Name = "Client A"
},
new()
{
Key = "CB",
Name = "Client B"
}
});
public ArangoQueryableContext(ArangoContext arango, ArangoHandle handle, string collection)
{
Provider = new ArangoProvider(arango, handle, collection);
Expression = Expression.Constant(this);
}
/// <summary>
/// Executes transformed query
/// </summary>
public async Task <DxLoadResult> ExecuteAsync <T>(ArangoContext arango,
ArangoHandle handle,
string collection,
CancellationToken cancellationToken = default)
where T : new()
{
if (!_isTransformed)
{
throw new Exception("call transform first");
}
var queryBuilder = new StringBuilder();
if (!string.IsNullOrWhiteSpace(_settings.Preamble))
{
queryBuilder.AppendLine(_settings.Preamble);
}
queryBuilder.AppendLine($"FOR {_settings.IteratorVar} IN {collection}");
queryBuilder.AppendLine("FILTER " + FilterExpression);
if (_settings.Filter != null)
{
queryBuilder.AppendLine(" && " + _settings.Filter);
}
if (HasGrouping)
{
queryBuilder.AppendLine(AggregateExpression);
}
else
{
Parameter.TryAdd("SKIP", Skip);
Parameter.TryAdd("TAKE", Take);
queryBuilder.AppendLine(SortExpression);
queryBuilder.AppendLine("LIMIT @SKIP, @TAKE");
queryBuilder.AppendLine($"RETURN {_settings.Projection ?? _settings.IteratorVar}");
}
var query = queryBuilder.ToString();
if (HasGrouping)
{
var res = await arango.QueryAsync <JObject>(handle, query, Parameter,
cancellationToken : cancellationToken);
return(new DxLoadResult
{
Data = BuildGrouping(this, res)
});
}
else
{
var res = await arango.QueryAsync <T>(handle, query, Parameter,
fullCount : _loadOption.RequireTotalCount, cancellationToken : cancellationToken);
decimal?[] summary = null;
if (_loadOption.TotalSummary?.Any() == true)
{
var summaryQueryBuilder = new StringBuilder();
if (!string.IsNullOrWhiteSpace(_settings.Preamble))
{
summaryQueryBuilder.AppendLine(_settings.Preamble);
}
summaryQueryBuilder.AppendLine($"FOR {_settings.IteratorVar} IN {collection}");
summaryQueryBuilder.AppendLine("FILTER " + FilterExpression);
if (_settings.Filter != null)
{
summaryQueryBuilder.AppendLine(" && " + _settings.Filter);
}
summaryQueryBuilder.AppendLine(AggregateExpression);
// TODO: refactor
Parameter.Remove("SKIP");
Parameter.Remove("TAKE");
var summaryQuery = summaryQueryBuilder.ToString();
var summaryResult = await arango.QueryAsync <JObject>(handle, summaryQuery, Parameter,
cancellationToken : cancellationToken);
summary = summaryResult.SingleOrDefault()?.PropertyValues()
.Select(x => x.Value <decimal?>()).Skip(1).ToArray();
}
return(new DxLoadResult
{
Data = res,
Summary = summary,
TotalCount = res.FullCount ?? -1
});
}
}
public static IQueryable <T> AsQueryable <T>(this ArangoContext arango, ArangoHandle db, string collection = null)
{
return(new ArangoQueryableContext <T>(arango, db, collection ?? typeof(T).Name));
}
public ArangoProvider(ArangoContext arango, ArangoHandle handle, string collection)
{
_arango = arango;
_handle = handle;
_collection = collection;
}
/// <summary>
/// Stores DataProtection keys in ArangoDB
/// </summary>
/// <param name="database">Name of the database suffix</param>
/// <param name="collection">Name of the collection</param>
/// <param name="context">Arango context (if not supplied it will be tried via dependency injection)</param>
public static IDataProtectionBuilder PersistKeysToArangoDB(this IDataProtectionBuilder builder,
string database = "dataprotection", string collection = "keys", ArangoContext context = null)
{
builder.Services.AddSingleton <IConfigureOptions <KeyManagementOptions> >(services =>
{
var loggerFactory = services.GetService <ILoggerFactory>() ?? NullLoggerFactory.Instance;
return(new ConfigureOptions <KeyManagementOptions>(options =>
{
options.XmlRepository = new ArangoXmlRepository(services, loggerFactory, database, collection, context);
}));
});
return(builder);
}
