public async Task <ICommandResult> Handle(CartAddCommand mesage)
        {
            try
            {
                bool isLockSuccess = await _cartService.CreatingCart(mesage.ClientId);

                if (isLockSuccess)
                {
                    var shard = await _shardingService.GetCurrentWriteShardByRoundRobin(ShardGroup);

                    Cart           cart                   = new Cart(mesage, shard.Id, mesage.Version);
                    CartItem       shoppingCartItem       = new CartItem(mesage.CartItem);
                    CartItemDetail shoppingCartItemDetail = new CartItemDetail(mesage.CartItemDetail);
                    var            newCartItems           = cart.Add(shoppingCartItem, shoppingCartItemDetail, mesage.CartItem.Quantity,
                                                                     out var newCartItemDetail);
                    await _cartService.Save(shard.ConnectionString, cart, newCartItems, newCartItemDetail);

                    _eventSender.Add(cart.Events);
                    await _eventSender.Notify();

                    ICommandResult result = new CommandResult()
                    {
                        Message  = "",
                        ObjectId = cart.Id,
                        Status   = CommandResult.StatusEnum.Sucess,
                    };
                    return(result);
                }
                else
                {
                    throw new MessageException(ResourceKey.Cart_IsCreating);
                }
            }
            catch (MessageException e)
            {
                e.Data["Param"] = mesage;
                ICommandResult result = new CommandResult()
                {
                    Message      = e.Message,
                    Status       = CommandResult.StatusEnum.Fail,
                    ResourceName = e.ResourceName
                };
                return(result);
            }
            catch (Exception e)
            {
                e.Data["Param"] = mesage;
                ICommandResult result = new CommandResult()
                {
                    Message = e.Message,
                    Status  = CommandResult.StatusEnum.Fail
                };
                return(result);
            }
            finally
            {
                await _cartService.CreatedCart(mesage.ClientId);
            }
        }
Esempio n. 2
0
        public async Task <CartItemDetail> AddCartItem(int id, int foodTruckId, int userId, int itemId, int qty)
        {
            // 1. CHECK IF CART EXISTS
            // // IsPurchased == 0  | IsOrderFilled == 0
            var cart = await GetCart(foodTruckId, userId, id);

            if (cart == null)
            {
                // 2. IF NOT CREATE CART
                cart = await CreateCart(cart, foodTruckId, userId);
            }

            // 3. IS ITEM ALREADY IN CART? IF SO, UPDATE TO QTY 22.19
            var itemInCart = await _context.CartItemDetails.FirstOrDefaultAsync(
                c => c.CartId == id && c.ItemId == itemId
                );

            if (itemInCart != null)
            {
                var updatedQty = itemInCart.Quantity + 1;
                await UpdateItem(id, itemId, updatedQty);
            }
            else
            {
                // 4. CREATE ITEM
                var cartItem = default(CartItemDetail);

                cartItem = new CartItemDetail()
                {
                    Quantity = qty,
                    ItemId   = itemId,
                    CartId   = id
                };

                await _context.CartItemDetails.AddAsync(cartItem);
                await SaveAll();
            }

            // 5. UPDATE CART TOTALS
            var updatedCart = await UpdateCart(cart);

            var itemToReturn = await _context.CartItemDetails.FirstOrDefaultAsync(
                c => c.CartId == cart.Id && c.ItemId == itemId
                );

            return(itemToReturn);
        }
 public async Task Save(string connectionString, Cart shoppingCart,
                        CartItem[] cartItems,
                        CartItemDetail cartItemDetail,
                        Func <int, IDbConnection, IDbTransaction, Cart, CartItem, Task> addCartItem,
                        Func <int, IDbConnection, IDbTransaction, Cart, CartItemDetail, Task> addCartItemDetail)
 {
     await WithConnection(connectionString, async (connection, transaction) =>
     {
         DynamicParameters parametersCheckExist = new DynamicParameters();
         parametersCheckExist.Add("@ClientId", shoppingCart.ClientId, DbType.String);
         parametersCheckExist.Add("@Status", EnumDefine.CartStatusEnum.New.AsEnumToInt(), DbType.Int64);
         var cartExist = await connection.QueryFirstOrDefaultAsync <RCart>(ProcName.ShoppingCart_GetByCustomer, parametersCheckExist, transaction, commandType: CommandType.StoredProcedure);
         if (cartExist != null)
         {
             throw new MessageException(ResourceKey.Cart_Exist);
         }
         DynamicParameters parameters = new DynamicParameters();
         parameters.Add("@Id", shoppingCart.Id, DbType.String);
         parameters.Add("@ShardId", shoppingCart.ShardId, DbType.Int32);
         parameters.Add("@Code", shoppingCart.Code, DbType.String);
         parameters.Add("@CreatedDateUtc", shoppingCart.CreatedDateUtc, DbType.DateTime);
         parameters.Add("@UpdatedDateUtc", shoppingCart.CreatedDateUtc, DbType.DateTime);
         parameters.Add("@CreatedUid", shoppingCart.CreatedUid, DbType.String);
         parameters.Add("@UpdatedUid", shoppingCart.CreatedUid, DbType.String);
         parameters.Add("@LanguageId", shoppingCart.LanguageId, DbType.String);
         parameters.Add("@StoreId", shoppingCart.StoreId, DbType.String);
         parameters.Add("@ClientId", shoppingCart.ClientId, DbType.String);
         parameters.Add("@STATUS", shoppingCart.Status, DbType.String);
         parameters.Add("@Version", shoppingCart.Version, DbType.String);
         var result = await connection.ExecuteAsync(ProcName.ShoppingCart_Add, parameters, transaction, commandType: CommandType.StoredProcedure);
         if (cartItems != null && cartItems.Length > 0)
         {
             foreach (var cartItem in cartItems)
             {
                 await addCartItem(shoppingCart.ShardId, connection, transaction, shoppingCart, cartItem);
             }
         }
         if (cartItemDetail != null)
         {
             await addCartItemDetail(shoppingCart.ShardId, connection, transaction, shoppingCart, cartItemDetail);
         }
         return(result);
     });
 }
