private bool ValidateName(Wallet wallet)
 {
     if (wallet.Name.Length <= 0)
     {
         wallet.AddError(nameof(Wallet), nameof(wallet.Name), ErrorCode.StringEmpty);
         return(false);
     }
     else if (wallet.Name.Length > 500)
     {
         wallet.AddError(nameof(Wallet), nameof(wallet.Name), ErrorCode.StringLimited);
         return(false);
     }
     return(true);
 }
Ejemplo n.º 2
0
        public async Task <Wallet> Create(Wallet wallet)
        {
            wallet.Id = Guid.NewGuid();

            if (wallet == null)
            {
                return(null);
            }
            if (!await WalletValidator.Create(wallet))
            {
                return(wallet);
            }

            using (UnitOfWork.Begin())
            {
                try
                {
                    await UnitOfWork.WalletRepository.Create(wallet);

                    await UnitOfWork.Commit();
                }
                catch (Exception ex)
                {
                    await UnitOfWork.Rollback();

                    wallet.AddError(nameof(WalletService), nameof(wallet.Id), CommonEnum.ErrorCode.SystemError);
                }
            }
            return(wallet);
        }
Ejemplo n.º 3
0
        public async Task <Wallet> UpdateWalletName(Wallet wallet, string newName)
        {
            if (wallet == null)
            {
                return(null);
            }
            if (!await WalletValidator.Update(wallet, newName))
            {
                return(wallet);
            }

            using (UnitOfWork.Begin())
            {
                try
                {
                    WalletFilter filter = new WalletFilter
                    {
                        UserId = new GuidFilter {
                            Equal = wallet.UserId
                        },
                        Name = new StringFilter {
                            Equal = wallet.Name
                        }
                    };
                    wallet = await Get(filter);

                    wallet.Name = newName;

                    await UnitOfWork.WalletRepository.Update(wallet);

                    await UnitOfWork.Commit();

                    return(await Get(new WalletFilter
                    {
                        Id = new GuidFilter {
                            Equal = wallet.Id
                        },
                        UserId = new GuidFilter {
                            Equal = wallet.UserId
                        },
                        Name = new StringFilter {
                            Equal = wallet.Name
                        },
                        Balance = new DecimalFilter {
                            Equal = wallet.Balance
                        }
                    }));
                }
                catch (Exception ex)
                {
                    await UnitOfWork.Rollback();

                    wallet.AddError(nameof(WalletService), nameof(wallet.Id), CommonEnum.ErrorCode.SystemError);
                }
            }
            return(wallet);
        }
 private bool ValidateBalance(Wallet wallet)
 {
     if (wallet.Balance.ToString() == null)
     {
         wallet.AddError(nameof(Wallet), nameof(wallet.Balance), ErrorCode.InitBalanceEmpty);
         return(false);
     }
     else if (wallet.Balance.ToString().Length > 15)
     {
         wallet.AddError(nameof(Wallet), nameof(wallet.Balance), ErrorCode.InitBalanceLimited);
         return(false);
     }
     else if (wallet.Balance < 0)
     {
         wallet.AddError(nameof(Wallet), nameof(wallet.Balance), ErrorCode.InitBalanceInvalid);
         return(false);
     }
     return(true);
 }
 private bool ValidateNewWalletName(Wallet wallet, string newWalletName)
 {
     if (newWalletName == null)
     {
         wallet.AddError(nameof(WalletValidator), nameof(newWalletName), ErrorCode.InvalidWalletName);
         return(false);
     }
     else if (newWalletName.Length <= 0)
     {
         wallet.AddError(nameof(Wallet), nameof(wallet.Name), ErrorCode.StringEmpty);
         return(false);
     }
     else if (newWalletName.Length > 500)
     {
         wallet.AddError(nameof(Wallet), nameof(wallet.Name), ErrorCode.StringLimited);
         return(false);
     }
     return(true);
 }
        private async Task <bool> WalletDuplicated(Wallet wallet)
        {
            WalletFilter walletFilter = new WalletFilter
            {
                Take = Int32.MaxValue,
                Id   = new GuidFilter {
                    Equal = wallet.Id
                }
            };
            int count = await unitOfWork.WalletRepository.Count(walletFilter);

            if (count > 0)
            {
                wallet.AddError(nameof(WalletValidator), nameof(wallet.Name), ErrorCode.WalletDuplicated);
                return(false);
            }
            return(true);
        }
        private async Task <bool> ValidateNotExistedWallet(Wallet wallet)
        {
            WalletFilter filter = new WalletFilter
            {
                UserId = new GuidFilter {
                    Equal = wallet.UserId
                },
                Name = new StringFilter {
                    Equal = wallet.Name
                }
            };

            int countWallet = await unitOfWork.WalletRepository.Count(filter);

            if (countWallet > 0)
            {
                wallet.AddError(nameof(WalletValidator), nameof(wallet.Name), ErrorCode.WalletDuplicated);
                return(false);
            }
            return(true);
        }
Ejemplo n.º 8
0
        public async Task <Wallet> Delete(Wallet wallet)
        {
            if (!await WalletValidator.Delete(wallet))
            {
                return(wallet);
            }

            using (UnitOfWork.Begin())
            {
                try
                {
                    WalletFilter walletFilter = new WalletFilter
                    {
                        UserId = new GuidFilter {
                            Equal = wallet.UserId
                        },
                        Name = new StringFilter {
                            Equal = wallet.Name
                        }
                    };
                    Wallet walletToDelete = await UnitOfWork.WalletRepository.Get(walletFilter);

                    await UnitOfWork.WalletRepository.Delete(walletToDelete.Id);

                    await UnitOfWork.Commit();

                    return(walletToDelete);
                }
                catch (Exception ex)
                {
                    await UnitOfWork.Rollback();

                    wallet.AddError(nameof(WalletService), nameof(wallet.Id), CommonEnum.ErrorCode.SystemError);
                    return(wallet);
                }
            }
        }