public async Task <CommandResult> Handle(MakeTransferCommand command, CancellationToken cancellationToken)
        {
            var user = await context.Users.Include(x => x.Wallets).FirstOrDefaultAsync(x => x.Id == command.UserId);

            if (!user.Wallets.Any(x => x.Id == command.Transaction.SourceId))
            {
                return(CommandResult.ReturnFailure());
            }

            if (!context.Users.Any(e => e.UserName == command.Transaction.Username) || !context.Wallets.Any(e => e.Id == command.Transaction.TargetId))
            {
                return(CommandResult.ReturnFailure());
            }

            var source          = context.Wallets.FirstOrDefault(e => e.Id == command.Transaction.SourceId);
            var destinationUser = context.Users.Include(e => e.Wallets).FirstOrDefault(e => e.UserName == command.Transaction.Username);
            var destination     = destinationUser.Wallets.FirstOrDefault(e => e.Id == command.Transaction.TargetId);

            if (destination == null || source.Amount < command.Transaction.Amount)
            {
                return(CommandResult.ReturnFailure());
            }

            source.Amount -= command.Transaction.Amount;
            decimal destinationAmount = CurrencyManager.CheckCurrency(command.Transaction.Amount, source.Currency, destination.Currency);

            destination.Amount += destinationAmount;

            var transaction = new Transaction
            {
                SourceWalletId      = source.Id,
                SourceUserId        = command.UserId,
                SourceUserName      = user.UserName,
                DestinationWalletId = destination.Id,
                DestinationUserId   = destinationUser.Id,
                DestinationUserName = destinationUser.UserName,
                Date     = DateTime.Now,
                Amount   = command.Transaction.Amount,
                Currency = source.Currency
            };

            context.Add(transaction);
            context.SaveChanges();

            return(CommandResult.ReturnSuccess());
        }
Exemple #2
0
        public async Task <CommandResult> Handle(ReciveCashByCodeCommand command, CancellationToken cancellationToken)
        {
            if (!context.Users.Any(e => e.Id == command.UserId))
            {
                return(CommandResult.ReturnFailure());
            }

            var user = await context.Users.Include(x => x.Wallets).FirstOrDefaultAsync(x => x.Id == command.UserId);

            if (!user.Wallets.Any(e => e.Id == command.WalletId))
            {
                return(CommandResult.ReturnFailure());
            }

            if (!context.CashByCodeRepo.Any(e => e.GeneratedCode == command.Code))
            {
                return(CommandResult.ReturnFailure());
            }

            var wallet = await context.Wallets.FirstOrDefaultAsync(e => e.Id == command.WalletId);

            var cashByCode = await context.CashByCodeRepo.FirstOrDefaultAsync(e => e.GeneratedCode == command.Code);

            if (cashByCode.ExpireTime < DateTime.Now)
            {
                context.CashByCodeRepo.Remove(cashByCode);
                context.SaveChanges();
                return(CommandResult.ReturnFailure());
            }

            wallet.Amount += CurrencyManager.CheckCurrency(cashByCode.Amount, cashByCode.Currency, wallet.Currency);
            context.CashByCodeRepo.Remove(cashByCode);
            context.SaveChanges();

            return(CommandResult.ReturnSuccess());
        }