Esempio n. 4
0
 public async Task Save(string connectionString, int id, string cartId, string cartCode, int version, CartItem[] cartItems,
                        CartItemDetail shoppingCartItemDetail)
 {
     await _cartItemRepository.Add(connectionString, id, cartId, cartCode, version, cartItems, shoppingCartItemDetail, _cartItemDetailRepository.Add, _cartRepository.Change);
 }
Esempio n. 5
0
 public async Task Save(string connectionString, Cart cart, CartItem[] cartItems,
                        CartItemDetail cartItemDetail)
 {
     await _cartRepository.Save(connectionString, cart, cartItems, cartItemDetail, _cartItemRepository.Add, _cartItemDetailRepository.Add);
 }
Esempio n. 6
0
        public async Task Add(int shardId, string cartId, string cartCode, IDbConnection dbConnection, IDbTransaction transaction, CartItemDetail cartItemDetail)
        {
            DynamicParameters parameters = new DynamicParameters();

            parameters.Add("@ShoppingCartId", cartId, DbType.String);
            parameters.Add("@ShoppingCartCode", cartCode, DbType.String);
            parameters.Add("@Id", cartItemDetail.Id, DbType.String);
            parameters.Add("@ShardId", shardId, DbType.Int32);
            parameters.Add("@CreatedDateUtc", cartItemDetail.CreatedDateUtc, DbType.DateTime);
            parameters.Add("@UpdatedDateUtc", cartItemDetail.CreatedDateUtc, DbType.DateTime);
            parameters.Add("@CreatedUid", cartItemDetail.CreatedUid, DbType.String);
            parameters.Add("@UpdatedUid", cartItemDetail.CreatedUid, DbType.String);
            parameters.Add("@LanguageId", cartItemDetail.LanguageId, DbType.String);
            parameters.Add("@ProductId", cartItemDetail.ProductId, DbType.String);
            parameters.Add("@NAME", cartItemDetail.Name, DbType.String);
            await dbConnection.ExecuteAsync(ProcName.ShoppingCartItemDetail_Add, parameters, transaction, null,
                                            CommandType.StoredProcedure);
        }
        public async Task <ICommandResult> Handle(CartItemChangeCommand mesage)
        {
            try
            {
                var shard = await _shardingService.GetShardById(ShardGroup, mesage.ShardId);

                RCart rCart = await _cartService.GetFromDb(shard.ConnectionString, mesage.CartId);

                if (rCart == null)
                {
                    throw new MessageException(ResourceKey.Cart_NotFound);
                }
                Cart cart = new Cart(rCart);
                switch (mesage.Action)
                {
                case EnumDefine.CartActionEnum.AddNewItem:
                {
                    CartItem       cartItem = new CartItem(mesage);
                    CartItemDetail shoppingCartItemDetail = null;
                    if (mesage.CartItemDetail != null)
                    {
                        shoppingCartItemDetail = new CartItemDetail(mesage.CartItemDetail, mesage.LanguageId, mesage.UpdatedUid);
                    }
                    var newCartItems = cart.Add(cartItem, shoppingCartItemDetail, mesage.Quantity, out var newCartItemDetail);
                    _eventSender.Add(cart.Events);
                    await _cartService.Save(shard.ConnectionString, shard.Id, mesage.CartId, mesage.CartCode, mesage.Version, newCartItems, newCartItemDetail);
                }
                break;

                case EnumDefine.CartActionEnum.RemoveItem:
                {
                    var cartItemRemoved = cart.Remove(mesage.ProductId, mesage.Quantity, out var shoppingCartItemDetailsRemoved);
                    await _cartService.Remove(shard.ConnectionString, mesage.CartId, mesage.Version,
                                              cartItemRemoved?.Select(p => p.Id).ToArray(),
                                              shoppingCartItemDetailsRemoved?.Select(p => p.Id).ToArray());
                };
                    break;

                case EnumDefine.CartActionEnum.ChangeQuantity:
                {
                    var changeQuantity = mesage.Quantity;
                    if (changeQuantity > 0)
                    {
                        CartItem       cartItem = new CartItem(mesage);
                        CartItemDetail shoppingCartItemDetail = null;
                        if (mesage.CartItemDetail != null)
                        {
                            shoppingCartItemDetail = new CartItemDetail(mesage.CartItemDetail, mesage.LanguageId, mesage.UpdatedUid);
                        }
                        var newCartItems = cart.Add(cartItem, shoppingCartItemDetail, changeQuantity, out var newCartItemDetail);
                        _eventSender.Add(cart.Events);
                        await _cartService.Save(shard.ConnectionString, shard.Id, mesage.CartId, mesage.CartCode, mesage.Version, newCartItems, newCartItemDetail);
                    }
                    else
                    {
                        var cartItemRemoved = cart.Remove(mesage.ProductId, mesage.Quantity * -1, out var shoppingCartItemDetailsRemoved);
                        await _cartService.Remove(shard.ConnectionString, mesage.CartId, mesage.Version,
                                                  cartItemRemoved?.Select(p => p.Id).ToArray(),
                                                  shoppingCartItemDetailsRemoved?.Select(p => p.Id).ToArray());
                    }
                }
                break;
                }
                await _eventSender.Notify();

                ICommandResult result = new CommandResult()
                {
                    Message  = "",
                    ObjectId = string.Empty,
                    Status   = CommandResult.StatusEnum.Sucess
                };
                return(result);
            }
            catch (MessageException e)
            {
                e.Data["Param"] = mesage;
                ICommandResult result = new CommandResult()
                {
                    Message      = e.Message,
                    Status       = CommandResult.StatusEnum.Fail,
                    ResourceName = e.ResourceName
                };
                return(result);
            }
            catch (Exception e)
            {
                e.Data["Param"] = mesage;
                ICommandResult result = new CommandResult()
                {
                    Message = e.Message,
                    Status  = CommandResult.StatusEnum.Fail
                };
                return(result);
            }
        }
        public async Task <IActionResult> AddToCart()
        {
            try
            {
                using (var reader = new StreamReader(Request.Body))
                {
                    var body = await reader.ReadToEndAsync();

                    var userData = JsonConvert.DeserializeObject <userData>(body);

                    if (userData.username == null || userData.username.Trim() == "")
                    {
                        return(Json(new { success = "register" }));
                    }
                    if (userData != null)
                    {
                        var cartId = _db.CartItems.Where(c => c.Username == userData.username).Select(t => t.Id).FirstOrDefault();
                        if (cartId != 0 && cartId != default)
                        {
                            var cartItemDetail = _db.CartItemDetails.Where(c => c.BookId == userData.id).FirstOrDefault();
                            if (cartItemDetail != default)
                            {
                                cartItemDetail.Amount += userData.bookamount;
                                _db.SaveChanges();
                                return(Json(new { success = "done" }));
                            }
                            else
                            {
                                var cartDetail = new CartItemDetail()
                                {
                                    BookId     = userData.id,
                                    CartItemId = cartId,
                                    Amount     = userData.bookamount,
                                };
                                _db.CartItemDetails.Add(cartDetail);
                                var resultCartItemDetail = _db.SaveChanges();
                                if (resultCartItemDetail > 0)
                                {
                                    var counter = (_db.CartItems.Where(c => c.Username == userData.username).Select(c => c)).Count();
                                    return(Json(new { success = "done", count = counter }));
                                }
                            }
                        }
                        else
                        {
                            var cart = new CartItem()
                            {
                                Username   = userData.username,
                                TimeAddded = DateTime.Now
                            };
                            await _db.CartItems.AddAsync(cart);

                            var resultCartItem = _db.SaveChanges();
                            if (resultCartItem > 0)
                            {
                                var cartDetail = new CartItemDetail()
                                {
                                    BookId     = userData.id,
                                    CartItemId = cart.Id,
                                    Amount     = userData.bookamount,
                                };
                                _db.CartItemDetails.Add(cartDetail);
                                var resultCartItemDetail = _db.SaveChanges();
                                if (resultCartItemDetail > 0)
                                {
                                    var counter = (_db.CartItems.Where(c => c.Username == userData.username).Select(c => c)).Count();
                                    return(Json(new { success = "done", count = counter }));
                                }
                            }
                        }
                    }
                }
                return(BadRequest());
            }
            catch (Exception)
            {
                return(BadRequest());
            }
        }
