public async Task <ActionResult <BasketDTO> > UpsertBasket([FromBody] BasketDTO basketDto)
{
var discountUpdateTasks = new List <Task>();
foreach (var basketItem in basketDto.Items)
{
async Task UpdateDiscount()
{
try
{
var coupon = await _discountGrpcService.GetDiscount(basketItem.ProductName);
basketItem.Price -= coupon.Amount;
}
catch (RpcException exception) when(exception.StatusCode == Grpc.Core.StatusCode.NotFound)
{
}
}
discountUpdateTasks.Add(UpdateDiscount());
}
await Task.WhenAll(discountUpdateTasks);
var basket = await _basketRepository.UpsertBasket(_mapper.Map <Entities.Basket>(basketDto));
return(CreatedAtAction(nameof(GetBasket), new { userName = basket.UserName }, _mapper.Map <BasketDTO>(basket)));
}
public void UpdateBasket_Should_Return_Valid_Data()
{
//Arrange
var mock = new Mock <IBasketRepository>();
var myBasket = new BasketDTO
{
Id = 1,
UserId = "25"
};
mock.Setup(x => x.Update(myBasket)).Returns(
new BasketDTO
{
Id = 1,
UserId = "25"
}
);
BasketUC target = new BasketUC(mock.Object);
//Act
var result = target.UpdateBasket(new BasketBTO
{
Id = 1,
UserId = "25"
});
//Assert
mock.Verify(u => u.Update(It.IsAny <BasketDTO>()), Times.Once());
}
public BasketDTO AddProduct(ProductInsertDTO productInsertDTO)
{
if (productInsertDTO.ProductId > 0)
{
var newProductDTO = GetProductById(productInsertDTO.ProductId);
for (int i = 0; i < productInsertDTO.Amount; i++)
{
productInsertDTO.CurrentBasketProducts.Add(newProductDTO);
}
}
decimal totalSum = productInsertDTO.CurrentBasketProducts.Select(x => x.Price).Sum();
var productIdList = productInsertDTO.CurrentBasketProducts.Select(x => x.Id).ToList();
var discountDTO = _discountService.CalculateDiscount(productIdList);
BasketDTO basketDTO = new BasketDTO()
{
CurrentBasketProducts = productInsertDTO.CurrentBasketProducts,
DiscountDTO = discountDTO,
TotalCost = totalSum - discountDTO.TotalDiscount
};
_logService.LogBasketDetails(basketDTO);
return(basketDTO);
}
public BasketDTO GetBasket(int userId)
{
Mapper.Initialize(cfg => cfg.CreateMap <Purchase, PurchaseDTO>());
var purchase = Mapper.Map <PurchaseDTO>(db.Purchases.Get(userId));
if (purchase == null)
{
return(null);
}
Mapper.Initialize(cfg => cfg.CreateMap <UserSubscription, UserSubscriptionDTO>());
var items = Mapper.Map <IEnumerable <UserSubscriptionDTO> >(db.UserSubscriptions.GetAll()
.Where(us => us.PurchaseId == purchase.Id));
var subscriptionsIds = new List <int>();
foreach (var item in items)
{
subscriptionsIds.Add(item.SubscriptionId);
}
Mapper.Initialize(cfg => cfg.CreateMap <Subscription, SubscriptionDTO>());
var subscriptions = Mapper.Map <IEnumerable <Subscription>, IEnumerable <SubscriptionDTO> >(db.Subscriptions.GetAll()
.Where(s => subscriptionsIds.Contains(s.Id)));
var basket = new BasketDTO()
{
UserId = userId, PurchaseId = purchase.Id
};
basket.SubscriptionsList.AddRange(subscriptions);
return(basket);
}
public Response <BasketDTO> Create(BasketDTO basket)
{
try
{
basket.Status = DTO.Entities.ModelEnums.Status.Active;
basket.UpdateDate = DateTime.Now;
basket.UploadDate = DateTime.Now;
Basket entity = null;
entity = Map <Basket>(basket);
_basketRepository.Create(entity);
_unitOfWork.SaveChanges();
basket.Id = entity.Id;
return(new Response <BasketDTO>()
{
IsSuccess = true, Message = "Ürün Sepete Eklendi.", Result = basket
});
}
catch (Exception ex)
{
return(new Response <BasketDTO>()
{
IsSuccess = false, Exception = ex, Message = "Hata oluştu."
});
}
}
public void GetBasketById_Should_Return_Valid_Data()
{
//Arrange
var mock = new Mock <IBasketRepository>();
var myBasket = new BasketDTO
{
Id = 1,
UserId = "25"
};
mock.Setup(x => x.GetById(1)).Returns(
new BasketDTO
{
Id = 1,
UserId = "25"
}
);
BasketUC target = new BasketUC(mock.Object);
//Act
var result = target.GetBasketById(1);
//Assert
Assert.AreEqual(result.Id, 1);
Assert.AreEqual(result.UserId, "25");
}
public void UpdateBasket_Should_Return_Null_If_Bto_Is_Null()
{
//Arrange
var mock = new Mock <IBasketRepository>();
var myBasket = new BasketDTO
{
Id = 1,
UserId = "25"
};
mock.Setup(x => x.Update(myBasket)).Returns(
new BasketDTO
{
Id = 1,
UserId = "25"
}
);
BasketUC target = new BasketUC(mock.Object);
//Act
var result = target.UpdateBasket(null);
//Assert
Assert.IsNull(result);
}
public async Task <BasketDTO> GetBasketAsync(int id)
{
await using var connection = new SqlConnection(_connectionString);
BasketDTO resultBasket = null;
var queryResult = await connection.QueryAsync <BasketDTO, BasketItemDTO, BasketDTO>(
"SELECT b.[Id] as Id, bi.[Id] as BasketItemId, bi.[ProductId], bi.[Quantity] " +
"FROM [Basket].[Baskets] b " +
"INNER JOIN [Basket].[BasketItems] bi on bi.BasketId = b.[Id] " +
$"WHERE b.[Id]={id}",
(basket, basketItem) =>
{
if (resultBasket == null)
{
resultBasket = basket;
resultBasket.Items = new List <BasketItemDTO>();
}
resultBasket.Items.Add(basketItem);
return(resultBasket);
},
splitOn : "BasketItemId");
return(queryResult.FirstOrDefault());
}
public UnitTest()
{
userRepoMock = new Mock <IUserRepository>();
itemRepoMock = new Mock <IItemRepository>();
basketRepoMock = new Mock <IBasketRepository>();
var options = new DbContextOptionsBuilder <ApiContext>().UseInMemoryDatabase("TestDb").ConfigureWarnings(x => x.Ignore(InMemoryEventId.TransactionIgnoredWarning)).Options;
context = new ApiContext(options);
basketService = new BasketService(basketRepoMock.Object, userRepoMock.Object, itemRepoMock.Object, context);
List <BasketDTO> basketDTOList = new List <BasketDTO>();
basketRepoMock.Setup(x => x.CreateorUpdateBasket(It.IsAny <AddedItemDTO>()))
.Callback((AddedItemDTO addedItem) => {
BasketDTO basketDTO = new BasketDTO();
basketDTO.ItemId = addedItem.Item.Id;
basketDTOList.Add(basketDTO);
}
);
basketRepoMock.Setup(x => x.GetUserBasket(It.IsAny <int>())).Returns(basketDTOList);
itemRepoMock.Setup(x => x.StockCheck(It.IsAny <AddedItemDTO>())).Returns(true);
userRepoMock.Setup(x => x.UserExist(It.IsAny <int>())).Returns(true);
itemRepoMock.Setup(x => x.UpdateCompanyStock(It.IsAny <AddedItemDTO>()));
}
public void AddBook(string t, int id)
{
BasketDal dal2 = new BasketDal(ConfigurationManager.ConnectionStrings["IMDB"].ConnectionString);
using (SqlConnection conn = new SqlConnection(connStr))
using (SqlCommand comm = conn.CreateCommand())
{
conn.Open();
comm.CommandText = $"select * from Books where Title = '{t}'";
SqlDataReader reader = comm.ExecuteReader();
BooksDTO Book = new BooksDTO();
while (reader.Read())
{
Book.BookID = (int)reader["BookID"];
Book.Author = reader["Autor"].ToString();
Book.Price = (Decimal)reader["Price"];
}
conn.Close();
BasketDTO m = new BasketDTO
{
Title = t,
UserID = id,
BookID = Book.BookID,
StatusID = 3,
Author = Book.Author,
Price = Book.Price,
Amount = 1,
Date = DateTime.Now
};
m = dal2.CreateBasket(m);
}
}
public void GetBasketTest()
{
BasketDAL dal = new BasketDAL(ConfigurationManager.ConnectionStrings["IMDB"].ConnectionString);
BasketDTO result = new BasketDTO(dal);
Assert.IsTrue(result.GetBasket(5).BasketID == 5, "Cannot find the item");
}
private static void NewOne()
{
BasketDal dal = new BasketDal(ConfigurationManager.ConnectionStrings["IMDB"].ConnectionString);
BasketDTO m = new BasketDTO
{
// BasketID = 2,
Title = "Mizery",
UserID = 1,
BookID = 1,
StatusID = 2,
Author = "King",
Price = 150,
Amount = 1,
Date = DateTime.Now
};
m = dal.CreateBasket(m);
Console.WriteLine($"New basket ID: {m.Title}");
foreach (var basket in dal.GetAllBaskets())
{
Console.WriteLine($"{basket.BasketID}\t{basket.Title}\t{basket.Price}");
}
Console.WriteLine($"Deleting basket ID: {m.BasketID}");
dal.DeleteBasket(m.BasketID);
foreach (var basket in dal.GetAllBaskets())
{
Console.WriteLine($"{basket.BasketID}\t{basket.Title}\t{basket.Price}");
}
}
public void Get_User_Basket_Returns_BasketDto()
{
var basketDtoList = new List <BasketDTO>();
var basketDto = new BasketDTO
{
Id = 1,
ItemId = 1,
ItemCount = 1
};
basketDtoList.Add(basketDto);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.CreateMap <BasketDTO, Basket>().ReverseMap();
});
var mapper = mockMapper.CreateMapper();
var options = new DbContextOptionsBuilder <ApiContext>()
.UseInMemoryDatabase("user_basket_test_db")
.Options;
using (var context = new ApiContext(options))
{
context.LoadUserBasketTestData(1);
var repository = new BasketRepository(context, mapper);
var tst = basketDtoList.First();
var act = repository.GetUserBasket(1).First();
Assert.True(tst.ItemId == act.ItemId && tst.ItemCount == act.ItemCount && tst.Id == act.Id);
}
}
public async Task <ActionResult <Basket> > UpdateBasket(BasketDTO basketDTO)
{
List <BasketItem> items = new List <BasketItem>();
foreach (BasketItemDTO itemek in basketDTO.BasketItems)
{
items.Add(new BasketItem
{
Id = itemek.Id,
ProductName = itemek.ProductName,
Price = itemek.Price,
Quantity = itemek.Quantity,
PictureUrl = itemek.PictureUrl,
TypeId = itemek.TypeId
});
}
var basketchecked = new Basket
{
Id = basketDTO.Id,
CustomOrderItems = basketDTO.CustomOrderItems,
BasketItems = items
};
var updatedBasket = await _basketRepository.UpdateBasketAsync(basketchecked);
return(Ok(updatedBasket));
}
private void AddButton(object sender, RoutedEventArgs e)
{
BasketDTO basket = (BasketDTO)dataGrid2.SelectedItem;
_basketViewModel.ADD(TitleBox2.Text);
_basketViewModel.Update();
dataGrid2.Items.Refresh();
}
public async Task <BasketDTO> UpdateBasketAsync(BasketDTO basket)
{
var customBasket = await _basketRepository.UpdateBasketAsync(_mapper.Map <BasketDTO, CustomBasket>(basket));
_mapper.Map(basket, customBasket);
return(basket);
}
public async Task Checkout(BasketDTO basket, string userToken)
{
var updateBasketUri = Infrastructure.Basket.CheckoutBasket(_basketByPassUrl);
var response = await _apiClient.PostAsync(updateBasketUri, basket, userToken);
response.EnsureSuccessStatusCode();
}
public async Task Add(BasketDTO AddDTO)
{
await _basketRepository.Add(_Mapper.Map <Basket>(AddDTO));
await _basketRepository.Commit();
await _basketRepository.DisposeAsync();
}
public IActionResult PostInvokeSuggetionMatch()
{
// TODO: Send a request/function call (from lib) that generates 1000 baskets
BasketDTO[] list = new BasketDTO[4];
return(Ok(list));
}
public Basket(BasketViewModel vm)
{
Baskett = new BasketDTO();
_basketCollection = (CollectionViewSource)(Resources["BasketCollection"]);
_basketViewModel = vm;
DataContext = vm;
InitializeComponent();
}
public async Task Checkout(BasketDTO basket)
{
var uri = API.Basket.CheckoutBasket(_basketByPassUrl);
var basketContent = new StringContent(JsonConvert.SerializeObject(basket), System.Text.Encoding.UTF8, "application/json");
var response = await _apiClient.PostAsync(uri, basketContent);
response.EnsureSuccessStatusCode();
}
public void Do(BasketId basketId)
{
BasketDTO basket = _basketRepository.Get(basketId.ConsumerId, basketId.Id);
if (basket != null)
{
_basketRepository.Delete(basketId.ConsumerId, basketId.Id);
}
}
private void ConsumerHasBasket()
{
BasketDTO basket = A.Fake <BasketDTO>();
A.CallTo(() => basket.Id)
.Returns(_basketId);
A.CallTo(() => _basketRepository.Get(_consumerId))
.Returns(basket);
}
public async Task Checkout(BasketDTO basket)
{
var uri = $"{_settings.Value.BasketUrl}/api/v1/basket/checkout";
var basketContent = new StringContent(JsonConvert.SerializeObject(basket), System.Text.Encoding.UTF8, "application/json");
var response = await _apiClient.PostAsync(uri, basketContent);
response.EnsureSuccessStatusCode();
}
public async Task Checkout(BasketDTO basket)
{
var token = await GetUserTokenAsync();
var updateBasketUri = API.Basket.CheckoutBasket(_remoteServiceBaseUrl);
var response = await _apiClient.PostAsync(updateBasketUri, basket, token);
response.EnsureSuccessStatusCode();
}
public BasketDTO Create(BasketDTO obj)
{
var basket = obj.DtoToBasket();
contextDB.Users.First(x => x.Id == obj.UserId);
basket.ShoppingMeals.ToList().ForEach(x => contextDB.Attach(x.Meal));
contextDB.Baskets.Add(basket);
contextDB.SaveChanges();
return(basket.BasketToDTO());
}
public static Basket ToModel(this BasketDTO basket, Guid ownerId)
{
return(new Basket
{
Id = basket.Id,
Items = basket.Items.Select(ToModel).ToList(),
OwnerId = ownerId,
Status = basket.Status
});
}
public BasketDTO CreateBasket(BasketDTO basket)
{
using (var entities = new IMDBEntities())
{
Basket b = _mapper.Map<Basket>(basket);
entities.Basket.Add(b);
entities.SaveChanges();
return _mapper.Map<BasketDTO>(b);
}
}
public async Task Checkout(BasketDTO basket)
{
var uri = API.Basket.CheckoutBasket(_basketByPassUrl);
var basketContent = new StringContent(JsonSerializer.Serialize(basket), System.Text.Encoding.UTF8, "application/json");
_logger.LogInformation("Uri chechout {uri}", uri);
var response = await _apiClient.PostAsync(uri, basketContent);
response.EnsureSuccessStatusCode();
}
public bool Checkout([FromBody] BasketDTO basketDto)
{
var order = basketDto.OrderInfo.MapToOrder();
if (order != null)
{
order.Complete = true;
order = (Order)order.Save();
}
return(order != null);
}
