public static void ThrowOnError(this IServiceResult serviceResult) { if (!serviceResult.Succeeded) { throw new NotSucceededException(serviceResult, $"Service result did not succeed. {serviceResult.Errors.ToStringOrDefaultMessage()}"); } }
protected IServiceResult CreateServiceResult(IServiceResult cachedServiceResult) { // Important to clone the ori list, because potential (user-dependent) // security logic may truncate this list (original must remain unmodified) IList <IObjRef> objRefs = cachedServiceResult.ObjRefs; IList <IObjRef> list = new List <IObjRef>(objRefs.Count); for (int a = 0, size = objRefs.Count; a < size; a++) { list.Add(objRefs[a]); } IList <IObjRef> filteredList; if (SecurityManager != null) { filteredList = SecurityManager.FilterValue(list); } else { filteredList = list; } ServiceResult serviceResult = new ServiceResult(); serviceResult.AdditionalInformation = cachedServiceResult.AdditionalInformation; serviceResult.ObjRefs = filteredList; return(serviceResult); }
public async Task <IActionResult> NewOrganizationPartial(OrganizationNewViewModel model) { if (!Request.IsAjaxRequest()) { return(RedirectToAction("BadRequest", "Home")); } if (model == null) { return(PartialView("_FailureToLoadDataPartial")); } ViewBag.HttpMethod = Request.Method; if (ModelState.IsValid) { var entity = model.GetBase(); ServiceResultModel = await _organizationService.AddNewOrganizationEntityAsync(entity); if (ServiceResultModel.IsSuccess) { return(PartialView("_SuccessAddPartial")); } else { model.ErrorMessage = ServiceResultModel.ErrorMessage; } } return(PartialView("_NewOrganizationPartial", model)); }
public async Task <IActionResult> RegisterAdminAsync(UserToRegisterDto userToRegister) { if (ModelState.IsValid) { UserModel user = new AdminModel { UserName = userToRegister.Username, Email = userToRegister.EmailAddress }; IServiceResult <UserModel> registerResult = await _authService.RegisterAsync(user, userToRegister.Password, Url); if (registerResult.Result == ResultType.Created) { return(Ok()); } else { return(BadRequest(registerResult.Errors)); } } else { return(BadRequest(ModelState.Values)); } }
public async Task DeleteIngredientFromPizzaCorrectly() { string expectedPizzaName = "TestPizza"; int expectedIdOfIngredient = 2; pizzaRepoMock.Setup(x => x.GetByExpressionAsync(It.IsAny <Expression <Func <PizzaModel, bool> > >(), It.IsAny <Func <IQueryable <PizzaModel>, IIncludableQueryable <PizzaModel, object> > >())).Returns(GetPizzaByName(expectedPizzaName)); pizzaRepoMock.Setup(x => x.Update(It.IsAny <PizzaModel>())); Mock <IFoodOrderRepository <IngredientModel> > ingredientRepoMock = new Mock <IFoodOrderRepository <IngredientModel> >(); ingredientRepoMock.Setup(x => x.GetByExpressionAsync(It.IsAny <Expression <Func <IngredientModel, bool> > >(), It.IsAny <Func <IQueryable <IngredientModel>, IIncludableQueryable <IngredientModel, object> > >())).Returns(GetExpectedIngredientById(expectedIdOfIngredient)); uowMock.Setup(x => x.Pizzas).Returns(pizzaRepoMock.Object); uowMock.Setup(x => x.Ingredients).Returns(ingredientRepoMock.Object); uowMock.Setup(x => x.SaveChangesAsync()); IPizzaService service = new PizzaService(uowMock.Object); IServiceResult <PizzaToReturnDto> result = await service.DeleteIngredientAsync(expectedPizzaName, expectedIdOfIngredient); Assert.AreEqual(ResultType.Edited, result.Result); Assert.IsNull(result.Errors); Assert.AreEqual(4, result.ReturnedObject.Ingredients.Count); for (int i = 0; i < result.ReturnedObject.TotalPrices.Count; i++) { Assert.AreEqual(expectedPizzas.First().PizzaDetails.ElementAt(i).TotalPrice, result.ReturnedObject.TotalPrices.ElementAt(i).Price); } }
public async Task CreateNewPizzaWithTakenName() { PizzaToCreateDto expectedPizzaToCreate = new PizzaToCreateDto { Name = "TestPizza", IngredientIds = new List <int> { 1 } }; pizzaRepoMock.Setup(x => x.GetByExpressionAsync(It.IsAny <Expression <Func <PizzaModel, bool> > >(), It.IsAny <Func <IQueryable <PizzaModel>, IIncludableQueryable <PizzaModel, object> > >())).Returns(GetPizzaByName(expectedPizzaToCreate.Name)); uowMock.Setup(x => x.Pizzas).Returns(pizzaRepoMock.Object); IPizzaService service = new PizzaService(uowMock.Object); IServiceResult <PizzaToReturnDto> creationResult = await service.CreateAsync(expectedPizzaToCreate); Assert.AreEqual(ResultType.Error, creationResult.Result); Assert.IsNull(creationResult.ReturnedObject); Assert.IsNotNull(creationResult.Errors); Assert.AreEqual(1, creationResult.Errors.Count); Assert.AreEqual($"Pizza name: {expectedPizzaToCreate.Name} is already taken", creationResult.Errors.First()); }
public void Display(IUserInterface userInterface, IServiceResult serviceResult) { if (userInterface == null) { throw new ArgumentNullException("userInterface"); } if (serviceResult == null) { return; } if (serviceResult.Status == ServiceResultType.NoResult) { return; } if (string.IsNullOrWhiteSpace(serviceResult.Message)) { return; } if (serviceResult.InnerResult != null) { this.Display(userInterface, serviceResult.InnerResult); } string resultTypeLabel = Resources.ServiceResultVisualizer.ResourceManager.GetString("ServiceResultType" + serviceResult.Status); userInterface.WriteLine(resultTypeLabel + ": " + serviceResult.Message); if (!string.IsNullOrWhiteSpace(serviceResult.ResultArtefact)) { userInterface.WriteLine(Resources.ServiceResultVisualizer.ReturnValue + ": " + serviceResult.ResultArtefact); } }
public async Task GetPizzaById() { int expectedId = 1; PizzaModel expectedPizza = (await GetPizzaById(expectedId)).Single(); pizzaRepoMock.Setup(x => x.GetByExpressionAsync(It.IsAny <Expression <Func <PizzaModel, bool> > >(), It.IsAny <Func <IQueryable <PizzaModel>, IIncludableQueryable <PizzaModel, object> > >())).Returns(GetPizzaById(expectedId)); uowMock.Setup(x => x.Pizzas).Returns(pizzaRepoMock.Object); // create instance of service IPizzaService service = new PizzaService(uowMock.Object); // call function to test IServiceResult <PizzaToReturnDto> result = await service.GetByIdAsync(expectedId); // asserts Assert.AreEqual(ResultType.Correct, result.Result); Assert.IsNotNull(result.ReturnedObject); Assert.AreEqual(expectedPizza.Id, result.ReturnedObject.Id); Assert.AreEqual(expectedPizza.Name.ToLower(), result.ReturnedObject.Name.ToLower()); Assert.AreEqual(expectedPizza.PizzaIngredients.Count + 3, result.ReturnedObject.Ingredients.Count); Assert.AreEqual(expectedPizza.PizzaDetails.Count, result.ReturnedObject.TotalPrices.Count); // check of total price makes sure that also ingredients have correct prices for (int i = 0; i < expectedPizza.PizzaDetails.Count; i++) { Assert.AreEqual(expectedPizza.PizzaDetails.ElementAt(i).TotalPrice, result.ReturnedObject.TotalPrices.ElementAt(i).Price); } }
public static IServiceResult <TResult> ToResult <TResult>(this IServiceResult serviceResult) { var result = new ServiceResult <TResult>(); result.Errors.AddRange(serviceResult.Errors); return(result); }
/// <summary> /// Check conditions for a succeeded result. You may ingnore error codes that could cause to a failed result. /// </summary> public static bool Success(this IServiceResult serviceResult, IEnumerable <string> ignoredErrorCodes) { serviceResult = serviceResult ?? throw new ArgumentNullException(nameof(serviceResult)); var errors = serviceResult.Errors; if (serviceResult.Succeeded || errors == null || errors.Count == 0) { return(true); } int notIgnoredErrorCodesCount; if (ignoredErrorCodes is null) { notIgnoredErrorCodesCount = errors.Count; } else { notIgnoredErrorCodesCount = errors.Errors .Where(x => !ignoredErrorCodes.Contains(x.ErrorCode)) .Count(); } if (notIgnoredErrorCodesCount == 0) { return(true); } return(false); }
protected ActionResult ActionResult(IServiceResult <Error> serviceResult) { if (!serviceResult.IsSuccess) { return(FaultedActionResult(serviceResult)); } return(NoContent()); }
internal static void ValidateNullWhiteSpace <T>(string value, IServiceResult <T> result, string prop, string entity) { if (string.IsNullOrWhiteSpace(value)) { result.ErrorMessages.Add(prop, string.Format(MessagesResx._CantBe_, entity, CommonsResx.Empty)); } }
protected void AddModelErrorsToResult(IServiceResult result) { foreach (var item in ModelState) { foreach (var error in item.Value.Errors) { result.AddError(item.Key, error.ErrorMessage); } } }
public async Task <IActionResult> UpdateOrganizationPartial(OrganizationUpdateViewModel model, string command) { if (!Request.IsAjaxRequest()) { return(RedirectToAction("BadRequest", "Home")); } if (model == null) { return(PartialView("_FailureToLoadDataPartial")); } ViewBag.HttpMethod = Request.Method; var OrganizationEntity = _organizationService.GetOrganization(model.Id).Data; if (OrganizationEntity == null) { model.IsSuccess = false; model.ErrorMessage = "Entry doesn't exist."; return(View(model)); } if (command == "Delete") { ServiceResultModel = await _organizationService.DeleteOrganizationEntityAsync(model.Id); if (ServiceResultModel.IsSuccess) { return(PartialView("_SuccessDeletePartial")); } else { model.ErrorMessage = ServiceResultModel.ErrorMessage; } } if (command == "Update" && ModelState.IsValid) { OrganizationEntity = model.UpdateBase(OrganizationEntity); ServiceResultModel = await _organizationService.UpdateOrganizationEntityAsync(OrganizationEntity); if (ServiceResultModel.IsSuccess) { return(PartialView("_SuccessUpdatePartial")); } else { model.ErrorMessage = ServiceResultModel.ErrorMessage; } } return(PartialView("_UpdateOrganizationPartial", model)); }
public async Task <IActionResult> ConfirmEmail(int userId, string token) { IServiceResult confirmationResult = await _authService.ConfirmEmailAsync(userId, token); if (confirmationResult.Result == ResultType.Correct) { return(Ok()); } return(BadRequest(confirmationResult.Errors)); }
protected Object CreateResultObject(IServiceResult serviceResult, Type expectedType, Object[] originalArgs, Attribute annotation) { IList <IObjRef> objRefs = serviceResult.ObjRefs; IList <Object> syncObjects = null; if (annotation is FindAttribute && ((FindAttribute)annotation).ResultType != QueryResultType.REFERENCES) { syncObjects = Cache.GetObjects(objRefs, CacheDirective.None); } return(PostProcessCacheResult(objRefs, syncObjects, expectedType, serviceResult, originalArgs, annotation)); }
public static IEnumerable <int> MapProviderSearchResult_ProviderIds(IServiceResult input) { var items = input as ProviderSearchResult; IList <int> retval = new List <int>(); foreach (var item in items.Result) { retval.Add(item.Key); } return(retval); }
public void testDFSTurnStackUpsideDownNumberOfVisitedCells2() { //0 1 10 //10 8 10 //10 1 0 IMap map = new Map(3, 3, 0, 1, 10, 10, 8, 10, 10, 1, 0); IMapService service = new MapServiceDFSTurnStackUpsideDown(map); IServiceResult result = service.FindAllRiverSourcesWhichFlowToBothOceans(); Assert.AreEqual(19, result.TotalCountOfVisitedCells, "Wrong number of visited cells for DFSTurnStackUpsideDown."); }
public async Task <IActionResult> DeleteOrder(int orderId) { IServiceResult deletionResult = await _orderService.DeleteOrder(orderId); if (deletionResult.Result == ResultType.Deleted) { return(Ok()); } else { return(BadRequest()); } }
public async Task <IActionResult> CancelOrder(int orderId) { IServiceResult cancelResult = await _orderService.CancelOrder(orderId, int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)); if (cancelResult.Result == ResultType.Edited) { return(Ok()); } else { return(BadRequest()); } }
public async Task <IActionResult> MakeOrder(List <PizzaToOrderDto> orderItems) { IServiceResult orderResult = await _orderService.MakeOrder(orderItems, int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)); if (orderResult.Result == ResultType.Correct) { return(Ok()); } else { return(BadRequest()); } }
public async Task <IActionResult> Delete(int pizzaId) { IServiceResult result = await _service.DeleteAsync(pizzaId); if (result.Result == ResultType.Deleted) { return(Ok()); } else { return(BadRequest()); } }
public async Task <IActionResult> GetIngredientById(int id) { IServiceResult <IngredientModel> result = await _service.GetByIdAsync(id); if (result.Result == ResultType.Correct) { return(Ok(result.ReturnedObject)); } else { return(NotFound(result.Errors)); } }
public async Task <IActionResult> Create(PizzaToCreateDto pizzaToCreate) { IServiceResult <PizzaToReturnDto> result = await _service.CreateAsync(pizzaToCreate); if (result.Result == ResultType.Created) { return(CreatedAtRoute("GetPizzaByName", new { name = result.ReturnedObject.Name }, result.ReturnedObject)); } else { return(BadRequest()); } }
public async Task <IActionResult> DeleteIngredient(int id) { IServiceResult result = await _service.DeleteAsync(id); if (result.Result == ResultType.Deleted) { return(Ok()); } else { return(BadRequest(result.Errors)); } }
public void testMapServiceStartTraversingFromOceansNumberOfVisitedCells2() { //0 1 10 //10 8 10 //10 1 0 IMap map = new Map(3, 3, 0, 1, 10, 10, 8, 10, 10, 1, 0); IMapService service = new MapServiceStartTraversingFromOceans(map); IServiceResult result = service.FindAllRiverSourcesWhichFlowToBothOceans(); Assert.AreEqual(14, result.TotalCountOfVisitedCells, "Wrong number of visited cells for MapServiceStartTraversingFromOceans."); }
public async Task <IActionResult> AddPizzaPhotoAsync(PhotoToCreateDto photoToCreate) { IServiceResult result = await _photoService.AddPizzaPhotoAsync(photoToCreate); if (result.Result == ResultType.Correct) { return(Ok()); } else { return(BadRequest(result.Errors)); } }
public async Task <IActionResult> DeleteIngredient(string pizzaName, int ingredientId) { IServiceResult <PizzaToReturnDto> result = await _service.DeleteIngredientAsync(pizzaName, ingredientId); if (result.Result == ResultType.Edited) { return(CreatedAtRoute("GetPizzaByName", new { name = result.ReturnedObject.Name }, result.ReturnedObject)); } else { return(BadRequest(result.Errors)); } }
public async Task <IActionResult> GetByName(string name) { IServiceResult <PizzaToReturnDto> result = await _service.GetByNameAsync(name); if (result.Result == ResultType.Correct) { return(Ok(result.ReturnedObject)); } else { return(BadRequest(result.Errors)); } }
public async Task <IActionResult> GetById(int id) { IServiceResult <PizzaToReturnDto> result = await _service.GetByIdAsync(id); if (result.Result == ResultType.Correct) { return(Ok(result.ReturnedObject)); } else { return(BadRequest()); } }
/// <summary> /// Throw exception in the "No Retry" scenario /// </summary> /// <param name="result">The Service Result</param> public static void ThrowOnNoRetry(this IServiceResult result) { if (result is IServiceResultExceptionInfo resultWithException) { if (resultWithException.NoRetryException != null) { throw resultWithException.NoRetryException; } else { throw new CouchbaseException(); } } }
public async Task DeleteExistingIngredient() { repoMock.Setup(x => x.GetByExpressionAsync(It.IsAny <Expression <Func <IngredientModel, bool> > >(), null)).Returns(GetFakeIngredientByName(expectedIngredients.ElementAt(0).Name)); repoMock.Setup(x => x.Delete(expectedIngredients.ElementAt(0))); uowMock.Setup(x => x.Ingredients).Returns(repoMock.Object); IIngredientService ingredientService = new IngredientService(uowMock.Object); IServiceResult deleteResult = await ingredientService.DeleteAsync(expectedIngredients.ElementAt(0).Id); Assert.AreEqual(ResultType.Deleted, deleteResult.Result); Assert.IsNull(deleteResult.Errors); }
public void Display(IServiceResult serviceResult) { this.serviceResultVisualizer.Display(this, serviceResult); }