public FoodDto UpdateFood(FoodDto dto)
{
Food food = _modelMapper.FromFoodDto(dto);
Food updatedFood = _foodRepository.Update(food);
return(_modelMapper.ToFoodDto(updatedFood));
}
public FoodDto GetFoodById(Guid id)
{
Food food = _foodRepository.GetById(id);
FoodDto foodDto = _modelMapper.ToFoodDto(food);
return(foodDto);
}
public IActionResult PartialUpdate(int Id,
[FromBody] JsonPatchDocument <FoodDto> FoodDtoPatchDocument)
{
if (FoodDtoPatchDocument == null)
{
return(BadRequest());
}
FoodItem item = foodRepository.GetSingle(Id);
if (item == null)
{
return(NotFound());
}
FoodDto dto = AutoMapper.Mapper.Map <FoodDto>(item);
FoodDtoPatchDocument.ApplyTo(dto, ModelState);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
FoodItem updated = foodRepository.Update(Id, AutoMapper.Mapper.Map <FoodItem>(dto));
return(Ok(AutoMapper.Mapper.Map <FoodDto>(updated)));
}
public async Task <ResultDto> UpdateFoodInformation(FoodDto foodDto)
{
var food = await _context.Foods.Where(f => f.UUID == foodDto.UUID).FirstOrDefaultAsync();
if (food == null)
{
_logger.LogDebug("Food not found with id: ", foodDto.UUID);
return(new ResultDto(false, "Food not found"));
}
food.UpdatedAt = DateTime.Now;
food.Name = foodDto.Name ?? food.Name;
food.Energy = foodDto.Energy;
food.Carbs = foodDto.Carbs;
food.Fat = foodDto.Fat;
food.Protein = foodDto.Protein;
food.Fiber = foodDto.Fiber;
food.Sugar = foodDto.Sugar;
food.PackageSize = foodDto.PackageSize;
food.ServingSize = foodDto.ServingSize;
_context.Entry(food).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(new ResultDto(true, "Food updated succesfully"));
}
public async Task <IActionResult> Put(Guid id, [FromBody] FoodDto foodDto)
{
if (id != foodDto.Id)
{
return(BadRequest());
}
var food = _mapper.Map <Food>(foodDto);
_repository.Update(id, food);
if (foodDto.DeletedPictures?.Any() == true)
{
await _foodPictureService.RemovePictures(foodDto.DeletedPictures);
}
if (!_repository.HasChanges() && foodDto.DeletedPictures?.Any() == false)
{
return(StatusCode(304));
}
if (!_repository.HasChanges() && foodDto.DeletedPictures?.Any() == true)
{
return(Ok());
}
return(await _repository.Commit() ? Ok() : (IActionResult)BadRequest());
}
//update food in database
public FoodDto PutFood(FoodDto foodDto)
{
using (HealthyMenuEntities db = new HealthyMenuEntities())
{
try
{
Food food = db.Foods.FirstOrDefault(x => x.id == foodDto.id);
if (food == null)
{
return(null);
}
food.cosher = foodDto.cosher;
food.foodName = foodDto.foodName;
food.id = foodDto.id;
food.picture = foodDto.picture;
food.suitableToID = foodDto.suitableToID;
food.category = foodDto.category;
return(Convertion.FoodConvetrtion.convert(food));
}
catch
{
return(null);
}
}
}
public void FromFoodDto_MapFoodFromDtoToModel()
{
Guid id = new Guid("0f8fad5b-d9cb-469f-a165-70867728950e");
string name = "Test food";
int kcal = 100;
float protein = 5.5f;
bool isVegetarian = true;
FoodDto foodDto = new FoodDto()
{
Id = id,
Name = name,
Kcal = kcal,
Protein = protein,
IsVegetarian = isVegetarian
};
DtoModelMapper mapper = new DtoModelMapper();
Food food = mapper.FromFoodDto(foodDto);
Assert.AreEqual(id, food.Id, "Copied 'Id' has invalid value");
Assert.AreEqual(name, food.Name, "Copied 'name' has invalid value");
Assert.AreEqual(kcal, food.Kcal, "Copied 'kcal' has invalid value");
Assert.AreEqual(protein, food.Protein, "Copied 'protein' has invalid value");
Assert.AreEqual(isVegetarian, food.IsVegetarian, "Copied 'is vegetarian' has invalid value");
}
// helpers
public static ActorDetailsDto BuildPlayerData(ParsedEvtcLog log, AbstractSingleActor actor, Dictionary <long, SkillItem> usedSkills, Dictionary <long, Buff> usedBuffs)
{
var dto = new ActorDetailsDto
{
DmgDistributions = new List <DmgDistributionDto>(),
DmgDistributionsTargets = new List <List <DmgDistributionDto> >(),
DmgDistributionsTaken = new List <DmgDistributionDto>(),
BoonGraph = new List <List <BuffChartDataDto> >(),
Rotation = new List <List <object[]> >(),
Food = FoodDto.BuildFoodData(log, actor, usedBuffs),
Minions = new List <ActorDetailsDto>(),
DeathRecap = DeathRecapDto.BuildDeathRecap(log, actor)
};
foreach (PhaseData phase in log.FightData.GetPhases(log))
{
dto.Rotation.Add(SkillDto.BuildRotationData(log, actor, phase, usedSkills));
dto.DmgDistributions.Add(DmgDistributionDto.BuildFriendlyDMGDistData(log, actor, null, phase, usedSkills, usedBuffs));
var dmgTargetsDto = new List <DmgDistributionDto>();
foreach (AbstractSingleActor target in phase.Targets)
{
dmgTargetsDto.Add(DmgDistributionDto.BuildFriendlyDMGDistData(log, actor, target, phase, usedSkills, usedBuffs));
}
dto.DmgDistributionsTargets.Add(dmgTargetsDto);
dto.DmgDistributionsTaken.Add(DmgDistributionDto.BuildDMGTakenDistData(log, actor, phase, usedSkills, usedBuffs));
dto.BoonGraph.Add(BuffChartDataDto.BuildBoonGraphData(log, actor, phase, usedBuffs));
}
foreach (KeyValuePair <long, Minions> pair in actor.GetMinions(log))
{
dto.Minions.Add(BuildFriendlyMinionsData(log, actor, pair.Value, usedSkills, usedBuffs));
}
return(dto);
}
public void Title_should_be_selected_food_name(FoodDto foodDto)
{
// Given
var viewModel = Mocker.Create <FoodDetailViewModel>(new NamedParameter("selectedFood", foodDto));
// then
Assert.That(viewModel.Title, Is.EqualTo(foodDto.Name));
}
public FoodDto Save(FoodDto foodDto)
{
Food food = _modelMapper.FromFoodDto(foodDto);
Food updated = _foodRepository.CreateOrUpdate(food);
FoodDto updatedDto = _modelMapper.ToFoodDto(updated);
return(updatedDto);
}
public FoodDto AddFood(FoodDto dto)
{
Food food = _modelMapper.FromFoodDto(dto);
Food createdFood = _foodRepository.Add(food);
FoodDto createdFoodDto = _modelMapper.ToFoodDto(createdFood);
return(createdFoodDto);
}
// PUT api/<controller>/5
public async Task Put(int id, FoodDto foodDto)
{
var foodInDb = _unitOfWork.Foods.SingleOrDefault(c => c.Id == id);
_mapper.Map <Food>(foodDto);
await _unitOfWork.Complete();
}
public void SelectedFood_should_be_equal_food_which_is_passed_from_parameter(FoodDto foodDto)
{
// given
var viewModel = Mocker.Create <FoodDetailViewModel>(new NamedParameter("selectedFood", foodDto));
// then
Assert.That(viewModel.SelectedFood, Is.EqualTo(foodDto));
}
//public IHttpActionResult Create(FoodDto foodDto)
//{
// _unitOfWork.Foods.Add(_mapper.Map<Food>(foodDto));
// return Ok();
//}
// POST api/<controller>
public async Task <IHttpActionResult> Post(FoodDto foodDto)
{
var food = _mapper.Map <Food>(foodDto);
_unitOfWork.Foods.Add(food);
await _unitOfWork.Complete();
return(Created(new Uri(Request.RequestUri + "/" + food.Id), foodDto));
}
public void Add_to_basket_should_add_order_to_Orders(FoodDto foodDto)
{
// Given
var viewModel = Mocker.Create <FoodDetailViewModel>(new NamedParameter("selectedFood", foodDto));
// when
viewModel.AddToBasket.Execute(null);
// then
}
public void Given_invalid_id_Delete_should_throw()
{
var id = -1;
var foodDto = new FoodDto {
Id = id
};
var result = ClassUnderTest.RemoveFood(id);
result.Should().BeOfType <BadRequestResult>();
}
public void GoToBasket_should_navigate_to_Basket_page(FoodDto foodDto)
{
// Given
var viewModel = Mocker.Create <FoodDetailViewModel>(new NamedParameter("selectedFood", foodDto));
// when
viewModel.GoToBasket.Execute(null);
// then
GetMock <INavigationService>().Verify(x => x.NavigateAsync(typeof(IBasketViewModel)));
}
public IActionResult CreateFood([FromBody] FoodDto foodDto)
{
CreateFoodResponse response = _foodService.CreateFood(foodDto);
if (!response.ResponseStatus.HasError())
{
return(Ok());
}
return(StatusCode(response.ResponseStatus.Status, response.ResponseStatus.Message));
}
private dynamic ExpandSingleFoodItem(FoodEntity foodItem, ApiVersion version)
{
var links = GetLinks(foodItem.Id, version);
FoodDto item = _mapper.Map <FoodDto>(foodItem);
var resourceToReturn = item.ToDynamic() as IDictionary <string, object>;
resourceToReturn.Add("links", links);
return(resourceToReturn);
}
public async Task Given_id_and_FoodDto_Id_not_equal_Put_should_return_bad_request()
{
var id = Guid.NewGuid();
var foodDto = new FoodDto
{
Id = Guid.NewGuid()
};
var result = await ClassUnderTest.Put(id, foodDto);
result.Should().BeOfType <BadRequestResult>();
}
//convert one Food to FoodDto
public static FoodDto convert(Food food)
{
FoodDto NewFood = new FoodDto();
NewFood.cosher = food.cosher;
NewFood.foodName = food.foodName;
NewFood.id = food.id;
NewFood.picture = food.picture;
NewFood.suitableToID = food.suitableToID;
NewFood.category = food.category;
return(NewFood);
}
public async Task <IActionResult> Post([FromBody] FoodDto foodDto)
{
var food = _mapper.Map <Food>(foodDto);
_repository.Create(food);
var result = await _repository.Commit();
if (result)
{
return(Ok());
}
return(BadRequest());
}
public async Task Given_invalid_id_Delete_should_throw()
{
var id = Guid.Empty;
var foodDto = new FoodDto {
Id = id
};
GetMock <IMapper>().Setup(x => x.Map <Food>(foodDto)).Throws <Exception>();
var result = await ClassUnderTest.Delete(id);
result.Should().BeOfType <BadRequestResult>();
}
// DELETE api/<controller>/5
public IHttpActionResult Delete(FoodDto value)
{
if (value == null)
{
return(BadRequest("לא נשלח מידע"));
}
value = service.RemoveFood(value);
if (value == null)
{
return(BadRequest("מחיקה נכשלה"));
}
return(Ok(value));
}
// PUT api/<controller>/5
public IHttpActionResult Put(FoodDto value)
{
if (value == null)
{
return(BadRequest("לא נשלח מידע"));
}
value = service.PostFood(value);
if (value == null)
{
return(BadRequest("עדכון נכשל"));
}
return(Ok(value));
}
public FoodDto AddFood(FoodParameter foodParameter, int userId)
{
var newFood = new Food()
{
FoodName = foodParameter.FoodName,
Remark = foodParameter.Remark,
CreatedBy = userId,
CreatedAt = DateTime.Now
};
_foodRepositories.AddFood(newFood);
return(FoodDto.ToFoodDto(newFood));
}
public async Task <IActionResult> UpdateFood(string id, [FromBody] FoodDto foodDto)
{
if (HttpContext.User.Identity.Name != foodDto.AddedBy)
{
return(Unauthorized());
}
if (id != foodDto.UUID)
{
return(BadRequest());
}
return(Ok(await _foodService.UpdateFoodInformation(foodDto)));
}
public async Task <ResultDto> AddNewFood(FoodDto foodDto, string userId)
{
var food = _mapper.Map <Food>(foodDto);
food.User = await _context.Users.Where(u => u.UUID == userId).FirstOrDefaultAsync();
food.UUID = Guid.NewGuid().ToString();
food.CreatedAt = DateTime.Now;
food.UpdatedAt = DateTime.Now;
_context.Add(food);
await _context.SaveChangesAsync();
return(new ResultDto(true, "Food added succesfully"));
}
public FoodDto ToDto(Food food)
{
FoodDto foodDto = new FoodDto();
FoodCategoryMapper foodCategroyMapper = new FoodCategoryMapper();
FoodInfoMapper foodInfoMapper = new FoodInfoMapper();
foodDto.validated = food.Validated;
foodDto.name = food.Name;
foodDto.foodCategoryDto = foodCategroyMapper.ToDto(food.FoodCategory);
foodDto.foodInfoDto = foodInfoMapper.ToDto(food.FoodInfo);
foodDto.barcode = food.Barcode;
foodDto.portion = food.Portion;
return(foodDto);
}
public FoodDto UpdateFood(FoodParameter foodParameter, int userId)
{
var food = _foodRepositories.GetFood(foodParameter.Id);
if (food != null)
{
food.FoodName = foodParameter.FoodName;
food.Remark = foodParameter.Remark;
food.UpdatedBy = userId;
food.UpdatedAt = DateTime.Now;
return(FoodDto.ToFoodDto(_foodRepositories.UpdateFood(food)));
}
return(null);
}
