public IHttpActionResult Post([FromBody] OrderPostModel order)
{
if (!ModelState.IsValid)
{
return(this.Conflict());
}
string userId = this.User.Identity.GetUserId();
User user = this.userRepository.GetById(userId);
PizzaItem newPizzaItem = new PizzaItem(Guid.NewGuid(), order.Pizza.Name, order.Pizza.TotalCost, order.Pizza.ImageUrl);
foreach (var ingred in order.Pizza.Ingredients)
{
newPizzaItem.Ingredients.Add(this.ingredientRepository.GetList(ing => ing.Name == ingred.Name).FirstOrDefault());
}
Order orderEntity = new Order(
Guid.NewGuid(),
order.Pizza.TotalCost,
EntityBuilder.ToEntity(order.Contact));
orderEntity.User = user;
orderEntity.Pizzas = new List <PizzaItem>()
{
newPizzaItem
};
this.orderRepository.Add(orderEntity);
this.orderRepository.SaveChanges();
return(this.Ok());
}
public void ToPizzaItemEntity_PizzaItemIsCorrect_PizzaItemDtoIsEqualToPizzaItem()
{
PizzaItemDto pizzaItemDto = new PizzaItemDto(
"Margarita",
1200,
"Margarita.png",
DateTime.Now,
new List <IngredientDto>());
pizzaItemDto.Ingredients.Add(new IngredientDto(
"Dough",
200,
"Dough.png",
"DoughBase.png",
new CategoryDto(Categories.Dough.ToString()),
5));
pizzaItemDto.Ingredients.Add(new IngredientDto(
"Bacon",
200,
"Bacon.png",
"BaconBase.png",
new CategoryDto(Categories.Meat.ToString()),
500));
PizzaItem actual = EntityBuilder.ToEntity(pizzaItemDto);
base.AssertPizzaItemsAreEqualEntities(actual, pizzaItemDto);
}
public void Add(string ingids, PizzaItem item)
{
db.PizzaItems.Add(item);
db.SaveChanges();
try
{
StringBuilder clearingids = new StringBuilder();
foreach (char c in ingids)
{
if ((c >= '0' && c <= '9') || (c == ','))
{
clearingids.Append(c);
}
}
List <long> ids = clearingids.ToString().Split(',').Select(Int64.Parse).ToList();
foreach (long ingid in ids)
{
AddIngridient(item.Id, ingid);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void ToPizzaItemDto_PizzaItemIsCorrect_PizzaItemDtoIsEqualToPizzaItem()
{
PizzaItem expected = new PizzaItem(
Guid.NewGuid(),
"Margarita",
1200,
"Margarita.png");
expected.Order = new Order(Guid.NewGuid(), 1200, new Contact());
expected.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Dough",
200,
"Dough.png",
"DoughBase.png",
Categories.Dough,
5));
expected.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Bacon",
200,
"Bacon.png",
"BaconBase.png",
Categories.Meat,
500));
PizzaItemDto actual = DtoBuilder.ToDto(expected);
base.AssertPizzaItemsAreEqual(expected, actual);
}
public void ToPizzaItemEntity_PizzaItemIsEmpty_PizzaItemDtoIsEqualToPizzaItem()
{
PizzaItemDto expected = new PizzaItemDto();
PizzaItem actual = EntityBuilder.ToEntity(expected);
base.AssertPizzaItemsAreEqualEntities(actual, expected);
}
public void ToUserDto_NameIsNull_UserDtoIsEqualToUser()
{
User user = new User(null, "Email");
Order order = new Order(Guid.NewGuid(), 2000, new Contact());
PizzaItem pizza1 = new PizzaItem(
Guid.NewGuid(),
"Margarita",
1200,
"Margarita.png");
pizza1.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Dough",
200,
"Dough.png",
"DoughBase.png",
Categories.Dough,
5));
pizza1.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Bacon",
200,
"Bacon.png",
"BaconBase.png",
Categories.Meat,
500));
pizza1.Order = order;
PizzaItem pizza2 = new PizzaItem(
Guid.NewGuid(),
"Margarita",
1200,
"Margarita.png");
pizza2.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Dough",
200,
"Dough.png",
"DoughBase.png",
Categories.Dough,
5));
pizza2.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Cheese",
150,
"Cheese.png",
"CheeseBase.png",
Categories.Cheese,
10));
pizza2.Order = order;
user.Orders.Add(order);
UserDto userDto = DtoBuilder.ToDto(user);
base.AssertUsersAreEqual(user, userDto);
}
public void ToPizzaItemDto_PizzaItemIsEmpty_PizzaItemDtoIsEqualToPizzaItem()
{
PizzaItem expected = new PizzaItem();
expected.Order = new Order();
PizzaItemDto actual = DtoBuilder.ToDto(expected);
base.AssertPizzaItemsAreEqual(expected, actual);
}
public void ToOrderDto_OrderIsCorrect_OrderDtoIsEqualToOrder()
{
Order expectedOrder = new Order(Guid.NewGuid(), 2000, new Contact());
PizzaItem pizza1 = new PizzaItem(
Guid.NewGuid(),
"Margarita",
1200,
"Margarita.png");
pizza1.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Dough",
200,
"Dough.png",
"DoughBase.png",
Categories.Dough,
5));
pizza1.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Bacon",
200,
"Bacon.png",
"BaconBase.png",
Categories.Meat,
500));
pizza1.Order = expectedOrder;
PizzaItem pizza2 = new PizzaItem(
Guid.NewGuid(),
"Margarita",
1200,
"Margarita.png");
pizza2.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Dough",
200,
"Dough.png",
"DoughBase.png",
Categories.Dough,
5));
pizza2.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Cheese",
150,
"Cheese.png",
"CheeseBase.png",
Categories.Cheese,
10));
pizza2.Order = expectedOrder;
OrderDto actualOrder = DtoBuilder.ToDto(expectedOrder);
base.AssertOrdersAreEqual(expectedOrder, actualOrder);
}
public void RemovePizza(PizzaItem pizza)
{
pizzaList.Remove(pizza);
foreach (KeyValuePair <long, List <PizzaItem> > pair in orderPreparator)
{
if (pair.Value.Contains(pizza))
{
pair.Value.Remove(pizza);
break;
}
}
}
public IActionResult Update(int id, string ingids, PizzaItem item)
{
var pizza = db.Find(id);
if (pizza == null)
{
return(NotFound());
}
db.Update(id, ingids, item);
return(new NoContentResult());
}
public static PizzaItem ToEntity(PizzaItemDto pizzaItemDto)
{
var pizzaItem = new PizzaItem(Guid.NewGuid(),
pizzaItemDto.Name,
pizzaItemDto.TotalCost,
pizzaItemDto.ImageUrl);
foreach (var ingredientDto in pizzaItemDto.Ingredients)
{
pizzaItem.Ingredients.Add(ToEntity(ingredientDto));
}
return(pizzaItem);
}
public void ToPizzaItemEntity_IngredientsAreNull_NullReferenceException()
{
PizzaItemDto expected = new PizzaItemDto(
"Margarita",
200,
"Margarita.png",
DateTime.Now,
new List <IngredientDto>());
expected.Ingredients = null;
PizzaItem actual = EntityBuilder.ToEntity(expected);
}
public void AddPizza(PizzaItem pizza, long idShop)
{
pizzaList.Add(pizza);
if (orderPreparator.ContainsKey(idShop))
{
orderPreparator[idShop].Add(pizza);
}
else
{
orderPreparator.Add(idShop, new List <PizzaItem>());
orderPreparator[idShop].Add(pizza);
}
}
public void DelIngridient(long pizzaid, long ingid)
{
PizzaItem item = db.PizzaItems
.Include(p => p.AdditionalIngridients)
.Where(p => p.Id == pizzaid)
.FirstOrDefault();
AdditionalItem ingridient = db.AdditionalItems.Find(ingid);
if (item.AdditionalIngridients.Contains(ingridient))
{
item.AdditionalIngridients.Remove(db.AdditionalItems.Find(ingid));
}
db.SaveChanges();
}
public void ToPizzaItemDto_IngredientsAreNull_NullReferenceException()
{
PizzaItem expected = new PizzaItem(
Guid.NewGuid(),
"Margarita",
200,
"Margarita.png");
expected.Order = new Order();
expected.Ingredients = null;
PizzaItemDto actual = DtoBuilder.ToDto(expected);
}
protected void AssertPizzaItemsAreEqualEntities(PizzaItem pizzaItem, PizzaItemDto pizzaItemDto)
{
Assert.AreEqual(pizzaItem.Name, pizzaItemDto.Name);
Assert.AreEqual(pizzaItem.TotalCost, pizzaItemDto.TotalCost);
Assert.AreEqual(pizzaItem.Ingredients.Count, pizzaItemDto.Ingredients.Count);
for (int i = 0; i < pizzaItem.Ingredients.Count; i++)
{
Ingredient expectedIngredient = pizzaItem.Ingredients.ElementAt(i);
IngredientDto actualIngredientDto = pizzaItemDto.Ingredients.ElementAt(i);
this.AssertIngredientsAreEqual(expectedIngredient, actualIngredientDto);
}
}
public static PizzaItemDto ToDto(PizzaItem pizzaItem)
{
PizzaItemDto pizzaItemDto = new PizzaItemDto(
pizzaItem.Name,
pizzaItem.TotalCost,
pizzaItem.ImageUrl,
pizzaItem.Order.Date,
new List <IngredientDto>());
foreach (var ingredient in pizzaItem.Ingredients)
{
pizzaItemDto.Ingredients.Add(ToDto(ingredient));
}
return(pizzaItemDto);
}
public void ToPizzaItemEntity_IngredientsAreEmpty_PizzaItemDtoIsEqualToPizzaItem()
{
PizzaItemDto expected = new PizzaItemDto(
"Margarita",
200,
"Margarita.png",
DateTime.Now,
new List <IngredientDto>());
expected.Ingredients = new List <IngredientDto>();
PizzaItem actual = EntityBuilder.ToEntity(expected);
base.AssertPizzaItemsAreEqualEntities(actual, expected);
}
public void ToPizzaItemDto_IngredientsAreEmpty_PizzaItemDtoIsEqualToPizzaItem()
{
PizzaItem expected = new PizzaItem(
Guid.NewGuid(),
"Margarita",
200,
"Margarita.png");
expected.Order = new Order();
expected.Ingredients = new List <Ingredient>();
PizzaItemDto actual = DtoBuilder.ToDto(expected);
base.AssertPizzaItemsAreEqual(expected, actual);
}
private async Task AddItem()
{
UpdatePrice();
var items = StateContainer.Items;
PizzaItem item = new PizzaItem
{
ItemId = new Guid(),
Qty = Qty,
SizeId = SelectedSize.SizeId,
TypeId = PizzaInfo.Type.Where(o => o.TypeName == PizzaName).FirstOrDefault().TypeId,
ToppingId = SelectedTopping.ToArray(),
Subtotal = SubtotalPrice,
Tax = TaxPrice,
Total = TotalPrice
};
items.Add(item);
StateContainer.SetItems(items);
}
public void ToPizzaItemDto_OrderIsNull_NullReferenceException()
{
PizzaItem expected = new PizzaItem(
Guid.NewGuid(),
"Margarita",
200,
"Margarita.png");
expected.Order = null;
expected.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Dough",
200,
"Dough.png",
"DoughBase.png",
Categories.Dough,
5));
PizzaItemDto actual = DtoBuilder.ToDto(expected);
}
public void ToPizzaItemEntity_OrderIsEmpty_PizzaItemDtoIsEqualToPizzaItem()
{
PizzaItemDto expected = new PizzaItemDto(
"Margarita",
200,
"Margarita.png",
DateTime.Now,
new List <IngredientDto>());
expected.Ingredients.Add(new IngredientDto(
"Dough",
200,
"Dough.png",
"DoughBase.png",
new CategoryDto(Categories.Dough.ToString()),
5));
PizzaItem actual = EntityBuilder.ToEntity(expected);
base.AssertPizzaItemsAreEqualEntities(actual, expected);
}
public void Update(long id, string ingids, PizzaItem item)
{
PizzaItem olditem = db.PizzaItems.Find(id);
olditem.Name = item.Name;
olditem.Price = item.Price;
olditem.Description = item.Description;
olditem.Image = item.Image;
olditem.Ingredients = item.Ingredients;
olditem.IsActive = item.IsActive;
olditem.IsNew = item.IsNew;
olditem.Dough = item.Dough;
olditem.OptionalIngredients = item.OptionalIngredients;
try
{
StringBuilder clearingids = new StringBuilder();
foreach (char c in ingids)
{
if ((c >= '0' && c <= '9') || (c == ','))
{
clearingids.Append(c);
}
}
List <long> ids = clearingids.ToString().Split(',').Select(Int64.Parse).ToList();
foreach (long ingid in ids)
{
AddIngridient(item.Id, ingid);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
db.SaveChanges();
}
}
public void ToPizzaItemDto_OrderIsEmpty_PizzaItemDtoIsEqualToPizzaItem()
{
PizzaItem expected = new PizzaItem(
Guid.NewGuid(),
"Margarita",
200,
"Margarita.png");
expected.Order = new Order();
expected.AddIngredient(new Ingredient(
Guid.NewGuid(),
"Dough",
200,
"Dough.png",
"DoughBase.png",
Categories.Dough,
5));
PizzaItemDto actual = DtoBuilder.ToDto(expected);
base.AssertPizzaItemsAreEqual(expected, actual);
}
public void Create(string ingids, PizzaItem item)
{
db.Add(ingids, item);
}
public PizzaDetailPage(PizzaItem pizza, int shopId)
{
BindingContext = new PizzaDetailViewModel(pizza, shopId);
InitializeComponent();
}
