public void Store(Basket basket)
{
if (basket == null)
{
throw new ArgumentNullException(nameof(basket));
}
if (!Validate(basket))
{
throw new BasketServiceException("Basket not valid.");
}
//should be rolled back when storing goes wrong
basket.Created = basket.Created ?? DateTime.Now;
basket.Modified = DateTime.Now;
//update items as well
basket.Contents.ToList().ForEach(item =>
{
item.Id = item.Id ?? Guid.NewGuid().ToString();
item.Created = item.Created ?? DateTime.Now;
item.Modified = DateTime.Now;
});
//store it
_repository.Add(basket);
}
public Model.Basket CreateBasket()
{
var basket = new Model.Basket();
_basketRepository.Add(basket);
return(basket);
}
private BasketViewModel GetOrCreateBasketForUser(string userId)
{
var baskets = _basketRepository.GetAll()
.Include(b => b.Items)
.ThenInclude(item => item.Product);
var basket = baskets.FirstOrDefault(basket => basket.BuyerId == userId);
if (basket == null)
{
basket = new Models.Entities.Basket(userId);
_basketRepository.Add(basket);
return(new BasketViewModel()
{
BuyerId = basket.BuyerId,
Id = basket.Id,
Items = new List <BasketItem>()
});
}
return(new BasketViewModel()
{
Id = basket.Id,
Items = basket.Items.ToList(),
BuyerId = basket.BuyerId
});
}
public async Task <Basket> GetOrCreateBasketforUserAsync(string userId)
{
//find the first basket that belongs to user
var basket = (await _basketRepository.Find(new BasketFilterObject()
{
UserId = userId
}))?.FirstOrDefault();
//if there is no basket present create one.
if (basket == null)
{
basket = new Basket
{
UserId = userId,
CreatedAt = DateTime.UtcNow
};
basket = await _basketRepository.Add(basket);
return(basket);
}
return(basket);
}
public async Task Add(BasketDTO AddDTO)
{
await _basketRepository.Add(_Mapper.Map <Basket>(AddDTO));
await _basketRepository.Commit();
await _basketRepository.DisposeAsync();
}
public async Task <ActionResult <BasketDto> > Post(BasketForCreationDto basketForCreationDto)
{
var basket = _mapper.Map <Basket>(basketForCreationDto);
await _basketRepository.Add(basket);
return(CreatedAtAction(nameof(Get), new { basketId = basket.BasketId }, _mapper.Map <BasketDto>(basket)));
}
public async Task <UpsertBasketItemResult> UpsertBasketItem(
UpsertBasketItemInput input,
[Service] IBasketRepository repository)
{
var item = new BasketItem(input.Id, input.CustomerId, input.ProductId, input.Quantity);
repository.Add(item);
return(await Task.FromResult(new UpsertBasketItemResult(item.BasketItemId, item.CustomerId, input.ProductId, input.Quantity)));
}
public ICommandResult Execute(AddItemToBasketCommand command)
{
if (command.ProductIds == null)
{
throw new ArgumentNullException();
}
var exceptions = new List <Exception>();
foreach (var productId in command.ProductIds)
{
try
{
var userBasket = _basketRepository.GetUserBasket(command.UserId);
if (userBasket != null)
{
AddItemsToBasket(productId, userBasket);
_basketRepository.Edit(userBasket);
}
else
{
var basket = new Basket();
AssignToUser(command, basket);
AddItemsToBasket(productId, basket);
_basketRepository.Add(basket);
}
}
catch (Exception exception)
{
_logger.Error(exception.Message);
exceptions.Add(exception);
return(new FailureResult(BasketCommandMessage.AddingItemToBasketFaild));
}
}
if (exceptions.Any())
{
throw new AggregateException(exceptions);
}
_unitOfWork.Commit();
return(new SuccessResult(BasketCommandMessage.ItemAddedToBasketSuccessfully));
}
public async Task CreateBasket(BasketInPut basketInPut)
{
var result = await _basketRepository.GetAsync(basketInPut.UserId);
if (result == null)
{
var basket = new Basket(basketInPut.UserId);
_basketRepository.Add(basket);
await _basketRepository.UnitOfWork.SaveChangesAsync();
}
}
public async Task <BasketDto> GenerateEmptyBasket()
{
var basket = new BasketView();
basket.Handle();
_basketRepository.Add(basket);
await _unitOfWork.CommitAsync();
return(new BasketDto(basket.Id));
}
public override void Add(Basket entity)
{
if (_productService.IsAvailableInStock(entity.ProductId) && _productService.IsValidEndDateForSell(entity.ProductId))
{
if (entity.Amount == 0)
{
entity.Amount = 1;
}
_repository.Add(entity);
}
else
{
throw new SampleEcommerceException("Bu ürün sepete eklenemez.");
}
}
public async Task <bool> Create(Guid userId)
{
if (userId == Guid.Empty)
{
throw new ArgumentNullException(nameof(userId));
}
Basket newBasket = new Basket()
{
Id = Guid.NewGuid(),
UserId = userId,
DateCreated = DateTime.Now
};
return(await _basketRepository.Add(newBasket));
}
public void ItemIsAddedToBasket()
{
var request = new ShoppingCartItem
{
Customer = Name,
ProductId = "testProduct",
Quantity = 2,
UnitPrice = 1.50m
};
var sut = new Basket(CreateMockCustomerRepo(), _basketRepository, _paymentServie, _messager);
sut.Add(request);
A.CallTo(() => _basketRepository.Add(request)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task Consume(ConsumeContext <ICreateBasketEvent> context)
{
try
{
var basket = new Basket(
context.Message.BasketRef
, context.Message.ProductId
, context.Message.Quantity
, context.Message.ProductPrice);
_basketRepository.Add(basket);
_logger.LogInformation($"Basket ref: {context.Message.BasketRef} is about to create");
await _basketRepository.UnitOfWork.SaveEntitiesAsync();
var basketResult = (await _basketRepository.FindByConditionAsync(bk => bk.BasketRef == context.Message.BasketRef)).Single();
var basketItems = new List <JsonBasketItem>();
foreach (var item in basketResult.BasketItems)
{
var product = (await _productRepository.FindByConditionAsync(p => p.Id == item.GetProductId)).Single();
basketItems.Add(new JsonBasketItem
{
Quantity = item.Quantity,
Price = item.Amount,
ProductName = product.Name,
ProductRef = product.ProductRef
});
}
await context.RespondAsync <IBasketPlacedSuccessfullyEvent>(
new BasketPlacedSuccessfullyEvent(context.Message.BasketRef, basketResult.GetTotal, basketItems));
_logger.LogInformation($"Basket ref: {context.Message.BasketRef} is created & notified");
}
catch (Exception ex)
{
_logger.LogInformation($"Basket ref: {context.Message.BasketRef} process failed with error {ErrorUtility.BuildExceptionDetail(ex)}");
await context.RespondAsync <IBasketProcessFailedEvent>(
new BasketProcessFailedEvent(context.Message.BasketRef
, ErrorUtility.BuildExceptionDetail(ex)));
}
}
public IActionResult Add(string itemId)
{
try
{
if (string.IsNullOrEmpty(itemId))
{
return(BadRequest("No ID Provided"));
}
var result = _basketRepo.Add(itemId);
return(Ok(result));
}
catch (Exception)
{
return(StatusCode(500, "Something went wrong"));
}
}
public IActionResult CheckoutBasket(string BuyerId, Dictionary <string, int> items)
{
if (BuyerId == null)
{
RedirectToPage("Basket");
}
if (ModelState.IsValid)
{
var basket = _basketRepository.GetAll()
.Include(basket => basket.Items)
.ThenInclude(item => item.Product)
.FirstOrDefault(basket => basket.BuyerId == BuyerId);
if (basket == null)
{
basket = new Models.Entities.Basket(User.FindFirstValue(ClaimTypes.NameIdentifier));
_basketRepository.Add(basket);
}
var OrderItems = new List <OrderItem>();
foreach (var item in basket.Items)
{
if (items.TryGetValue(item.Id.ToString(), out var quantity))
{
OrderItems.Add(new OrderItem(item.Product.Id, item.Price, quantity));
}
}
OrderViewModel ovm = new OrderViewModel()
{
Order = new Order()
{
BuyerId = BuyerId,
Status = OrderStatus.Pending,
CheckoutDate = DateTime.Now
},
OrderItems = OrderItems
};
return(View(ovm));
}
return(BadRequest());
}
public ResponseView <string> ToBasket(BasketRequestView requestView)
{
requestView.CheckRequest();
var basket = _basketRepository.GetFirstOrDefault(x => x.UserId == requestView.userid);
var skus = _skuRepository.GetSkus(requestView.skuids);
if (basket == null)
{
basket = new Basket
{
UserId = requestView.userid
};
_basketRepository.Add(basket);
}
var results = "";
foreach (var item in skus)
{
basket.AddItem(item);
results = string.Concat(results, results, item.Id, ",");
foreach (var subItem in requestView.pack)
{
if (item.Id == subItem.skuid)
{
basket.ChangeItemQty(item.Id, subItem.qty);
}
}
}
_basketRepository.Commit();
var response = base.OutPutBrokenResponseView(results.TrimEnd(','));
return(response);
}
/// <summary> /// Update or insert a product item in the customers shopping basket /// </summary> /// <param name="repository">The repository where this item is stored</param> /// <param name="item">The product item to upsert</param> /// <returns></returns> public BasketItem UpsertItemToBasket(BasketItem item, [Service] IBasketRepository repository) => repository.Add(item);
public void AddBasket(Basket basket)
{
ProcessBasket(basket);
_basketRepository.Add(basket);
}
public override IBasket Handle(CreateBasketMessage message)
{
message.BasketId = Guid.NewGuid();
return(_basketRepository.Add(_mapper.Map <IBasket>(message)));
}
public void Add(ShoppingCartItem request)
{
_basketRepository.Add(request);
}
