/// <summary>
/// Saves the updated entities into the actual database.
/// </summary>
/// <param name="dbContextFactory">
/// Factory for <see cref="DbContext" /> to save the updated entities into.
/// </param>
/// <param name="request">
/// The <see cref="SaveChangesRequest" /> object from the client containing the updated entities.
/// </param>
/// <returns>
/// The save operation result which can either be
/// a SaveChangesResult.Success or SaveChangesResult.Error.
/// </returns>
public SaveChangesResult SaveChanges(Func <DbContext> dbContextFactory, SaveChangesRequest request)
{
using (DbContext dbContext = dbContextFactory())
{
return(new SaveChangesHelper(dbContext, request).SaveChanges());
}
}
public virtual async Task <SaveChangesResult> SaveChangesAsync(SaveChangesRequest request, CancellationToken cancellationToken)
{
IWcfService channel = this.channelFactory.CreateChannel();
using ((IDisposable)channel)
{
return(await channel.ProcessSaveChangesRequestAsync(request));
}
}
public virtual SaveChangesResult SaveChanges(SaveChangesRequest request)
{
IWcfService channel = this.channelFactory.CreateChannel();
using ((IDisposable)channel)
{
return(channel.ProcessSaveChangesRequest(request));
}
}
public IHttpActionResult PostEmailerInformation(SaveChangesRequest request)
{
var identity = (ClaimsIdentity)User.Identity;
var id = int.Parse(identity.Claims.FirstOrDefault(c => c.Type == "Id").Value);
db.Users.Find(id).Message = request.Message;
db.Users.Find(id).Topic = request.Topic;
db.SaveChanges();
return(Ok());
}
public async Task <SaveChangesResult> SaveChangesAsync(SaveChangesRequest request, CancellationToken cancellationToken)
=> SimulateNetworkTransferJson(
await this.infoCarrierServer.SaveChangesAsync(
this.CreateDbContext,
SimulateNetworkTransferJson(request),
cancellationToken));
public SaveChangesResult SaveChanges(SaveChangesRequest request)
=> SimulateNetworkTransferJson(
this.infoCarrierServer.SaveChanges(
this.CreateDbContext,
SimulateNetworkTransferJson(request)));
public Task <SaveChangesResult> PostSaveChangesAsync([FromBody] SaveChangesRequest request) => this.infoCarrierServer.SaveChangesAsync(this.CreateDbContext, request);
/// <summary>
/// Asynchronously saves the updated entities into the actual database.
/// </summary>
/// <param name="dbContextFactory">
/// Factory for <see cref="DbContext" /> to save the updated entities into.
/// </param>
/// <param name="request">
/// The <see cref="SaveChangesRequest" /> object from the client containing the updated entities.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken" /> to observe while waiting for the task to complete.
/// </param>
/// <returns>
/// A task that represents the asynchronous operation.
/// The task result contains the save operation result which can either be
/// a SaveChangesResult.Success or SaveChangesResult.Error.
/// </returns>
public async Task <SaveChangesResult> SaveChangesAsync(Func <DbContext> dbContextFactory, SaveChangesRequest request, CancellationToken cancellationToken = default)
{
using (DbContext dbContext = dbContextFactory())
{
return(await new SaveChangesHelper(dbContext, request).SaveChangesAsync(cancellationToken));
}
}
public SaveChangesResult SaveChanges(SaveChangesRequest request)
{
return(this.client.Send(new SaveChanges(request)).Result);
}
=> this.SaveChangesAsync(request, default).Result; // Watchout: https://stackoverflow.com/a/35831540
public async Task <SaveChangesResult> SaveChangesAsync(SaveChangesRequest request, CancellationToken cancellationToken)
=> JsonConvert.DeserializeObject <SaveChangesResult>(
await this.CallApiAsync("SaveChanges", request, cancellationToken),
JsonSerializerSettings);
public SaveChangesResult SaveChanges(SaveChangesRequest request) => this.SaveChangesAsync(request, default).Result; // Watchout: https://stackoverflow.com/a/35831540
public override async Task <SaveChangesResult> SaveChangesAsync(SaveChangesRequest request, CancellationToken cancellationToken) => await Task.Run(() => this.SaveChanges(request), cancellationToken);
/// <summary>
/// Initializes a new instance of the <see cref="SaveChangesHelper" /> class.
/// </summary>
/// <param name="dbContext"> <see cref="DbContext" /> against which the requested query will be executed. </param>
/// <param name="request"> The <see cref="SaveChangesRequest" /> object from the client containing the updated entities. </param>
public SaveChangesHelper(DbContext dbContext, SaveChangesRequest request)
{
this.dbContext = dbContext;
var typeMap = this.dbContext.Model.GetEntityTypes().ToDictionary(x => x.DisplayName());
var stateManager = this.dbContext.GetService <IStateManager>();
var entityMaterializerSource = this.dbContext.GetService <IEntityMaterializerSource>();
// Materialize entities and add entries to dbContext
EntityEntry MaterializeAndTrackEntity(UpdateEntryDto dto)
{
IEntityType entityType = typeMap[dto.EntityTypeName];
object MaterializeEntity()
{
var valueBuffer = new ValueBuffer(dto.GetCurrentValues(entityType, request.Mapper));
var materializationContext = new MaterializationContext(valueBuffer, this.dbContext);
return(entityMaterializerSource.GetMaterializer(entityType).Invoke(materializationContext));
}
EntityEntry entry;
if (entityType.HasDefiningNavigation())
{
IKey key = entityType.DefiningEntityType.FindPrimaryKey();
object[] keyValues = dto.GetDelegatedIdentityKeys(request.Mapper, key);
// Here we assume that the owner entry is already present in the context
EntityEntry ownerEntry = stateManager.TryGetEntry(key, keyValues).ToEntityEntry();
ReferenceEntry referenceEntry = ownerEntry.Reference(entityType.DefiningNavigationName);
if (referenceEntry.CurrentValue == null)
{
referenceEntry.CurrentValue = MaterializeEntity();
}
entry = referenceEntry.TargetEntry;
}
else
{
entry = stateManager.GetOrCreateEntry(MaterializeEntity()).ToEntityEntry();
}
// Correlate properties of DTO and entry
var props = dto.JoinScalarProperties(entry, request.Mapper);
// Set Key properties
foreach (var p in props.Where(x => x.EfProperty.Metadata.IsKey()))
{
p.EfProperty.CurrentValue = p.CurrentValue;
if (p.EfProperty.Metadata.GetOriginalValueIndex() >= 0)
{
p.EfProperty.OriginalValue = p.OriginalValue;
}
}
// Set EntityState after PK values (temp or perm) are set.
// This will add entities to identity map.
entry.State = dto.EntityState;
// Set non key properties
foreach (var p in props.Where(x => !x.EfProperty.Metadata.IsKey()))
{
bool canSetCurrentValue =
p.EfProperty.Metadata.IsShadowProperty ||
p.EfProperty.Metadata.TryGetMemberInfo(forConstruction: false, forSet: true, out _, out _);
if (canSetCurrentValue)
{
p.EfProperty.CurrentValue = p.CurrentValue;
}
if (p.EfProperty.Metadata.GetOriginalValueIndex() >= 0 &&
p.EfProperty.OriginalValue != p.OriginalValue)
{
p.EfProperty.OriginalValue = p.OriginalValue;
}
if (canSetCurrentValue)
{
p.EfProperty.IsModified = p.DtoProperty.IsModified;
}
}
// Mark temporary property values
foreach (var p in props.Where(x => x.DtoProperty.IsTemporary))
{
p.EfProperty.IsTemporary = true;
}
return(entry);
}
request.SharedIdentityDataTransferObjects.ForEach(dto => MaterializeAndTrackEntity(dto));
var entries = request.DataTransferObjects.Select(MaterializeAndTrackEntity).ToList();
// Replace temporary PKs coming from client with generated values (e.g. HiLoSequence)
var valueGeneratorSelector = this.dbContext.GetService <IValueGeneratorSelector>();
foreach (EntityEntry entry in entries)
{
foreach (PropertyEntry tempPk in
entry.Properties.Where(p =>
p.IsTemporary &&
p.Metadata.IsKey() &&
p.Metadata.RequiresValueGenerator()).ToList())
{
ValueGenerator valueGenerator = valueGeneratorSelector.Select(tempPk.Metadata, entry.Metadata);
if (!valueGenerator.GeneratesTemporaryValues)
{
tempPk.CurrentValue = valueGenerator.Next(entry);
tempPk.IsTemporary = false;
}
}
}
this.Entries = entries.Select(e => e.GetInfrastructure()).ToList();
}
public SaveChangesResult ProcessSaveChangesRequest(SaveChangesRequest request) => this.infoCarrierServer.SaveChanges(this.CreateDbContext, request);
public async Task <SaveChangesResult> SaveChangesAsync(SaveChangesRequest request, CancellationToken cancellationToken)
{
return((await this.client.SendAsync(new SaveChanges(request), cancellationToken)).Result);
}
public Task <SaveChangesResult> ProcessSaveChangesRequestAsync(SaveChangesRequest request) => this.infoCarrierServer.SaveChangesAsync(this.CreateDbContext, request);
public SaveChanges(SaveChangesRequest request)
{
this.ToData(request);
}
