public async Task <Guid> Handle(CreateCartCommand request, CancellationToken cancellationToken)
{
var cart = new CartEntity();
await _cartRepository.Create(cart);
return(cart.CartId);
}
public CartController(UserClient userClient, ProductClient productClient, LogClient logClient)
{
_userClient = userClient;
_productClient = productClient;
_cart = userClient.GetCurrentUser().GetCart();
_logClient = logClient;
}
public CartDTO(CartEntity cartEntity)
{
TotalPrice = cartEntity.TotalPrice;
TotalItem = cartEntity.TotalItem;
User = cartEntity.User;
Items = cartEntity.Items.Select(X => new CartItem2DTO(X));
}
public async Task <CartEntity> AddToCart(ProductEntity product)
{
// Get the matching cart and album instances
var cartItem = await Task.Run(() =>
storeDB.Carts.SingleOrDefault(
c => c.CartId == ShoppingCartId &&
c.CartProductId == product.ProductId));
if (cartItem == null)
{
// Create a new cart item if no cart item exists
cartItem = new CartEntity
{
CartProductId = product.ProductId,
CartId = ShoppingCartId,
Number = 1,
DateCreated = DateTime.Now
};
storeDB.Carts.Add(cartItem);
storeDB.Entry(cartItem).State = EntityState.Added;
}
else
{
// If the item does exist in the cart,
// then add one to the quantity
cartItem.Number++;
}
// Save changes
await storeDB.SaveChangesAsync();
return(cartItem);
}
public async Task <Guid> GetCartIdByUserId(Guid userId)
{
try
{
var cart = await _context.Carts.Where(cart => cart.UserId == userId).FirstOrDefaultAsync();
if (cart == null)
{
cart = new CartEntity()
{
CartId = new Guid(),
UserId = userId
};
await _context.Carts.AddAsync(cart);
await _context.SaveChangesAsync();
}
return(cart.CartId);
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult removeRowCart([FromBody] FormDeleteCart formDeleteCart)
{
try
{
// Lấy UserEntity đang đăng nhập từ jwt
UserEntity user = (UserEntity)HttpContext.Items["User"];
Console.WriteLine("User: "******"User"] = null;
CartEntity c = cartDAO.getCart(user.Id, formDeleteCart.CartItemId);
if (c == null)
{
return(BadRequest());
}
cartDAO.RemoveCart(c.Items);
c = cartDAO.getCart(c);
return(Ok(new CartDTO(c)));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(BadRequest());
}
public PresentationalCart MapToPresentational(CartEntity cart)
{
return new PresentationalCart()
{
Items = MapToPresentationals(cart.Items)
};
}
private void med_add_to_cart_Click(object sender, EventArgs e)
{
//take amount from
CartEntity p = new CartEntity();
foreach (var it in medRepos.GetAll())
{
if (it.Id == (int)dataGridView1.CurrentCell.Value)//id in row
{
p.Id = it.Id;
p.name = it.name;
it.amount = it.amount - int.Parse(med_amount.Text);//amount in text
}
}
//add amount to cart
medRepos.Save();
cartRepos.Save(); //
if (cartRepos.IsProductExist(factory.GetCartFlyweight(p, int.Parse(med_amount.Text)))) ///////////////////////////////////
{
factory.GetCartFlyweight(p, int.Parse(med_amount.Text)).amount += int.Parse(med_amount.Text); /////
cartRepos.Update(factory.GetCartFlyweight(p, int.Parse(med_amount.Text)));
}
else if ((factory.GetCartFlyweight(p, int.Parse(med_amount.Text))).amount == 0)
{
factory.GetCartFlyweight(p, int.Parse(med_amount.Text)).amount += int.Parse(med_amount.Text);
cartRepos.Create(factory.GetCartFlyweight(p, int.Parse(med_amount.Text)));
}
else
{
cartRepos.Create(factory.GetCartFlyweight(p, int.Parse(med_amount.Text)));
}
}
public bool addToCart([FromBody] CartEntity cartEntity)
{
// if product is exist in cart Update count
Cart item = db.Carts.Where(a => a.userID == userID && a.productID == cartEntity.productID).FirstOrDefault();
if (item != null)
{
item.count = cartEntity.count;
db.Entry(item).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(true);
}
else // Add new Cart
{
db.Carts.Add(new Cart()
{
count = cartEntity.count,
expire = DateTime.Now.AddDays(2),
productID = cartEntity.productID,
userID = userID
});
db.SaveChanges();
return(true);
}
}
// Helper method to simplify shopping cart calls
public void AddToCart(Product product)
{
// Get the matching cart and album instances
var cartItem = storeDB.Carts.SingleOrDefault(
c => c.CartId == ShoppingCartId &&
c.ProductId == product.ProductId);
if (cartItem == null)
{
// Create a new cart item if no cart item exists
cartItem = new CartEntity
{
ProductId = product.ProductId,
CartId = ShoppingCartId,
Count = 1,
DateCreated = DateTime.Now
};
storeDB.Carts.Add(cartItem);
}
else
{
// If the item does exist in the cart,
// then add one to the quantity
cartItem.Count++;
}
// Save changes
storeDB.SaveChanges();
}
public async Task UpdateWithAddedItem(CartEntity cart, CartItem item)
{
item.CreatedAt = DateTime.Now;
_context.CartItems.Add(item);
_context.Carts.Update(cart);
await _context.SaveChangesAsync();
}
public async Task WhenItemWithGivenProductIdIsNotInCartThenAddItemToCart()
{
var cartId = Guid.NewGuid();
var productId = Guid.NewGuid();
var inputCommand = CreateCommand(cartId, productId, 100);
var cartReturnedFromRepository = CreateEmptyCart(cartId);
CartItem itemOnUpdate = null;
CartEntity cartOnUpdate = null;
_cartRepository.Setup(r => r.GetById(cartId))
.ReturnsAsync(cartReturnedFromRepository);
_cartRepository.Setup(r => r.UpdateWithAddedItem(It.IsAny <CartEntity>(), It.IsAny <CartItem>()))
.Callback <CartEntity, CartItem>((c, i) =>
{
cartOnUpdate = c;
itemOnUpdate = i;
});
await _addItemToCartCommandHandler.Handle(inputCommand, default);
itemOnUpdate.ProductId.Should().Be(productId);
itemOnUpdate.Quantity.Should().Be(100);
cartOnUpdate.Items.Count.Should().Be(1);
cartOnUpdate.Items[0].ProductId.Should().Be(productId);
cartOnUpdate.Items[0].Quantity.Should().Be(100);
}
public IActionResult DoLoginVer2([FromBody] LoginForm loginForm)
{
if (userDAO.getOneByEmail(loginForm.Email) == null)
{
return(BadRequest(new { message = "Email không tồn tại trong hệ thống!" }));
}
var response = _userService.loginAuthenticateByEmail(loginForm);
if (response == null)
{
return(BadRequest(new { message = "Mật khẩu không đúng!" }));
}
HttpContext.Session.SetInt32("idUserSession", response.user.Id);
// return Ok(response);
//Lấy Cart
CartEntity c = cartDAO.getCart(response.user.Id);
// return Ok(c);
response.cart = new CartDTO(c);
//check user has been blocked by admin
if (response.jwt.Equals("inactive"))
{
return(BadRequest(new { message = "Tài khoản của bạn hiện đang khóa. Thực hiện đổi mật khẩu mới để mở khóa!" }));
}
return(Ok(response));
}
private async Task LoadCartWith(Guid cartId)
{
_cart = await _cartRepository.GetById(cartId);
if (_cart == null)
{
throw new NotFoundException("Cart with given id does not exist.");
}
}
public void WhenItemsInCartThenReturnSumOfItemPricesForGetPrice()
{
var cart = new CartEntity();
cart.Items.Add(Mock.Of <CartItem>(ci => ci.GetPrice() == 10.0));
cart.Items.Add(Mock.Of <CartItem>(ci => ci.GetPrice() == 20.0));
cart.GetPrice().Should().Be(30.0);
}
public void Delete(CartEntity cart)
{
DagentDatabase db = new DagentDatabase(_connection);
ICommand<CartEntity> cartCommand = CreateCartCommand(db);
cartCommand.Delete(cart);
db.ExequteNonQuery("delete from CartItem where CustomerId = @customerId", new Parameter("customerId", cart.Id.CustomerId));
}
public async Task <Guid?> CreateAsync()
{
var entity = new CartEntity();
if (await _cartCollection.CreateAsync(entity.Init()))
{
return(entity.Id);
}
throw new Exception("Cart unable to be created.");
}
private CartEntity CreateCartWithItem(Guid cartId, CartItem item)
{
var cart = new CartEntity
{
CartId = cartId,
};
cart.Items.Add(item);
return(cart);
}
public void deleteAllItemCart(int UserId)
{
var tmp = dbContext.Carts.Where(s => s.UserId == UserId).Include(x => x.Items);
CartEntity c = tmp.FirstOrDefault();
foreach (var ci in c.Items)
{
dbContext.Remove(ci);
}
dbContext.SaveChanges();
}
//Cap nhat Giỏ hàng
public ActionResult EditCart(long id, FormCollection f)
{
List <CartEntity> lstGiohang = GetCart();
CartEntity item = lstGiohang.SingleOrDefault(n => n.IdItem == id);
if (item != null)
{
item.Quantity = int.Parse(f["txtSoluong"].ToString());
}
return(RedirectToAction("Cart"));
}
public void SaveOrder(CartEntity er)
{
try
{
string query = "Insert into OrderData values ('" + er.Id + "','" + er.Item + "','" + er.Table + "','" + er.Quantity + "','" + er.Price + "');";
DataAccess.ExecuteQuery(query);
}
catch (Exception ex)
{
return;
}
}
public async Task <CartEntity> UpdateCart(CartEntity cart)
{
var updated = await _context
.Redis
.StringSetAsync(cart.UserName, JsonConvert.SerializeObject(cart));
if (!updated)
{
return(null);
}
return(await GetCart(cart.UserName));
}
public Flyweight GetCartFlyweight(CartEntity product, int amount)
{
foreach (var it in flyweightsArr)
{
if (it.Id == product.Id)
{
return(it);
}
}
Flyweight flyw = new Flyweight(product, amount);
flyweightsArr.Add(flyw);
return(flyw);
}
public async Task <IActionResult> Handle(Request request, CancellationToken cancellationToken = default)
{
if (request is null)
{
return(BadRequest());
}
DiagnosticsContext.Set("CartId", request.CartId);
DiagnosticsContext.Set("ProductId", request.ProductId);
DiagnosticsContext.Set("Increment", request.Increment);
CartEntity cart = await Context.Carts.AsNoTracking().SingleOrDefaultAsync(c => c.Id == request.CartId, cancellationToken);
if (cart is null)
{
Logger.LogTrace("Cart not found");
string message = Localizer.GetStringSafe("CartNotFound", request.CartId);
return(NotFoundProblem(message));
}
ItemEntity item = await Context.Items.AsTracking().SingleOrDefaultAsync(c => c.CartId == request.CartId && c.ProductId == request.ProductId, cancellationToken);
if (item is null)
{
item = Mapper.Map <ItemEntity>(request);
item.CreatedOn = Clock.UtcNow;
item.ModifiedOn = Clock.UtcNow;
DiagnosticsContext.Set("NewQuantity", item.Quantity);
DiagnosticsContext.Set("PreviousQuantity", 0);
Context.Items.Add(item);
}
else
{
int existingQuantity = item.Quantity;
item.Quantity += request.Increment;
item.ModifiedOn = Clock.UtcNow;
DiagnosticsContext.Set("NewQuantity", item.Quantity);
DiagnosticsContext.Set("PreviousQuantity", existingQuantity);
}
await Context.SaveChangesAsync(cancellationToken);
var response = Mapper.Map <Response>(item);
return(Ok(response));
}
public async Task WhenItemWithGivenProductIdNotInCartThenSkip()
{
var cartId = Guid.NewGuid();
var productId = Guid.NewGuid();
var inputCommand = CreateCommand(cartId, productId);
var cartReturnedFromRepository = new CartEntity();
cartReturnedFromRepository.Items.Add(CreateItem(Guid.NewGuid()));
_cartRepository.Setup(r => r.GetById(cartId))
.ReturnsAsync(cartReturnedFromRepository);
await _removeItemFromCartCommandHandler.Handle(inputCommand, default);
_cartRepository.Verify(x => x.DeleteItem(It.IsAny <CartItem>()), Times.Never());
}
public async Task <IActionResult> UpdateCart([FromBody] CartEntity cartEntity)
{
int UserId = (Request.Headers.ContainsKey("CustomerId") ? int.Parse(HttpContext.Request.Headers["CustomerId"]) : 0);
cartEntity.TblCustomerId = UserId;
var result = await Task <int> .Run(() => _placeOrderActions.UpdateCart(cartEntity));
if (result != 0)
{
return(Ok("Item Updated to Cart"));
}
else
{
return(BadRequest("Item not added to the Cart"));
}
}
public async Task WhenItemWithGivenProductIdNotInCartThenThrowNotFoundException()
{
var cartId = Guid.NewGuid();
var productId = Guid.NewGuid();
var inputCommand = CreateCommand(cartId, productId, 100);
var cartReturnedFromRepository = new CartEntity();
cartReturnedFromRepository.Items.Add(CreateItem(Guid.NewGuid(), 125));
_cartRepository.Setup(r => r.GetById(cartId))
.ReturnsAsync(cartReturnedFromRepository);
Func <Task> act = async() =>
await _updateItemQuantityCommandHandler.Handle(inputCommand, default);
await act.Should().ThrowAsync <NotFoundException>();
}
async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
string msg = Encoding.UTF8.GetString(message.Body);
var cartentity = JsonConvert.DeserializeObject <CartEntity>(Encoding.UTF8.GetString(message.Body));
CartEntity cart = new CartEntity {
TblRestaurantId = cartentity.TblRestaurantId,
TblMenuId = cartentity.TblMenuId,
Price = cartentity.Price
};
_orderBusiness.UpdatePriceChange(cart);
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
await _subscriptionClient.CloseAsync();
}
public CartEntity TakeAmountFromCurrentProduct(int amount)
{
CartEntity p = new CartEntity();
products = medRepos.GetAll();
foreach (var it in products)
{
if (it.Id == currentId)
{
p.Id = it.Id;
p.name = it.name;
it.amount = it.amount - amount;
}
}
return(p);
}
//Xoa Giohang
public ActionResult DeleteCart(long id)
{
List <CartEntity> lstGiohang = GetCart();
CartEntity sanpham = lstGiohang.SingleOrDefault(n => n.IdItem == id);
if (sanpham != null)
{
lstGiohang.RemoveAll(n => n.IdItem == id);
return(RedirectToAction("Cart"));
}
if (lstGiohang.Count == 0)
{
return(RedirectToAction("Index", "AuraStore"));
}
return(RedirectToAction("Cart"));
}
public CartEntity ConvertToOrderEntity(DataRow row)
{
if (row == null)
{
return(null);
}
var c = new CartEntity();
c.Id = row["Id"].ToString();
c.Item = row["Item"].ToString();
c.Quantity = Int32.Parse(row["Quantity"].ToString());
c.Table = row["Table_Seat"].ToString();
c.Price = float.Parse(row["Price"].ToString());
return(c);
}
public void Update(CartEntity cart)
{
DagentDatabase db = new DagentDatabase(_connection);
ICommand<CartEntity> cartCommand = CreateCartCommand(db);
cartCommand.Update(cart);
ICommand<CartItemEntity> cartItemCommand = CreateCartItemCommand(db);
foreach (CartItemEntity cartItem in cart.CartItemList)
{
cartItemCommand.Update(cartItem);
}
}
