public async Task Handle(CartCacheAddEvent mesage)
 {
     try
     {
         RCart cart = new RCart()
         {
             Id             = mesage.Id,
             LanguageId     = mesage.LanguageId,
             ShardId        = mesage.ShardId,
             Version        = mesage.Version,
             ClientId       = mesage.ClientId,
             Code           = mesage.Code,
             CreatedDateUtc = mesage.CreatedDateUtc,
             CreatedUid     = mesage.CreatedUid,
             Status         = mesage.Status,
             StoreId        = mesage.StoreId,
             UpdatedUid     = mesage.UpdatedUid,
             UpdatedDateUtc = mesage.UpdatedDateUtc,
             CartItems      = mesage.CartItems?.Select(p => new RCartItem()
             {
                 LanguageId     = mesage.LanguageId,
                 Status         = p.Status,
                 ShardId        = mesage.ShardId,
                 Code           = p.Code,
                 CreatedUid     = mesage.CreatedUid,
                 Id             = p.Id,
                 Version        = mesage.Version,
                 StoreId        = mesage.StoreId,
                 UpdatedUid     = mesage.UpdatedUid,
                 CreatedDateUtc = mesage.CreatedDateUtc,
                 UpdatedDateUtc = mesage.UpdatedDateUtc,
                 ProductId      = p.ProductId,
                 Price          = p.Price,
             }).ToArray(),
             CartItemDetails = mesage.CartItemDetails?.Select(p => new RCartItemDetail()
             {
                 LanguageId     = mesage.LanguageId,
                 ShardId        = mesage.ShardId,
                 Code           = p.Code,
                 CreatedUid     = mesage.CreatedUid,
                 Id             = p.Id,
                 Version        = mesage.Version,
                 StoreId        = mesage.StoreId,
                 UpdatedUid     = mesage.UpdatedUid,
                 Name           = p.Name,
                 ProductId      = p.ProductId,
                 CreatedDateUtc = mesage.CreatedDateUtc,
                 UpdatedDateUtc = mesage.UpdatedDateUtc,
             }).ToArray()
         };
         //var t1 = Common.Serialize.ProtoBufSerialize(cart);
         //var t2 = Common.Serialize.ProtoBufDeserialize<RCart>(t1);
         await _cartCacheStorage.Add(cart);
     }
     catch (Exception e)
     {
         e.Data["Param"] = mesage;
         throw e;
     }
 }
        public async Task <ICommandResult> Handle(AddressSelectedCommand 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);
                }
                if (rCart.Version != mesage.Version)
                {
                    throw new MessageException(ResourceKey.Cart_IsChanged);
                }
                Cart         cart       = new Cart(rCart);
                RWarehouse[] warehouses = new RWarehouse[0];
                RWarehouse_Product_Mapping[] warehouseProductMappings = new RWarehouse_Product_Mapping[0];
                WorkingTime[] logisticsWorkingTimes = new WorkingTime[0];
                Holiday[]     logisticsHolidayTimes = new Holiday[0];
                //tinh ton kho
                var quantityChangedsCancel = cart.AddressSelectedCancel();
                var quantityChanges        = cart.AddressSelected(mesage, warehouses, warehouseProductMappings, logisticsWorkingTimes, logisticsHolidayTimes);
                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);
            }
        }
Example #3
0
 public static CartViewModel ToModel(this RCart model, string languageId)
 {
     if (model == null)
     {
         return(null);
     }
     return(new CartViewModel()
     {
     });
 }
