public async Task <BaseDtoResponse <AddToCartDto> > Add(AddToCartRequest request)
{
try
{
Product product = await _productRepository.GetById(request.ProductId);
if (product != null)
{
CartItem item = _mapper.Map <AddToCartRequest, CartItem>(request);
item.Product = product;
CartItem carItem = await _cartItemRepository.Add(item);
if (carItem == null)
{
return(new BaseDtoResponse <AddToCartDto>("Error occured while creating the CartItem, try again"));
}
AddToCartDto response = _mapper.Map <CartItem, AddToCartDto>(carItem);
return(new BaseDtoResponse <AddToCartDto>(response));
}
else
{
return(new BaseDtoResponse <AddToCartDto>("Unable to find product in the Catalog, please try again"));
}
//IList<CartItem> items = await _cartItemRepository.List(new ItemsInCartForUserSpecification(request.IdentityId));
//if (items != null)
//{
// CartItem sameProduct = items.Cast<CartItem>().SingleOrDefault(e => e.ProductId == request.ProductId);
//}
}
catch (Exception ex)
{
return(new BaseDtoResponse <AddToCartDto>(ex.Message));
}
}
/// <inheritdoc />
Task <IActionResult> ICartServices.AddProduct(AddToCartRequest request)
{
var arguments = new object[] { request };
var func = requestBuilder.BuildRestResultFuncForMethod("AddProduct", new Type[] { typeof(AddToCartRequest) });
return((Task <IActionResult>)func(Client, arguments));
}
public async Task <OrderItem> AddItem(AddToCartRequest request)
{
var currentUser = await accountManager.GetCurrentUser();
if (currentUser.Id == request.OfferOwnerId)
{
throw new NoPermissionsException(ErrorMessages.NotAllowedMessage);
}
if (currentUser.Cart == null)
{
currentUser.SetCart(await CreateCart(currentUser));
}
var item = new OrderItemBuilder()
.SetAmount(request.Amount)
.SetType(request.Type)
.SetProductName(request.ProductName)
.SetUserName(request.UserName)
.SetEmail(request.Email)
.SetCartId(currentUser.Cart.Id)
.SetOptionalData(request.OfferOwnerId)
.Build();
currentUser.Cart.Items.Add(item);
currentUser.Cart.CalculateTotalAmount();
return(await unitOfWork.Complete() ? item : throw new ServerException("Adding item to cart failed"));
}
public async Task <IActionResult> AddToCart(AddToCartRequest request)
{
var response = await mediator.Send(request);
Log.Information($"User #{HttpContext.GetCurrentUserId()} added item {request.ProductName} [offer #{request.OfferId}] to their cart");
return(this.CreateResponse(response));
}
public async Task <ActionResult> AddToCart(int id)
{
var request = new AddToCartRequest(id, HttpContext);
await _mediator.SendAsync(request);
return(this.RedirectToAction(c => c.Index()));
}
[HttpPost]//manager kur response kur jsondan cagır..
public ActionResult AddToCart(AddToCartRequest request)
{
CartManager manager = new CartManager();
string message = manager.Add(request.ProductID);
AddToCartResponse response = new AddToCartResponse();
response.Message = message;
return(Json(response));
}
public override async Task <AddToCartResponse> AddToCart(AddToCartRequest request, ServerCallContext context)
{
var product = request.Product;
var newProduct = AddToCartDB(product);
return(new AddToCartResponse
{
Product = newProduct
});
}
public async Task <IActionResult> AddProduct([FromBody] AddToCartRequest request)
{
if (request == null || request.SessionId == Guid.Empty || request.ProductId <= 0 || request.Count <= 0)
{
return(BadRequest());
}
var result = await _mediator.Send(request);
return(Ok(result));
}
public IActionResult AddToCart(AddToCartRequest addToCartRequest)
{
var cart = _cartService.AddToCart(addToCartRequest.SessionId,
addToCartRequest.ProductId,
addToCartRequest.Quantity);
return(Ok(new AddToCartResponse()
{
SessionId = cart.SessionId
}));
}
public CartModel AddToCart(AddToCartRequest request)
{
var productEntity = _context.Products
.SingleOrDefault(x => x.ProductId == new Guid(request.ProductId));
var userEntity = _context.Users
.Include(x => x.Cart)
.SingleOrDefault(x => x.UserId == new Guid(request.UserId));
var cartEntity = _context.Carts
.Include(x => x.CartItems)
.Include(x => x.CartItems.Select(y => y.Product))
.SingleOrDefault(x => x.User.UserId == userEntity.UserId);
var cartItemEntity = cartEntity.CartItems
.SingleOrDefault(x => x.Product.ProductId == productEntity.ProductId);
var model = new CartModel();
if (cartItemEntity != null)
{
cartItemEntity.Count += request.Count;
cartItemEntity.Price += productEntity.Price * request.Count;
cartEntity.TotalPrice += productEntity.Price * request.Count;
_context.CartItems.AddOrUpdate(cartItemEntity);
_context.SaveChanges();
model = new CartModel(cartEntity);
return(model);
}
var cartItem = new CartItemEntity()
{
CartItemId = Guid.NewGuid(),
Product = productEntity,
Cart = userEntity.Cart,
Count = request.Count,
Price = request.Count * productEntity.Price
};
cartEntity.TotalPrice += cartItem.Price;
_context.CartItems.Add(cartItem);
_context.Carts.AddOrUpdate(cartEntity);
_context.SaveChanges();
model = new CartModel(cartEntity);
return(model);
}
public async Task <IActionResult> AddToCart([FromBody] AddToCartRequest request)
{
var login = jwtHelper.GetClaimsFromToken()
.Claims.Single(x => x.Type == "login")
.Value;
await cart.AddPositionToCart(login, request.BookId);
return(Created("http://localhost:49194/api/Cart",
new CreatedResponse {
Message = "Resource added propperly."
}));
}
public ActionResult AddToCart(AddToCartRequest request)
{
var userId = new Guid(request.UserId);
if (userId == Guid.Empty)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var cart = _orderRepository.AddToCart(request);
return(Json(new { cartItemsCount = cart.CartItems.Count(), totalPrice = cart.TotalPrice }));
}
public async Task <bool> Handle(AddToCartRequest request, IOutputPort <AddToCartResponse> outputPort)
{
var product = await productRepository.GetProductById(request.ProductId);
if (product != null)
{
await _cartService.AddItem(new ProductDto(product.Id, product.Name, product.Description, product.Price, product.Category), 1);
outputPort.Handle(new AddToCartResponse(true));
return(true);
}
outputPort.Handle(new AddToCartResponse(false, $"ProductId - {request.ProductId} was not found"));
return(false);
}
public void AddToCart(AddToCartRequest req)
{
var filter = Builders <User> .Filter.Eq("Id", req.UserId);
User user = GetUser(req.UserId);
for (int i = 0; i < req.Amount; i++)
{
user.AddToCart(req.ProductId);
}
var update = Builders <User> .Update.Set("Cart", user.Cart);
_users.UpdateOne(filter, update);
}
public async Task <Result <int> > Handle(AddToCartRequest request, CancellationToken cancellationToken)
{
if (!int.TryParse(request.SkuId, out var skuId))
{
return(Result.Failure <int>($"{request.SkuId} is not a valid integer."));
}
var commandResult = await _addToCartCommandHandler.Handle(new AddToCartCommand(skuId), cancellationToken);
if (commandResult.IsFailure)
{
return(Result.Failure <int>(commandResult.Error));
}
return(Result.Success(skuId));
}
public async Task <IActionResult> Create([FromBody] AddToCartRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
try
{
var response = await _cartItemService.Add(request);
return(Ok(response));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult AddToCart(CarryOutBody body)
{
var request = new AddToCartRequest
{
CarryOutToAddToCart = body,
};
var response = _carryOutService.AddToCart(request);
if (response.IsSuccessful)
{
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task AddCart_should_Create_product_in_session_cart()
{
var request = new AddToCartRequest {
BookId = BookId
};
HttpContent httpContent = new StringContent(
JsonConvert.SerializeObject(request),
Encoding.UTF8,
"application/json");
var response = await httpClient.PostAsync($"/api/cart", httpContent);
var content = await response.Content.ReadAsAsync <CreatedResponse>();
response.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("Resource added propperly.", content.Message);
}
public ShoppingCartItem AddToCart([FromBody] AddToCartRequest request)
{
User user = _userRepository.Get(request.UserId);
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
Book book = _bookRepository.Get(request.BookId);
if (book == null)
{
throw new ArgumentNullException(nameof(book));
}
ShoppingCartItem sci;
if (user.ShoppingCartItems.Any(x => x.BookId == book.Id))
{
sci = user.ShoppingCartItems.FirstOrDefault(x => x.BookId == book.Id);
sci.Quantity += request.Quantity;
_shoppingCartItemRepository.Update(sci);
}
else
{
sci = new ShoppingCartItem
{
UserId = user.Id,
BookId = book.Id,
Price = book.Price,
Quantity = request.Quantity
};
_shoppingCartItemRepository.Insert(sci);
}
return(sci);
}
public ActionResult <string> AddToCart(AddToCartRequest request)
{
return(Ok(OrderOperations.AddToCart(request.productId, request.email)));
}
public async Task Add(string userId, [FromBody] AddToCartRequest request)
{
var actor = GetActor(userId);
await actor.AddToCart(request.ProductId, request.Quantity);
}
public ActionResult <Dictionary <string, int> > AddToCart(AddToCartRequest req)
{
_us.AddToCart(req);
return(_us.GetUser(req.UserId).Cart);
}
public void DeleteFromCart(AddToCartRequest req)
{
_us.RemoveFromCart(req.UserId, req.ProductId);
}
public AddToCartResponse AddToCart(AddToCartRequest request)
{
var response = new AddToCartResponse
{
IsSuccessful = false,
Message = ""
};
try
{
var customer = _context.Customers
.Where(x => x.Id == request.CarryOutToAddToCart.CustomerId)
.FirstOrDefault();
Food food = null;
List <CarryOut> existingFood = null;
Beverage beverage = null;
List <CarryOut> existingBeverages = null;
int currentFoodQuantity = 0;
int currentBeverageQuantity = 0;
if (request.CarryOutToAddToCart.Food != null)
{
food = _context.Foods
.Where(x => x.Id == request.CarryOutToAddToCart.Food.Id)
.FirstOrDefault();
}
if (request.CarryOutToAddToCart.Beverage != null)
{
beverage = _context.Beverages
.Where(x => x.Id == request.CarryOutToAddToCart.Beverage.Id)
.FirstOrDefault();
}
if (customer != null)
{
if (food != null)
{
existingFood = _context.CarryOuts
.Include(x => x.Food)
.Include(x => x.Beverage)
.Include(x => x.Customer)
.Where(x => x.Customer.Id == customer.Id)
.Where(x => x.Food.Name == food.Name)
.Where(x => x.SubmissionTime == null)
.ToList();
foreach (var item in existingFood)
{
currentFoodQuantity += item.FoodQuantity;
}
_context.RemoveRange(existingFood);
}
if (beverage != null)
{
existingBeverages = _context.CarryOuts
.Include(x => x.Food)
.Include(x => x.Beverage)
.Include(x => x.Customer)
.Where(x => x.Customer.Id == customer.Id)
.Where(x => x.Beverage.Name == beverage.Name)
.Where(x => x.SubmissionTime == null)
.ToList();
foreach (var item in existingBeverages)
{
currentBeverageQuantity += item.BeverageQuantity;
}
_context.RemoveRange(existingBeverages);
}
var cartItem = new CarryOut
{
Beverage = beverage,
BeverageQuantity = request.CarryOutToAddToCart.BeverageQuantity + currentBeverageQuantity,
BundleId = 0,
Customer = customer,
Food = food,
FoodQuantity = request.CarryOutToAddToCart.FoodQuantity + currentFoodQuantity,
SubmissionTime = null,
Id = 0
};
_context.Add(cartItem);
_context.SaveChanges();
response.IsSuccessful = true;
response.Message = "Successfully added carry out to cart for the customer.";
}
}
catch (Exception ex)
{
response.Message = ex.ToString();
}
return(response);
}
public async Task AddItemToCart([FromBody] AddToCartRequest requestDto)
{
int userId = int.Parse(User.FindFirstValue(ClaimTypes.Name));
await _orderService.AddItemToOrder(userId, requestDto.ProductId, requestDto.Quantity ?? 1);
}
