public void SetUp()
{
_pizzaSizeRepository = new Mock <IPizzaSizeRepository>();
_pizzaSizeRepository.Setup(x => x.GetByIds(It.IsAny <int>(), It.IsAny <int>())).Returns(() =>
new GetPizzaSizeResponse
{
HasError = true,
Error = new Error
{
UserMessage = "An error has occured"
}
});
_toppingSizeRepository = new Mock <IToppingSizeRepository>();
_voucherService = new Mock <IVoucherService>();
_subject = new UserSessionService(_pizzaSizeRepository.Object, _toppingSizeRepository.Object, _voucherService.Object);
_result = _subject.NewUser();
var basketData = new BasketData
{
PizzaId = 1,
SizeId = 2,
ExtraToppingIds = new List <int>
{
3,
4
}
};
_subject.AddItemToBasket(_result, basketData);
_basket = _subject.GetBasketForUser(_result);
}
private StudentBasketRequest MapToStudentBasketRequest(BasketData basketData)
{
if (basketData == null)
{
return(null);
}
var map = new StudentBasketRequest
{
Studentid = basketData.StudentId
};
basketData.Items.ToList().ForEach(item => map.Items.Add(new BasketItemResponse
{
Id = item.Id,
Oldslotamount = (double)item.OldSlotAmount,
Pictureurl = item.PictureUrl,
Scholarshipitemid = item.ScholarshipItemId,
ScholarshipItemname = item.ScholarshipItemName,
Slots = item.Slots,
Slotamount = (double)item.SlotAmount
}));
return(map);
}
public async Task <OrderData> GetOrderDraftAsync(BasketData basketData)
{
return(await _daprClient.InvokeMethodAsync <BasketData, OrderData>(
DaprAppId,
$"api/v1/orders/draft",
basketData));
}
private BasketData MapToBasketData(StudentBasketResponse studentBasketRequest)
{
if (studentBasketRequest == null)
{
return(null);
}
var map = new BasketData
{
StudentId = studentBasketRequest.Studentid
};
studentBasketRequest.Items.ToList().ForEach(item => map.Items.Add(new BasketDataItem
{
Id = item.Id,
OldSlotAmount = (decimal)item.Oldslotamount,
PictureUrl = item.Pictureurl,
ScholarshipItemId = item.Scholarshipitemid,
ScholarshipItemName = item.ScholarshipItemname,
Slots = item.Slots,
SlotAmount = (decimal)item.Slotamount
}));
return(map);
}
private OrderData MapToResponse(GrpcOrdering.OrderDraftDTO orderDraft, BasketData basketData)
{
if (orderDraft == null)
{
return(null);
}
var data = new OrderData
{
Buyer = basketData.BuyerId,
Total = (decimal)orderDraft.Total,
};
orderDraft.OrderItems.ToList().ForEach(o => data.OrderItems.Add(new OrderItemData
{
Discount = (decimal)o.Discount,
PictureUrl = o.PictureUrl,
ProductId = o.ProductId,
ProductName = o.ProductName,
UnitPrice = (decimal)o.UnitPrice,
Units = o.Units,
}));
return(data);
}
//--------------------------------------------------------
Basket Spawn(BasketData bd)
{
GameObject go = null;
lastSpawnPos = new Vector3(bd.offset.x, lastSpawnPos.y + bd.offset.y, 0f);
GameObject prototype = bd.isNormal ? prototype_Basket_Normal : prototype_Basket_Rare;
go = Instantiate(
prototype,
lastSpawnPos,
Quaternion.Euler(0f, 0f, bd.throwRotation),
transform
);
Basket b = go.GetComponent <Basket>();
b.score = bd.score;
if (bd.waypoints != null && bd.waypoints.Length > 0)
{
go.AddComponent <BasketMover>().SetData(bd, speedScale);
}
return(b);
}
private BasketData MapToBasketData(CustomerBasketResponse customerBasketRequest)
{
if (customerBasketRequest == null)
{
return(null);
}
var map = new BasketData
{
BuyerId = customerBasketRequest.Buyerid
};
customerBasketRequest.Items.ToList().ForEach(item =>
{
if (item.Id != null)
{
map.Items.Add(new BasketDataItem
{
Id = item.Id,
OldUnitPrice = (decimal)item.Oldunitprice,
PictureUrl = item.Pictureurl,
ProductId = item.Productid,
ProductName = item.Productname,
Quantity = item.Quantity,
UnitPrice = (decimal)item.Unitprice
});
}
});
return(map);
}
private CustomerBasketRequest MapToCustomerBasketRequest(BasketData basketData)
{
if (basketData == null)
{
return(null);
}
var map = new CustomerBasketRequest
{
Buyerid = basketData.BuyerId
};
basketData.Items.ToList().ForEach(item =>
{
if (item.Id != null)
{
map.Items.Add(new BasketItemResponse
{
Id = item.Id,
Oldunitprice = (double)item.OldUnitPrice,
Pictureurl = item.PictureUrl,
Productid = item.ProductId,
Productname = item.ProductName,
Quantity = item.Quantity,
Unitprice = (double)item.UnitPrice
});
}
});
return(map);
}
public async Task Update(BasketData currentBasket)
{
var token = await GetUserTokenAsync();
var data = await _apiClient.PostAsync <BasketData>(_urls.Basket + UrlsConfig.BasketOperations.UpdateBasket(), currentBasket, token);
int i = 0;
}
public async Task UpdateAsync(BasketData currentBasket)
{
_logger.LogDebug("Grpc update basket currentBasket {@currentBasket}", currentBasket);
var request = MapToCustomerBasketRequest(currentBasket);
_logger.LogDebug("Grpc update basket request {@request}", request);
await _basketClient.UpdateBasketAsync(request);
}
public async Task <OrderData> GetOrderDraftFromBasket(BasketData basket)
{
var url = _urls.Orders + UrlsConfig.OrdersOperations.GetOrderDraft();
var response = await _apiClient.PostAsync <BasketData>(url, basket);
response.EnsureSuccessStatusCode();
var jsonResponse = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <OrderData>(jsonResponse));
}
public async Task <OrderData> GetOrderDraftAsync(BasketData basketData)
{
var requestUri = "api/v1/orders/draft";
var response = await _httpClient.PostAsJsonAsync(requestUri, basketData);
response.EnsureSuccessStatusCode();
return(await response.Content.ReadFromJsonAsync <OrderData>());
}
public void PopulateBasket(Guid customerid, BasketData basketData)
{
Basket basket = new Basket();
basket.CustomerId = customerid;
basket.ProductId = basketData.ProductId;
basket.Quantity = basketData.Quantity;
basket.UnitPrice = basketData.UnitPrice;
_context.Basket.Add(basket);
_context.SaveChanges();
}
public async Task <OrderData> GetOrderDraftAsync(BasketData basketData)
{
_logger.LogDebug(" grpc client created, basketData={@basketData}", basketData);
var command = MapToOrderDraftCommand(basketData);
var response = await _orderingGrpcClient.CreateOrderDraftFromBasketDataAsync(command);
_logger.LogDebug(" grpc response: {@response}", response);
return(MapToResponse(response, basketData));
}
public async Task UpdateAsync(BasketData currentBasket)
{
await GrpcCallerService.CallService(_urls.GrpcBasket, async channel =>
{
var client = new Basket.BasketClient(channel);
_logger.LogDebug("Grpc update basket currentBasket {@currentBasket}", currentBasket);
var request = MapToCustomerBasketRequest(currentBasket);
_logger.LogDebug("Grpc update basket request {@request}", request);
return(await client.UpdateBasketAsync(request));
});
}
public async Task <OrderData> GetOrderDraftFromBasketAsync(BasketData basket)
{
var uri = _urls.Orders + UrlsConfig.OrdersOperations.GetOrderDraft();
var content = new StringContent(JsonConvert.SerializeObject(basket), System.Text.Encoding.UTF8, "application/json");
var response = await _apiClient.PostAsync(uri, content);
response.EnsureSuccessStatusCode();
var ordersDraftResponse = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <OrderData>(ordersDraftResponse));
}
public async Task UpdateAsync(BasketData currentBasket, string accessToken)
{
var request = new HttpRequestMessage(HttpMethod.Post, "api/v1/basket")
{
Content = JsonContent.Create(currentBasket)
};
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var response = await _httpClient.SendAsync(request);
response.EnsureSuccessStatusCode();
}
//--------------------------------------------------------
public void SetData(BasketData bd, float speedScale = 1f)
{
duration = bd.duration / speedScale;
delay = bd.delay;
waypoints = new Vector2[bd.waypoints.Length];
scale = bd.scale;
rotation = bd.rotation;
loopsCount = bd.loopsCount;
loopType = bd.loopType;
autoRun = bd.autoRun;
System.Array.Copy(bd.waypoints, waypoints, bd.waypoints.Length);
Start();
}
public async Task <OrderData> GetOrderDraftAsync(BasketData basketData)
{
return(await GrpcCallerService.CallService(_urls.GrpcOrdering, async channel =>
{
var client = new OrderingGrpc.OrderingGrpcClient(channel);
_logger.LogDebug(" grpc client created, basketData={@basketData}", basketData);
var command = MapToOrderDraftCommand(basketData);
var response = await client.CreateOrderDraftFromBasketDataAsync(command);
_logger.LogDebug(" grpc response: {@response}", response);
return MapToResponse(response, basketData);
}));
}
public Task UpdateAsync(BasketData currentBasket, string accessToken)
{
return(_daprClient.InvokeMethodAsync(
DaprAppId,
"api/v1/basket",
currentBasket,
new HttpInvocationOptions
{
Headers = new Dictionary <string, string>
{
[HeaderNames.Authorization] = accessToken
}
}));
}
public async Task <OrderData> GetOrderDraftFromBasketAsync(BasketData basket)
{
var uri = _urls.Orders + UrlsConfig.OrdersOperations.GetOrderDraft();
var content = new StringContent(JsonSerializer.Serialize(basket), System.Text.Encoding.UTF8, "application/json");
var response = await _apiClient.PostAsync(uri, content);
response.EnsureSuccessStatusCode();
var ordersDraftResponse = await response.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <OrderData>(ordersDraftResponse, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
}));
}
public ActionResult AddPizzaToBasket(int pizzaId, int sizeId, List <string> extraToppings)
{
var parsedExtraToppings = extraToppings.Where(x => int.TryParse(x, out _)).Select(int.Parse).ToList();
var basketItem = new BasketData
{
PizzaId = pizzaId,
SizeId = sizeId,
ExtraToppingIds = parsedExtraToppings
};
_userSessionService.AddItemToBasket(Session["UserId"].ToString(), basketItem);
return(new RedirectResult("/"));
}
public async Task <IEnumerable <BasketItem> > SaveItemsAsync(IEnumerable <BasketItem> items)
{
var request = new BasketData(items);
// Save items is a request to the Aggregator service.
var response = await _httpClient.PostAsJsonAsync(
"api/v1/basket/",
request);
response.EnsureSuccessStatusCode();
var basketData = await response.Content.ReadFromJsonAsync <BasketData>();
return(basketData !.Items);
}
public async Task <IActionResult> UpdateAllBasket([FromBody] UpdateBasketRequest data)
{
if (data.Items == null || !data.Items.Any())
{
return(BadRequest("Need to pass at least one basket line"));
}
// Retrieve the current basket
var currentBasket = await _basket.GetById(data.BuyerId);
if (currentBasket == null)
{
currentBasket = new BasketData(data.BuyerId);
}
var catalogItems = await _catalog.GetCatalogItems(data.Items.Select(x => x.ProductId));
var newBasket = new BasketData(data.BuyerId);
foreach (var bitem in data.Items)
{
var catalogItem = catalogItems.SingleOrDefault(ci => ci.Id == bitem.ProductId);
if (catalogItem == null)
{
return(BadRequest($"Basket refers to a non-existing catalog item ({bitem.ProductId})"));
}
newBasket.Items.Add(new BasketDataItem()
{
Id = bitem.Id,
ProductId = catalogItem.Id.ToString(),
ProductName = catalogItem.Name,
PictureUrl = catalogItem.PictureUri,
UnitPrice = catalogItem.Price,
Quantity = bitem.Quantity
});
}
var result = await _basket.Update(newBasket);
if (result.IsSuccessStatusCode)
{
return(Ok(newBasket));
}
return(BadRequest());
}
public IHttpActionResult AddToBasket([FromBody] AddToBasketRequest request)
{
if (request.PizzaId == 0 || request.SizeId == 0 || request.User == null)
{
return(BadRequest());
}
var basketItem = new BasketData
{
PizzaId = request.PizzaId,
SizeId = request.SizeId,
ExtraToppingIds = request.ToppingIds
};
_userSessionService.AddItemToBasket(request.User.Token, basketItem);
return(Ok(_userSessionService.GetBasketForUser(request.User.Token)));
}
//--------------------------------------------------------
public void Save()
{
if (editingBaskets == null)
{
Debug.LogWarning("Data not loaded yet");
return;
}
Debug.LogWarning("In Design mode, only the 1st level is saved");
levelData = levels[0];
Vector3 pos = Vector3.zero;
int countMoving = 0;
float sumDuration = 0f;
for (int i = 0; i < editingBaskets.Length; ++i)
{
BasketData bd = levelData.baskets[i];
Basket b = editingBaskets[i];
Transform bt = b.transform;
bd.score = b.score;
bd.offset = new Vector2(bt.localPosition.x, bt.localPosition.y - pos.y);
bd.throwRotation = bt.localRotation.eulerAngles.z;
BasketMover bm = b.GetComponent <BasketMover>();
if (bm != null)
{
bd.SaveFrom(bm);
++countMoving;
sumDuration += bm.duration;
}
else
{
bd.SetAsStatic();
}
levelData.baskets[i] = bd;
pos = bt.localPosition;
}
levelData.averageDuration = (countMoving > 0) ? (sumDuration / countMoving) : 0f;
EditorUtility.SetDirty(levelData);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public async Task <ActionResult <BasketData> > UpdateAllBasketAsync([FromBody] UpdateBasketRequest data, [FromHeader] string authorization)
{
var basket = new BasketData(data.BuyerId);
if (data.Items != null && data.Items.Any())
{
var catalogItems = await _catalog.GetCatalogItemsAsync(data.Items.Select(x => x.ProductId));
// group by product id to avoid duplicates
var itemsCalculated = data
.Items
.GroupBy(x => x.ProductId, x => x, (k, i) => new { productId = k, items = i })
.Select(groupedItem =>
{
var item = groupedItem.items.First();
item.Quantity = groupedItem.items.Sum(i => i.Quantity);
return(item);
});
foreach (var bitem in itemsCalculated)
{
var catalogItem = catalogItems.SingleOrDefault(ci => ci.Id == bitem.ProductId);
if (catalogItem == null)
{
return(BadRequest($"Basket refers to a non-existing catalog item ({bitem.ProductId})"));
}
basket.Items.Add(new BasketDataItem()
{
Id = bitem.Id,
ProductId = catalogItem.Id,
ProductName = catalogItem.Name,
PictureUrl = catalogItem.PictureUri,
UnitPrice = catalogItem.Price,
Quantity = bitem.Quantity
});
}
}
await _basket.UpdateAsync(basket, authorization);
return(basket);
}
private CreateOrderDraftCommand MapToOrderDraftCommand(BasketData basketData)
{
var command = new CreateOrderDraftCommand
{
BuyerId = basketData.BuyerId,
};
basketData.Items.ForEach(i => command.Items.Add(new BasketItem
{
Id = i.Id,
OldUnitPrice = (double)i.OldUnitPrice,
PictureUrl = i.PictureUrl,
ProductId = i.ProductId,
ProductName = i.ProductName,
Quantity = i.Quantity,
UnitPrice = (double)i.UnitPrice,
}));
return(command);
}
private CreateApplicationDraftCommand MapToApplicationDraftCommand(BasketData basketData)
{
var command = new CreateApplicationDraftCommand
{
StudentId = basketData.StudentId,
};
basketData.Items.ForEach(i => command.Items.Add(new BasketItem
{
Id = i.Id,
OldSlotAmount = (double)i.OldSlotAmount,
PictureUrl = i.PictureUrl,
ScholarshipItemId = i.ScholarshipItemId,
ScholarshipItemName = i.ScholarshipItemName,
Slots = i.Slots,
SlotAmount = (double)i.Slots,
}));
return(command);
}
private CustomerBasketRequest MapToCustomerBasketRequest(BasketData basketData)
{
if (basketData == null)
{
return(null);
}
var map = new CustomerBasketRequest
{
Buyerid = basketData.BuyerId,
Coupon = basketData.Coupon.CouponCode != null ? new CouponResponse
{
Couponcode = basketData.Coupon.CouponCode,
Expirationdate = basketData.Coupon.ExpirationDate,
Discount = (double)basketData.Coupon.Discount
} : new CouponResponse {
Discount = 0
}
};
basketData.Items.ToList().ForEach(item =>
{
if (item.Id != null)
{
map.Items.Add(new BasketItemResponse
{
Id = item.Id,
Oldunitprice = (double)item.OldUnitPrice,
Pictureurl = item.PictureUrl,
Productid = item.ProductId,
Productname = item.ProductName,
Quantity = item.Quantity,
Unitprice = (double)item.UnitPrice,
Isdiscounted = item.isDiscounted
});
}
});
return(map);
}
