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)); }