protected override IAsyncResult BeginSubmitCore(EntityChangeSet changeSet, AsyncCallback callback, object userState)
{
Assert.AreEqual(0, changeSet.AddedEntities.Count,
"Change set should not contained added entities.");
Assert.IsFalse(changeSet.IsEmpty,
"Change set should not be empty.");
Assert.AreEqual(1, changeSet.ModifiedEntities.Count,
"Change set should contain a single modified entity.");
Assert.AreEqual(0, changeSet.RemovedEntities.Count,
"Change set should not contained removed entities.");
ChangeSetEntry[] submitOperations = changeSet.GetChangeSetEntries().ToArray();
Assert.AreEqual(1, submitOperations.Length,
"A single submit operation is expected.");
MockUser userToSubmit = (MockUser)submitOperations[0].Entity;
MockUser userToReturn = new MockUser()
{
Name = userToSubmit.Name, Type = UserType.Saved
};
List <ChangeSetEntry> submitOperationsToReturn = new List <ChangeSetEntry>();
submitOperationsToReturn.Add(new ChangeSetEntry(userToReturn, submitOperations[0].Id, submitOperations[0].Operation));
this.Result = new AdcSubmitAsyncResult(changeSet, submitOperationsToReturn, userToReturn, callback, userState);
return(this.Result);
}
protected override Task <SubmitCompletedResult> SubmitAsyncCore(EntityChangeSet changeSet, CancellationToken cancellationToken)
{
IEnumerable <ChangeSetEntry> submitOperations = changeSet.GetChangeSetEntries();
// perform mock submit operations
SubmitCompletedResult submitResults = new SubmitCompletedResult(changeSet, submitOperations);
return(TaskHelper.FromResult(submitResults));
}
protected override IAsyncResult BeginSubmitCore(EntityChangeSet changeSet, AsyncCallback callback, object userState)
{
IEnumerable <ChangeSetEntry> submitOperations = changeSet.GetChangeSetEntries();
MockAsyncResult ar = new MockAsyncResult(null, userState, new object[] { changeSet, submitOperations, userState });
// perform mock submit operations
callback.Invoke(ar);
return(ar);
}
protected override async Task <SubmitCompletedResult> SubmitAsyncCore(EntityChangeSet changeSet, CancellationToken cancellationToken)
{
Assert.AreEqual(0, changeSet.AddedEntities.Count,
"Change set should not contained added entities.");
Assert.IsFalse(changeSet.IsEmpty,
"Change set should not be empty.");
Assert.AreEqual(1, changeSet.ModifiedEntities.Count,
"Change set should contain a single modified entity.");
Assert.AreEqual(0, changeSet.RemovedEntities.Count,
"Change set should not contained removed entities.");
ChangeSetEntry[] submitOperations = changeSet.GetChangeSetEntries().ToArray();
Assert.AreEqual(1, submitOperations.Length,
"A single submit operation is expected.");
cancellationToken.Register(() => this.CancellationRequested = true);
await _callbackDelay.WaitAsync(cancellationToken);
// Maybe assert expected type
if (this.Error != null)
{
throw this.Error;
}
this.Submitted = true;
MockUser userToSubmit = (MockUser)submitOperations[0].Entity;
MockUser userToReturn = new MockUser()
{
Name = userToSubmit.Name, Type = UserType.Saved
};
List <ChangeSetEntry> submitOperationsToReturn = new List <ChangeSetEntry>();
submitOperationsToReturn.Add(new ChangeSetEntry(userToReturn, submitOperations[0].Id, submitOperations[0].Operation));
var operation = submitOperationsToReturn.First();
operation.Entity = userToReturn;
operation.ConflictMembers = this.SubmitConflictMembers;
operation.ValidationErrors = this.SubmitValidationErrors;
return(new SubmitCompletedResult(changeSet, submitOperationsToReturn));
}
/// <summary>
/// Method called by the framework to asynchronously process the specified <see cref="T:OpenRiaServices.DomainServices.Client.EntityChangeSet" />.
/// Overrides should not call the base method.
/// </summary>
/// <param name="changeSet">The <see cref="T:OpenRiaServices.DomainServices.Client.EntityChangeSet" /> to submit to the DomainService.</param>
/// <param name="callback">The callback to invoke when the submit has been executed.</param>
/// <param name="userState">Optional user state associated with this operation.</param>
/// <returns>
/// An asynchronous result that identifies this submit request.
/// </returns>
protected override async Task <SubmitCompletedResult> SubmitCoreAsync(EntityChangeSet changeSet, CancellationToken cancellationToken)
{
const string operationName = "SubmitChanges";
var entries = changeSet.GetChangeSetEntries().ToList();
var parameters = new Dictionary <string, object>()
{
{ "changeSet", entries }
};
var response = await ExecuteRequestAsync(operationName, hasSideEffects : true, parameters : parameters, queryOptions : null, cancellationToken : cancellationToken)
.ConfigureAwait(false);
try
{
var returnValue = (IEnumerable <ChangeSetEntry>)ReadResponse(response, operationName, typeof(IEnumerable <ChangeSetEntry>));
return(new SubmitCompletedResult(changeSet, returnValue ?? Enumerable.Empty <ChangeSetEntry>()));
}
catch (FaultException <DomainServiceFault> fe)
{
throw GetExceptionFromServiceFault(fe.Detail);
}
}
protected override Task <SubmitCompletedResult> SubmitAsyncCore(EntityChangeSet changeSet, CancellationToken cancellationToken)
{
return(Task.FromResult(new SubmitCompletedResult(changeSet, changeSet.GetChangeSetEntries())));
}
public void RoundtripOriginalOnClass_VerifyPartialObjects()
{
TestDomainServices.TestProvider_Scenarios ctxt = new TestDomainServices.TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
TestDomainServices.RoundtripOriginal_TestEntity2 entity = new TestDomainServices.RoundtripOriginal_TestEntity2 {
ID = 1, RoundtrippedMember1 = 1, RoundtrippedMember2 = 1
};
ctxt.EntityContainer.LoadEntities(new Entity[] { entity });
entity.RoundtrippedMember1 += 1;
entity.RoundtrippedMember2 += 2;
EntityChangeSet cs = ctxt.EntityContainer.GetChanges();
TestDomainServices.RoundtripOriginal_TestEntity2 original = (TestDomainServices.RoundtripOriginal_TestEntity2)cs.GetChangeSetEntries().First().OriginalEntity;
// verify members with roundtrip have the original value
Assert.AreEqual(2, entity.RoundtrippedMember1);
Assert.AreEqual(3, entity.RoundtrippedMember2);
Assert.AreEqual(1, original.RoundtrippedMember1);
Assert.AreEqual(1, original.RoundtrippedMember2);
}
public void RoundtripOriginal_VerifyPartialObjects()
{
TestDomainServices.TestProvider_Scenarios ctxt = new TestDomainServices.TestProvider_Scenarios(TestURIs.TestProvider_Scenarios);
TestDomainServices.RoundtripOriginal_TestEntity entity = new TestDomainServices.RoundtripOriginal_TestEntity {
ID = 1, RoundtrippedMember = 1, NonRoundtrippedMember = 1
};
ctxt.EntityContainer.LoadEntities(new Entity[] { entity });
// make a change
entity.NonRoundtrippedMember += 1;
EntityChangeSet cs = ctxt.EntityContainer.GetChanges();
TestDomainServices.RoundtripOriginal_TestEntity original = (TestDomainServices.RoundtripOriginal_TestEntity)cs.GetChangeSetEntries().First().OriginalEntity;
// verify member with roundtrip has an original value
Assert.AreEqual(1, entity.RoundtrippedMember);
// verify member without roundtrip doesn't have it's original value set
Assert.AreEqual(0, original.NonRoundtrippedMember);
}
/// <summary>
/// Method called by the framework to asynchronously process the specified <see cref="T:OpenRiaServices.DomainServices.Client.EntityChangeSet" />.
/// Overrides should not call the base method.
/// </summary>
/// <param name="changeSet">The <see cref="T:OpenRiaServices.DomainServices.Client.EntityChangeSet" /> to submit to the DomainService.</param>
/// <param name="callback">The callback to invoke when the submit has been executed.</param>
/// <param name="userState">Optional user state associated with this operation.</param>
/// <returns>
/// An asynchronous result that identifies this submit request.
/// </returns>
protected override IAsyncResult BeginSubmitCore(EntityChangeSet changeSet, AsyncCallback callback, object userState)
{
var result = WebApiDomainClientAsyncResult.CreateSubmitResult(this, changeSet, changeSet.GetChangeSetEntries().ToList(), callback, userState);
var parameters = new Dictionary<string, object>() {
{"changeSet", result.ChangeSetEntries}
};
return BeginWebRequest(result, hasSideEffects: true, parameters: parameters, queryOptions: null);
}
protected override IAsyncResult BeginSubmitCore(EntityChangeSet changeSet, AsyncCallback callback, object userState)
{
IEnumerable<ChangeSetEntry> submitOperations = changeSet.GetChangeSetEntries();
MockAsyncResult ar = new MockAsyncResult(null, userState, new object[] { changeSet, submitOperations, userState });
// perform mock submit operations
callback.Invoke(ar);
return ar;
}
protected override IAsyncResult BeginSubmitCore(EntityChangeSet changeSet, AsyncCallback callback, object userState)
{
Assert.AreEqual(0, changeSet.AddedEntities.Count,
"Change set should not contained added entities.");
Assert.IsFalse(changeSet.IsEmpty,
"Change set should not be empty.");
Assert.AreEqual(1, changeSet.ModifiedEntities.Count,
"Change set should contain a single modified entity.");
Assert.AreEqual(0, changeSet.RemovedEntities.Count,
"Change set should not contained removed entities.");
ChangeSetEntry[] submitOperations = changeSet.GetChangeSetEntries().ToArray();
Assert.AreEqual(1, submitOperations.Length,
"A single submit operation is expected.");
MockUser userToSubmit = (MockUser)submitOperations[0].Entity;
MockUser userToReturn = new MockUser() { Name = userToSubmit.Name, Type = UserType.Saved };
List<ChangeSetEntry> submitOperationsToReturn = new List<ChangeSetEntry>();
submitOperationsToReturn.Add(new ChangeSetEntry(userToReturn, submitOperations[0].Id, submitOperations[0].Operation));
this.Result = new AdcSubmitAsyncResult(changeSet, submitOperationsToReturn, userToReturn, callback, userState);
return this.Result;
}
protected override Task <SubmitCompletedResult> SubmitAsyncCore(EntityChangeSet changeSet, CancellationToken cancellationToken)
{
Assert.AreEqual(0, changeSet.AddedEntities.Count,
"Change set should not contained added entities.");
Assert.IsFalse(changeSet.IsEmpty,
"Change set should not be empty.");
Assert.AreEqual(1, changeSet.ModifiedEntities.Count,
"Change set should contain a single modified entity.");
Assert.AreEqual(0, changeSet.RemovedEntities.Count,
"Change set should not contained removed entities.");
ChangeSetEntry[] submitOperations = changeSet.GetChangeSetEntries().ToArray();
Assert.AreEqual(1, submitOperations.Length,
"A single submit operation is expected.");
MockUser userToSubmit = (MockUser)submitOperations[0].Entity;
MockUser userToReturn = new MockUser()
{
Name = userToSubmit.Name, Type = UserType.Saved
};
List <ChangeSetEntry> submitOperationsToReturn = new List <ChangeSetEntry>();
submitOperationsToReturn.Add(new ChangeSetEntry(userToReturn, submitOperations[0].Id, submitOperations[0].Operation));
AsyncCallback completeCallback = (asyncResult) =>
{
var tcs = (TaskCompletionSource <SubmitCompletedResult>)asyncResult.AsyncState;
// Maybe assert expected type
if (this.Error != null)
{
tcs.SetException(this.Error);
}
else if (this.CancellationRequested)
{
tcs.SetCanceled();
}
else
{
this.Submitted = true;
AdcSubmitAsyncResult result = asyncResult as AdcSubmitAsyncResult;
result.SubmitOperations.First().Entity = result.User;
result.Submit(this.SubmitConflictMembers, this.SubmitErrors, this.SubmitValidationErrors);
SubmitCompletedResult results = new SubmitCompletedResult(result.ChangeSet, result.SubmitOperations);
tcs.SetResult(results);
}
};
var taskCompletionSource = new TaskCompletionSource <SubmitCompletedResult>();
this.Result = new AdcSubmitAsyncResult(changeSet, submitOperationsToReturn, userToReturn, completeCallback, taskCompletionSource);
cancellationToken.Register(res =>
{
this.CancellationRequested = true;
}, this.Result);
return(taskCompletionSource.Task);
}
