public async Task <ActionResult> Update(int buyerId, Domain.Basket basket)
{
basket.BuyerId = buyerId;
await _repository.UpdateAsync(basket);
return(Ok());
}
public async Task Create(Domain.Basket basket)
{
var baskets = await _fakeDB.BasketsAsync();
if (basket.CustomerGuid == Guid.Empty)
{
basket.CustomerGuid = Guid.NewGuid();
}
baskets.Add(basket);
}
public void Get_Basket_Retrieves_Basket_From_Store()
{
const int basketId = 1;
var basket = new Domain.Basket();
_basketStore.Stub(bs => bs.Get(basketId)).Return(basket);
_basketItemStore.Stub(bis => bis.GetForBasket(basketId)).Return(new BasketItem[]{});
_basketLogic.GetBasket(basketId);
_basketStore.AssertWasCalled(bs => bs.Get(basketId));
}
public async Task AddToBasket(Domain.Basket basket)
{
var baskets = await _fakeDB.BasketsAsync();
var dbModel = baskets.FirstOrDefault(c => c.CustomerGuid == basket.CustomerGuid);
if (dbModel != null)
{
dbModel.ProductIds.AddRange(basket.ProductIds);
}
else
{
await Create(basket);
}
}
public async Task <ItemDto> Handle(AddItemCommand command, CancellationToken cancellationToken)
{
var itemFromCommand = _mapper.Map <Item>(command);
// Just for demo to show that Dapr Store working!
//var oldItem = await _daprClient.GetStateAsync<Item>("default", itemFromCommand.ItemId.ToString(), cancellationToken: cancellationToken);
var basket = await _basketRepository.GetBasketSingeOrDefault(command.Username, cancellationToken);
var isBasketNotExits = (basket == null);
if (isBasketNotExits)
{
basket = new Domain.Basket {
BasketId = Guid.NewGuid(), Username = command.Username, State = State.Unlocked
};
await _basketRepository.AddAsync(basket, cancellationToken);
await _basketRepository.SaveChangesAsync(cancellationToken);
}
var itemFromDb = await _itemRepository.GetSingleOrDefault(itemFromCommand.ItemId, cancellationToken);
itemFromCommand.BasketId = basket.BasketId;
itemFromCommand.Basket = basket;
if (itemFromDb == null)
{
await _itemRepository.AddAsync(itemFromCommand, cancellationToken);
await _itemRepository.SaveChangesAsync(cancellationToken);
}
//await _basketItemNotificationHandler.Handle(new ItemCreatedMessage(), cancellationToken);
//// Lock
//await _daprClient.SaveStateAsync(
// "default",
// State.Locked.ToString(), ConsistencyMode.Strong,new StateOptions(),
// cancellationToken: cancellationToken);
return(_mapper.Map <ItemDto>(itemFromCommand));
}
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken)
{
var userId = httpContext.Request.Headers["claims_userId"];
var basket = await cacheContext.GetAsync <Domain.Basket>(userId);
if (basket == null)
{
basket = new Domain.Basket();
}
basket.Items.Add(request.Item);
var result = await cacheContext.SetAsync(userId, basket);
if (result)
{
return(Unit.Value);
}
throw new Exception("Problem saving data");
}
public async Task <ActionResult> Create(Domain.Basket basket)
{
await _repository.CreateAsync(basket);
return(Created(string.Empty, new { }));
}
public async Task HandleAsync(CreateBasketForUserCommand command)
{
var basket = new Domain.Basket(Guid.NewGuid(), command.BuyerId);
await _shopAggregateRepositoryService.SaveAsync(basket);
}
public Task CreateAsync(Domain.Basket basket)
=> _cache.SetAsync(basket.BuyerId.ToString(), basket, new DistributedCacheEntryOptions()
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(10)
});
public Task UpdateAsync(Domain.Basket basket)
{
_baskets[basket.BuyerId] = basket;
return(Task.CompletedTask);
}
public Task CreateAsync(Domain.Basket basket)
{
_baskets.Add(basket.BuyerId, basket);
return(Task.CompletedTask);
}
public void Update(Domain.Basket basket)
{
_baskets.Update(basket);
}
public void Remove(Domain.Basket basket)
{
_baskets.Remove(basket);
}
public async ValueTask AddAsync(Domain.Basket basket, CancellationToken cancellationToken)
{
await _baskets.AddAsync(basket, cancellationToken);
}