Esempio n. 9
0
 public async Task Add(string connectionString, int shardId, string cartId, string cartCode, int version, CartItem[] cartItems, CartItemDetail cartItemDetail,
                       Func <int, string, string, IDbConnection, IDbTransaction, CartItemDetail, Task> addCartItemDetail,
                       Func <string, int, IDbConnection, IDbTransaction, Task <bool> > changeCart)
 {
     await WithConnection(connectionString, async (connection, transaction) =>
     {
         bool isChangeCart = await changeCart(cartId, version, connection, transaction);
         if (!isChangeCart)
         {
             throw new MessageException(ResourceKey.Cart_IsChanged);
         }
         foreach (var shoppingCartItem in cartItems)
         {
             DynamicParameters parameters = new DynamicParameters();
             parameters.Add("@ShoppingCartId", cartId, DbType.String);
             parameters.Add("@ShoppingCartCode", cartCode, DbType.String);
             parameters.Add("@Id", shoppingCartItem.Id, DbType.String);
             parameters.Add("@ShardId", shardId, DbType.Int32);
             parameters.Add("@CreatedDateUtc", shoppingCartItem.CreatedDateUtc, DbType.DateTime);
             parameters.Add("@UpdatedDateUtc", shoppingCartItem.CreatedDateUtc, DbType.DateTime);
             parameters.Add("@CreatedUid", shoppingCartItem.CreatedUid, DbType.String);
             parameters.Add("@UpdatedUid", shoppingCartItem.CreatedUid, DbType.String);
             parameters.Add("@LanguageId", shoppingCartItem.LanguageId, DbType.String);
             parameters.Add("@StoreId", shoppingCartItem.StoreId, DbType.String);
             parameters.Add("@STATUS", shoppingCartItem.Status, DbType.Int64);
             parameters.Add("@ProductId", shoppingCartItem.ProductId, DbType.String);
             parameters.Add("@Price", shoppingCartItem.Price, DbType.Decimal);
             await connection.ExecuteAsync(ProcName.ShoppingCartItem_Add, parameters, transaction, null,
                                           CommandType.StoredProcedure);
         }
         if (cartItemDetail != null)
         {
             await addCartItemDetail(shardId, cartId, cartCode, connection, transaction, cartItemDetail);
         }
         return(Task.FromResult(true));
     });
 }