Example #4
0
        public async Task <CartViewModel> Change(CartItemChangeViewModel item)
        {
            try
            {
                var customer = await _currentContext.GetCurrentCustomer();

                CartViewModel model = new CartViewModel(await InitAjax());
                RCart         cart  = await _cartService.GetFromCache(_currentContext.ClientId, EnumDefine.CartStatusEnum.New);

                if (cart == null)
                {
                    //int shardId= _commonService.get

                    var  command        = item.ToCommand(1, _currentContext.LanguageId, customer.Id);
                    long systemIdentity = await _commonService.GetNextId(typeof(Cart));

                    CartAddCommand cartAddCommand = new CartAddCommand(SystemDefine.DefaultVersion)
                    {
                        LanguageId     = _currentContext.LanguageId,
                        Code           = Common.Common.GenerateCodeFromId(systemIdentity),
                        StoreId        = ConfigSettingEnum.StoreId.GetConfig(),
                        ClientId       = _currentContext.ClientId,
                        CreatedUid     = customer.Id ?? string.Empty,
                        CartItem       = command,
                        CartItemDetail = new CartItemDetailAddCommand(SystemDefine.DefaultVersion)
                        {
                            ProductId = command.ProductId,
                            Name      = "Name",
                        }
                    };
                    await _cartService.Add(cartAddCommand);
                }
                else
                {
                    //if (cart.Version != item.Version)
                    //{
                    //    model.AddMessage(ResourceKey.Cart_IsChanged);
                    //    return model;
                    //}
                    CartItemChangeCommand command = item.ToCommand(1, _currentContext.LanguageId, customer.Id, cart);
                    await _cartService.Change(command);
                }
                cart = await _cartService.GetFromCache(_currentContext.ClientId, EnumDefine.CartStatusEnum.New);

                model.CartItems = cart.CartItemFulls?.Select(p => p.ToModel()).ToArray();
                return(model);
            }
            catch (Exception e)
            {
                _logger.LogError(e, e.Message);
                throw e;
            }
        }
Example #5
0
 public Cart(RCart cart)
 {
     Id              = cart.Id;
     ShardId         = cart.ShardId;
     Code            = cart.Code;
     CreatedDateUtc  = cart.CreatedDateUtc;
     UpdatedDateUtc  = cart.UpdatedDateUtc;
     CreatedUid      = cart.CreatedUid;
     UpdatedUid      = cart.UpdatedUid;
     LanguageId      = cart.LanguageId;
     StoreId         = cart.StoreId;
     ClientId        = cart.ClientId;
     Status          = cart.Status;
     Version         = cart.Version;
     CartItems       = cart.CartItems.Select(p => new CartItem(p)).ToList();
     CartItemDetails = cart.CartItemDetails?.ToDictionary(p => p.ProductId, p => new CartItemDetail(p));
 }
Example #6
0
        public async Task <CartViewModel> Get()
        {
            try
            {
                CartViewModel model = new CartViewModel(await InitAjax());
                RCart         cart  = await _cartService.GetFromCache(_currentContext.ClientId, EnumDefine.CartStatusEnum.New);

                if (cart != null)
                {
                    model.CartItems = cart.CartItemFulls?.Select(p => p.ToModel()).ToArray();
                }
                return(model);
            }
            catch (Exception e)
            {
                _logger.LogError(e, e.Message);
                throw e;
            }
        }
Example #7
0
        public async Task <bool> Add(RCart cart)
        {
            string key = CartKey;

            return(await RedisStorage.HashSet(key, cart.ClientId, cart));
        }
        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 static CartItemChangeCommand ToCommand(this CartItemChangeViewModel model, decimal price, string languageId, string updatedUid, RCart cart)
 {
     if (model == null)
     {
         return(null);
     }
     return(new CartItemChangeCommand(cart.Version)
     {
         Price = price,
         ProductId = model.ProductId,
         Quantity = model.Quantity,
         LanguageId = languageId,
         CartCode = cart.Code,
         CartId = cart.Id,
         StoreId = ConfigSettingEnum.StoreId.GetConfig(),
         UpdatedUid = updatedUid,
         Action = (EnumDefine.CartActionEnum)model.Action,
         ShardId = cart.ShardId,
         Version = cart.Version,
         CreatedDateUtc = Extensions.GetCurrentDateUtc(),
     });
 }