protected async override ValueTask <object> InvokeCoreAsync(DomainService instance, object[] inputs, bool disableStackTraces)
{
ServiceInvokeResult invokeResult;
try
{
InvokeDescription invokeDescription = new InvokeDescription(this.operation, inputs);
invokeResult = await instance.InvokeAsync(invokeDescription, CancellationToken.None).ConfigureAwait(false);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw ServiceUtility.CreateFaultException(ex, disableStackTraces);
}
if (invokeResult.HasValidationErrors)
{
throw ServiceUtility.CreateFaultException(invokeResult.ValidationErrors, disableStackTraces);
}
else
{
return(invokeResult.Result);
}
}
/// <summary>
/// Derived classes override this method to provide custom invocation behavior.
/// </summary>
/// <param name="instance">Instance to invoke the invoker against.</param>
/// <param name="inputs">Input parameters post conversion.</param>
/// <param name="outputs">Optional out parameters.</param>
/// <returns>Result of invocation.</returns>
protected override object InvokeCore(object instance, object[] inputs, out object[] outputs)
{
outputs = ServiceUtils.EmptyObjectArray;
IEnumerable <ValidationResult> validationErrors;
object result;
try
{
InvokeDescription description = new InvokeDescription(this.operation, inputs);
result = ((DomainService)instance).Invoke(description, out validationErrors);
}
catch (UnauthorizedAccessException ex)
{
throw new DomainDataServiceException((int)System.Net.HttpStatusCode.Unauthorized, ex.Message, ex);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
else
{
throw new DomainDataServiceException(Resource.DomainDataService_General_Error, ex);
}
}
DomainDataServiceException.HandleValidationErrors(validationErrors);
return(result);
}
/// <summary>
/// Derived classes override this method to provide custom invocation behavior.
/// </summary>
/// <param name="instance">Instance to invoke the invoker against.</param>
/// <param name="inputs">Input parameters post conversion.</param>
/// <returns>Result of invocation.</returns>
protected override async ValueTask <object> InvokeCoreAsync(object instance, object[] inputs)
{
ServiceInvokeResult invokeResult;
try
{
InvokeDescription description = new InvokeDescription(this.operation, inputs);
invokeResult = await((DomainService)instance).InvokeAsync(description, CancellationToken.None).ConfigureAwait(false);
}
catch (UnauthorizedAccessException ex)
{
throw new DomainDataServiceException((int)System.Net.HttpStatusCode.Unauthorized, ex.Message, ex);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
else
{
throw new DomainDataServiceException(Resource.DomainDataService_General_Error, ex);
}
}
// This will throw if there are any validation erros
DomainDataServiceException.HandleValidationErrors(invokeResult.ValidationErrors);
return(invokeResult.Result);
}
protected override object InvokeCore(object instance, object[] inputs, out object[] outputs)
{
outputs = ServiceUtility.EmptyObjectArray;
IEnumerable <ValidationResult> validationErrors;
object result;
try
{
InvokeDescription invokeDescription = new InvokeDescription(this.operation, inputs);
result = ((DomainService)instance).Invoke(invokeDescription, out validationErrors);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw ServiceUtility.CreateFaultException(ex);
}
if (validationErrors != null && validationErrors.Any())
{
throw ServiceUtility.CreateFaultException(validationErrors);
}
return(result);
}
public void DomainService_InvalidOperationType()
{
TestDomainServices.EF.Northwind nw = new TestDomainServices.EF.Northwind();
DomainServiceContext dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew")
{
IsAuthenticated = true
}), DomainOperationType.Submit);
nw.Initialize(dsc);
IEnumerable <ValidationResult> validationResults = null;
int totalCount;
DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(TestDomainServices.EF.Northwind));
DomainOperationEntry entry = dsd.DomainOperationEntries.First(p => p.Operation == DomainOperation.Query);
QueryDescription qd = new QueryDescription(entry);
ExceptionHelper.ExpectException <InvalidOperationException>(delegate
{
nw.Query(qd, out validationResults, out totalCount);
}, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Submit, DomainOperationType.Query));
InvokeDescription id = new InvokeDescription(entry, null);
ExceptionHelper.ExpectException <InvalidOperationException>(delegate
{
nw.Invoke(id, out validationResults);
}, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Submit, DomainOperationType.Invoke));
nw = new TestDomainServices.EF.Northwind();
dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew")
{
IsAuthenticated = true
}), DomainOperationType.Query);
nw.Initialize(dsc);
ChangeSet cs = new ChangeSet(new ChangeSetEntry[] {
new ChangeSetEntry()
{
Entity = new ServiceContext_CurrentOperation_Entity()
{
Key = 1
},
Operation = DomainOperation.Insert
}
});
ExceptionHelper.ExpectException <InvalidOperationException>(delegate
{
nw.Submit(cs);
}, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Query, DomainOperationType.Submit));
}
/// <summary>
/// Invokes the specified <paramref name="invokeOperation"/> and returns the result, the validation errors,
/// and whether the operation completed successfully
/// </summary>
/// <typeparam name="TResult">The result type</typeparam>
/// <param name="invokeOperation">The <see cref="Expression"/> identifying the operation to invoke</param>
/// <param name="result">The result of the operation</param>
/// <param name="validationResults">The validation errors that occurred</param>
/// <returns>Whether the operation completed without error</returns>
private bool TryInvokeCore <TResult>(Expression invokeOperation, out TResult result, out IList <ValidationResult> validationResults)
{
OperationContext context = this.CreateOperationContext(DomainOperationType.Invoke);
InvokeDescription invokeDescription = Utility.GetInvokeDescription(context, invokeOperation);
IEnumerable <ValidationResult> validationErrors;
result = (TResult)context.DomainService.Invoke(invokeDescription, out validationErrors);
validationResults = (validationErrors == null) ? null : validationErrors.ToList();
return((validationResults == null) || (validationResults.Count == 0));
}
/// <summary>
/// Invokes the specified <paramref name="invokeOperation"/> and returns the result
/// </summary>
/// <typeparam name="TResult">The result type</typeparam>
/// <param name="invokeOperation">The <see cref="Expression"/> identifying the operation to invoke</param>
/// <exception cref="DomainServiceTestHostException">is thrown if there are any validation errors</exception>
private TResult InvokeCore <TResult>(Expression invokeOperation)
{
OperationContext context = this.CreateOperationContext(DomainOperationType.Invoke);
InvokeDescription invokeDescription = Utility.GetInvokeDescription(context, invokeOperation);
IEnumerable <ValidationResult> validationErrors;
TResult result = (TResult)context.DomainService.Invoke(invokeDescription, out validationErrors);
ErrorUtility.AssertNoValidationErrors(context, validationErrors);
return(result);
}
/// <summary>
/// Invokes the specified <paramref name="invokeOperation"/> and returns the result, the validation errors,
/// and whether the operation completed successfully
/// </summary>
/// <typeparam name="TResult">The result type</typeparam>
/// <param name="invokeOperation">The <see cref="Expression"/> identifying the operation to invoke</param>
/// <param name="result">The result of the operation</param>
/// <param name="validationResults">The validation errors that occurred</param>
/// <returns>Whether the operation completed without error</returns>
private bool TryInvokeCore <TResult>(Expression invokeOperation, out TResult result, out IList <ValidationResult> validationResults)
{
OperationContext context = this.CreateOperationContext(DomainOperationType.Invoke);
InvokeDescription invokeDescription = Utility.GetInvokeDescription(context, invokeOperation);
// TODO: Remove blocking wait
var invokeResult = context.DomainService.InvokeAsync(invokeDescription, CancellationToken.None).GetAwaiter().GetResult();
result = (TResult)invokeResult.Result;
validationResults = invokeResult.HasValidationErrors ? invokeResult.ValidationErrors.ToList() : null;
return(!invokeResult.HasValidationErrors);
}
/// <summary>
/// Invokes the specified <paramref name="invokeOperation"/> and returns the result
/// </summary>
/// <typeparam name="TResult">The result type</typeparam>
/// <param name="invokeOperation">The <see cref="Expression"/> identifying the operation to invoke</param>
/// <exception cref="DomainServiceTestHostException">is thrown if there are any validation errors</exception>
private TResult InvokeCore <TResult>(Expression invokeOperation)
{
OperationContext context = this.CreateOperationContext(DomainOperationType.Invoke);
InvokeDescription invokeDescription = Utility.GetInvokeDescription(context, invokeOperation);
// TODO: Remove blocking wait
var invokeResult = context.DomainService.InvokeAsync(invokeDescription, CancellationToken.None).GetAwaiter().GetResult();
ErrorUtility.AssertNoValidationErrors(context, invokeResult.ValidationErrors);
TResult result = (TResult)invokeResult.Result;
return(result);
}
public async Task DomainService_InvalidOperationType()
{
TestDomainServices.EF.Northwind nw = new TestDomainServices.EF.Northwind();
DomainServiceContext dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew")
{
IsAuthenticated = true
}), DomainOperationType.Submit);
nw.Initialize(dsc);
DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(TestDomainServices.EF.Northwind));
DomainOperationEntry entry = dsd.GetQueryMethod(nameof(TestDomainServices.EF.Northwind.GetOrderDetails));
QueryDescription qd = new QueryDescription(entry);
await ExceptionHelper.ExpectExceptionAsync <InvalidOperationException>(() =>
{
return(nw.QueryAsync <NorthwindModel.Order_Detail>(qd, CancellationToken.None).AsTask());
}, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Submit, DomainOperationType.Query));
InvokeDescription id = new InvokeDescription(entry, null);
await ExceptionHelper.ExpectExceptionAsync <InvalidOperationException>(() =>
{
return(nw.InvokeAsync(id, CancellationToken.None).AsTask());
}, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Submit, DomainOperationType.Invoke));
nw = new TestDomainServices.EF.Northwind();
dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew")
{
IsAuthenticated = true
}), DomainOperationType.Query);
nw.Initialize(dsc);
ChangeSet cs = new ChangeSet(new ChangeSetEntry[] {
new ChangeSetEntry()
{
Entity = new ServiceContext_CurrentOperation_Entity()
{
Key = 1
},
Operation = DomainOperation.Insert
}
});
await ExceptionHelper.ExpectExceptionAsync <InvalidOperationException>(async() =>
{
await nw.SubmitAsync(cs, CancellationToken.None);
}, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Query, DomainOperationType.Submit));
}
/// <summary>
/// Helper method performs a invoke operation against a given proxy instance.
/// </summary>
/// <param name="domainService">The type of <see cref="DomainService"/> to perform this query operation against.</param>
/// <param name="context">The current context.</param>
/// <param name="domainServiceInstances">The list of tracked <see cref="DomainService"/> instances that any newly created
/// <see cref="DomainServices"/> will be added to.</param>
/// <param name="name">The name of the operation to invoke.</param>
/// <param name="parameters">The operation parameters.</param>
/// <returns>The result of the invoke operation.</returns>
/// <exception cref="ArgumentNullException">if <paramref name="context"/> is null.</exception>
/// <exception cref="ArgumentNullException">if <paramref name="name"/> is null or an empty string.</exception>
/// <exception cref="OperationException">if operation errors are thrown during execution of the invoke operation.</exception>
public static object Invoke(Type domainService, DomainServiceContext context, IList <DomainService> domainServiceInstances, string name, object[] parameters)
{
context = new DomainServiceContext(context, DomainOperationType.Invoke);
DomainService service = CreateDomainServiceInstance(domainService, context, domainServiceInstances);
DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(service.GetType());
DomainOperationEntry method = serviceDescription.GetInvokeOperation(name);
IEnumerable <ValidationResult> validationErrors;
InvokeDescription invokeDescription = new InvokeDescription(method, parameters);
object result = service.Invoke(invokeDescription, out validationErrors);
if (validationErrors != null && validationErrors.Any())
{
IEnumerable <ValidationResultInfo> operationErrors = validationErrors.Select(ve => new ValidationResultInfo(ve.ErrorMessage, ve.MemberNames));
throw new OperationException(Resource.DomainServiceProxy_OperationError, operationErrors);
}
return(result);
}
/// <summary>
/// Helper method performs a invoke operation against a given proxy instance.
/// </summary>
/// <param name="domainService">The type of <see cref="DomainService"/> to perform this query operation against.</param>
/// <param name="context">The current context.</param>
/// <param name="domainServiceInstances">The list of tracked <see cref="DomainService"/> instances that any newly created
/// <see cref="DomainServices"/> will be added to.</param>
/// <param name="name">The name of the operation to invoke.</param>
/// <param name="parameters">The operation parameters.</param>
/// <returns>The result of the invoke operation.</returns>
/// <exception cref="ArgumentNullException">if <paramref name="context"/> is null.</exception>
/// <exception cref="ArgumentNullException">if <paramref name="name"/> is null or an empty string.</exception>
/// <exception cref="OperationException">if operation errors are thrown during execution of the invoke operation.</exception>
public static object Invoke(Type domainService, DomainServiceContext context, IList <DomainService> domainServiceInstances, string name, object[] parameters)
{
context = new DomainServiceContext(context, DomainOperationType.Invoke);
DomainService service = CreateDomainServiceInstance(domainService, context, domainServiceInstances);
DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(service.GetType());
DomainOperationEntry method = serviceDescription.GetInvokeOperation(name);
InvokeDescription invokeDescription = new InvokeDescription(method, parameters);
// TODO: Look into removing this blocking Wait
var loadResult = service.InvokeAsync(invokeDescription, CancellationToken.None)
.GetAwaiter().GetResult();
if (loadResult.HasValidationErrors)
{
IEnumerable <ValidationResultInfo> operationErrors = loadResult.ValidationErrors.Select(ve => new ValidationResultInfo(ve.ErrorMessage, ve.MemberNames));
throw new OperationException(Resource.DomainServiceProxy_OperationError, operationErrors);
}
return(loadResult.Result);
}
public async Task ServerValidation_InvokeOperation()
{
TestDomainServices.TestProvider_Scenarios service = ServerTestHelper.CreateInitializedDomainService <TestDomainServices.TestProvider_Scenarios>(DomainOperationType.Invoke);
DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(service.GetType());
DomainOperationEntry method = serviceDescription.DomainOperationEntries.Single(p => p.Name == "InvokeOperationWithParamValidation");
InvokeDescription invokeDescription = new InvokeDescription(method, new object[] { -3, "ABC", new TestDomainServices.CityWithCacheData() });
var invokeResult = await service.InvokeAsync(invokeDescription, CancellationToken.None);
Assert.IsNotNull(invokeResult.ValidationErrors);
Assert.AreEqual(2, invokeResult.ValidationErrors.Count());
ValidationResult error = invokeResult.ValidationErrors.ElementAt(0);
Assert.AreEqual("The field a must be between 0 and 10.", error.ErrorMessage);
Assert.AreEqual("a", error.MemberNames.Single());
error = invokeResult.ValidationErrors.ElementAt(1);
Assert.AreEqual("The field b must be a string with a maximum length of 2.", error.ErrorMessage);
Assert.AreEqual("b", error.MemberNames.Single());
}
public void ServerValidation_InvokeOperation()
{
TestDomainServices.TestProvider_Scenarios service = ServerTestHelper.CreateInitializedDomainService<TestDomainServices.TestProvider_Scenarios>(DomainOperationType.Invoke);
DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(service.GetType());
DomainOperationEntry method = serviceDescription.DomainOperationEntries.Single(p => p.Name == "InvokeOperationWithParamValidation");
IEnumerable<ValidationResult> validationErrors;
InvokeDescription invokeDescription = new InvokeDescription(method, new object[] { -3, "ABC", new TestDomainServices.CityWithCacheData() });
service.Invoke(invokeDescription, out validationErrors);
Assert.IsNotNull(validationErrors);
Assert.AreEqual(2, validationErrors.Count());
ValidationResult error = validationErrors.ElementAt(0);
Assert.AreEqual("The field a must be between 0 and 10.", error.ErrorMessage);
Assert.AreEqual("a", error.MemberNames.Single());
error = validationErrors.ElementAt(1);
Assert.AreEqual("The field b must be a string with a maximum length of 2.", error.ErrorMessage);
Assert.AreEqual("b", error.MemberNames.Single());
}
public void DomainService_InvalidOperationType()
{
TestDomainServices.EF.Northwind nw = new TestDomainServices.EF.Northwind();
DomainServiceContext dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew") { IsAuthenticated = true }), DomainOperationType.Submit);
nw.Initialize(dsc);
IEnumerable<ValidationResult> validationResults = null;
int totalCount;
DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(TestDomainServices.EF.Northwind));
DomainOperationEntry entry = dsd.DomainOperationEntries.First(p => p.Operation == DomainOperation.Query);
QueryDescription qd = new QueryDescription(entry);
ExceptionHelper.ExpectException<InvalidOperationException>(delegate
{
nw.Query(qd, out validationResults, out totalCount);
}, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Submit, DomainOperationType.Query));
InvokeDescription id = new InvokeDescription(entry, null);
ExceptionHelper.ExpectException<InvalidOperationException>(delegate
{
nw.Invoke(id, out validationResults);
}, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Submit, DomainOperationType.Invoke));
nw = new TestDomainServices.EF.Northwind();
dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew") { IsAuthenticated = true }), DomainOperationType.Query);
nw.Initialize(dsc);
ChangeSet cs = new ChangeSet(new ChangeSetEntry[] {
new ChangeSetEntry() {
Entity = new ServiceContext_CurrentOperation_Entity() { Key = 1 },
Operation = DomainOperation.Insert
}
});
ExceptionHelper.ExpectException<InvalidOperationException>(delegate
{
nw.Submit(cs);
}, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Query, DomainOperationType.Submit));
}
