public async Task DeleteHardAsync <T>(IDataStoreWriteOperation <T> aggregateHardDeleted) where T : class, IAggregate, new()
{
var docLink = CreateDocumentSelfLinkFromId(aggregateHardDeleted.Model.id);
var result = await DocumentDbUtils.ExecuteWithRetries(() => this.documentClient.DeleteDocumentAsync(docLink)).ConfigureAwait(false);
aggregateHardDeleted.StateOperationCost = result.RequestCharge;
}
public Task UpdateAsync <T>(IDataStoreWriteOperation <T> aggregateUpdated) where T : class, IAggregate, new()
{
var toUpdate = Aggregates.Single(x => x.id == aggregateUpdated.Model.id);
aggregateUpdated.Model.CopyProperties(toUpdate);
return(Task.CompletedTask);
}
public async Task AddAsync <T>(IDataStoreWriteOperation <T> aggregateAdded) where T : class, IAggregate, new()
{
using (IAsyncDocumentSession session = store.OpenAsyncSession())
{
string id = aggregateAdded.Model.id.ToString();
await session.StoreAsync(aggregateAdded.Model, id).ConfigureAwait(false);
await session.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task UpdateAsync <T>(IDataStoreWriteOperation <T> aggregateUpdated) where T : class, IAggregate, new()
{
using (IAsyncDocumentSession session = store.OpenAsyncSession())
{
T aggregate = await session.LoadAsync <T>(aggregateUpdated.Model.id.ToString()).ConfigureAwait(false);
aggregateUpdated.Model.CopyProperties(aggregate);
await session.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task DeleteHardAsync <T>(IDataStoreWriteOperation <T> aggregateHardDeleted) where T : class, IAggregate, new()
{
using (IAsyncDocumentSession session = store.OpenAsyncSession())
{
T aggregate = await session.LoadAsync <T>(aggregateHardDeleted.Model.id.ToString());
await Task.Run(() => session.Delete <T>(aggregate));
await session.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task DeleteHardAsync <T>(IDataStoreWriteOperation <T> aggregateHardDeleted) where T : class, IAggregate, new()
{
using (var con = this.clientFactory.OpenClient())
{
using (var command = new SqlCommand($"DELETE FROM {this.settings.TableName} WHERE AggregateId = CONVERT(uniqueidentifier, @AggregateId)", con))
{
command.Parameters.Add(new SqlParameter("AggregateId", aggregateHardDeleted.Model.id));
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
}
}
}
public Task DeleteSoftAsync <T>(IDataStoreWriteOperation <T> aggregateSoftDeleted) where T : class, IAggregate, new()
{
var aggregate = Aggregates.Where(x => x.schema == typeof(T).FullName).Cast <T>().Single(a => a.id == aggregateSoftDeleted.Model.id);
var now = DateTime.UtcNow;
aggregate.Active = false;
aggregate.Modified = now;
aggregate.ModifiedAsMillisecondsEpochTime = now.ConvertToMillisecondsEpochTime();
return(Task.CompletedTask);
}
public async Task AddAsync <T>(IDataStoreWriteOperation <T> aggregateAdded) where T : class, IAggregate, new()
{
if (aggregateAdded == null || aggregateAdded.Model == null)
{
throw new ArgumentNullException(nameof(aggregateAdded));
}
var result = await DocumentDbUtils
.ExecuteWithRetries(() => this.documentClient.CreateDocumentAsync(this.config.CollectionSelfLink(), aggregateAdded.Model))
.ConfigureAwait(false);
aggregateAdded.StateOperationCost = result.RequestCharge;
}
public async Task DeleteSoftAsync <T>(IDataStoreWriteOperation <T> aggregateSoftDeleted) where T : class, IAggregate, new()
{
using (IAsyncDocumentSession session = store.OpenAsyncSession())
{
T aggregate = await session.LoadAsync <T>(aggregateSoftDeleted.Model.id.ToString());
var now = DateTime.UtcNow;
aggregateSoftDeleted.Model.Modified = now;
aggregateSoftDeleted.Model.ModifiedAsMillisecondsEpochTime = now.ConvertToMillisecondsEpochTime();
aggregateSoftDeleted.Model.Active = false;
aggregateSoftDeleted.Model.CopyProperties(aggregate);
await session.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task UpdateAsync <T>(IDataStoreWriteOperation <T> aggregateUpdated) where T : class, IAggregate, new()
{
using (var connection = this.clientFactory.OpenClient())
{
using (var command = new SqlCommand(
$"UPDATE {this.settings.TableName} SET Json = @Json WHERE AggregateId = CONVERT(uniqueidentifier, @AggregateId)",
connection))
{
command.Parameters.Add(new SqlParameter("AggregateId", aggregateUpdated.Model.id));
var json = JsonConvert.SerializeObject(aggregateUpdated.Model);
command.Parameters.Add(new SqlParameter("Json", json));
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
}
}
}
public async Task DeleteSoftAsync <T>(IDataStoreWriteOperation <T> aggregateSoftDeleted) where T : class, IAggregate, new()
{
//HACK: this call inside the doc repository is effectively duplicate [see callers]
//and causes us to miss this query when profiling, arguably its cheap, but still
//if I can determine how to create an Azure Document from T we can ditch it.
var document = await GetItemAsync(new AggregateQueriedByIdOperation(nameof(DeleteSoftAsync), aggregateSoftDeleted.Model.id, typeof(T)))
.ConfigureAwait(false);
var now = DateTime.UtcNow;
document.SetPropertyValue(nameof(IAggregate.Active), false);
document.SetPropertyValue(nameof(IAggregate.Modified), now);
document.SetPropertyValue(nameof(IAggregate.ModifiedAsMillisecondsEpochTime), now.ConvertToMillisecondsEpochTime());
var result = await DocumentDbUtils.ExecuteWithRetries(() => this.documentClient.ReplaceDocumentAsync(document.SelfLink, document)).ConfigureAwait(false);
aggregateSoftDeleted.StateOperationCost = result.RequestCharge;
}
public async Task AddAsync <T>(IDataStoreWriteOperation <T> aggregateAdded) where T : class, IAggregate, new()
{
using (var con = this.clientFactory.OpenClient())
{
using (var command = new SqlCommand(
$"INSERT INTO {this.settings.TableName} ([AggregateId], [Schema], [Json]) VALUES(Convert(uniqueidentifier, @AggregateId), @Schema, @Json)",
con))
{
command.Parameters.Add(new SqlParameter("AggregateId", aggregateAdded.Model.id));
command.Parameters.Add(new SqlParameter("Schema", aggregateAdded.Model.schema));
var json = JsonConvert.SerializeObject(aggregateAdded.Model);
command.Parameters.Add(new SqlParameter("Json", json));
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
}
}
}
public async Task DeleteSoftAsync <T>(IDataStoreWriteOperation <T> aggregateSoftDeleted) where T : class, IAggregate, new()
{
using (var connection = this.clientFactory.OpenClient())
{
using (var command = new SqlCommand(
$"UPDATE {this.settings.TableName} SET Json = @Json WHERE AggregateId = CONVERT(uniqueidentifier, @AggregateId)",
connection))
{
command.Parameters.Add(new SqlParameter("AggregateId", aggregateSoftDeleted.Model.id));
var now = DateTime.UtcNow;
aggregateSoftDeleted.Model.Modified = now;
aggregateSoftDeleted.Model.ModifiedAsMillisecondsEpochTime = now.ConvertToMillisecondsEpochTime();
aggregateSoftDeleted.Model.Active = false;
var json = JsonConvert.SerializeObject(aggregateSoftDeleted.Model);
command.Parameters.Add(new SqlParameter("Json", json));
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
}
}
}
public Task DeleteHardAsync <T>(IDataStoreWriteOperation <T> aggregateHardDeleted) where T : class, IAggregate, new()
{
Aggregates.RemoveAll(a => a.id == aggregateHardDeleted.Model.id);
return(Task.CompletedTask);
}
public Task AddAsync <T>(IDataStoreWriteOperation <T> aggregateAdded) where T : class, IAggregate, new()
{
Aggregates.Add(aggregateAdded.Model);
return(Task.CompletedTask);
}
