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