static async Task Main(string[] args) { var stockRepository = new StockRepository(); var walletRepository = new WalletRepository(); var twoPhaseTransactions = new List<TwoPhaseTransaction>() { new DecreaseStockQuantityTransaction(stockRepository, new Dictionary<string, string>() {{"productId", "12"}, {"quantity", "10"}}), new DecreaseWalletBalanceTransaction(walletRepository, new Dictionary<string, string>() {{"userId", "150"}, {"totalPrice", "4000"}}) }; var tasks = new List<Task>(); twoPhaseTransactions.ForEach(x => tasks.Add(x.PrepareTransaction())); Task.WaitAll(tasks.ToArray()); tasks.Clear(); if (twoPhaseTransactions.All(x => x.Status is TransactionStatus.Prepared)) { twoPhaseTransactions.ForEach(x => tasks.Add(x.CommitTransaction())); } else { twoPhaseTransactions.Where(x => x.Status is TransactionStatus.Prepared) .ToList().ForEach(x => tasks.Add(x.RollBackTransaction())); } Task.WaitAll(tasks.ToArray()); }
public WalletsController(StoreRepository repo, AtomicSwapRepository atomicSwapRepository, WalletRepository walletRepository, CurrencyNameTable currencyTable, BTCPayNetworkProvider networkProvider, UserManager <ApplicationUser> userManager, MvcNewtonsoftJsonOptions mvcJsonOptions, NBXplorerDashboard dashboard, RateFetcher rateProvider, IAuthorizationService authorizationService, ExplorerClientProvider explorerProvider, IFeeProviderFactory feeRateProvider, BTCPayWalletProvider walletProvider, AtomicSwapClientFactory atomicSwapClientFactory) { _currencyTable = currencyTable; Repository = repo; WalletRepository = walletRepository; RateFetcher = rateProvider; _authorizationService = authorizationService; NetworkProvider = networkProvider; _userManager = userManager; _serializerSettings = mvcJsonOptions.SerializerSettings; _dashboard = dashboard; ExplorerClientProvider = explorerProvider; _feeRateProvider = feeRateProvider; _walletProvider = walletProvider; AtomicSwapClientFactory = atomicSwapClientFactory; AtomicSwapRepository = atomicSwapRepository; }
private static async Task CreateIndexesAsync(string settingsUrl) { if (!Uri.TryCreate(settingsUrl, UriKind.Absolute, out _)) { Console.WriteLine($"{SettingsUrl} should be a valid uri"); return; } var logFactory = LogFactory.Create() .AddConsole(); var settings = new SettingsServiceReloadingManager <AppSettings>(settingsUrl, p => { }).Nested(x => x.BlockchainWalletsService.Db.DataConnString); var defaultWalletsRepository = (WalletRepository)WalletRepository.Create(settings, logFactory); string continuationToken = null; Console.WriteLine("Creating Indexes..."); var progressCounter = 0; do { try { IEnumerable <WalletDto> wallets; (wallets, continuationToken) = await defaultWalletsRepository.GetAllAsync(100, continuationToken); foreach (var defaultWallet in wallets) { await defaultWalletsRepository.AddAsync ( defaultWallet.BlockchainType, defaultWallet.AssetId, defaultWallet.ClientId, defaultWallet.Address ); Console.SetCursorPosition(0, Console.CursorTop); Console.Write($"{++progressCounter} indexes created"); } } catch (Exception e) { Console.WriteLine(e.StackTrace + " " + e.Message); } } while (continuationToken != null); if (progressCounter == 0) { Console.WriteLine("Nothing to create"); } else { Console.WriteLine(); Console.WriteLine($"Added indexes to {progressCounter} wallets"); } }
public void TestOutOfStockFromOrderPanel() { // setup the tested class instance and dependencies with the test case initialization. MockDisplayPanel displayPanel = new MockDisplayPanel(); MockOrderPanel orderPanel = new MockOrderPanel(); MockPaymentReceiver paymentReceiver = new MockPaymentReceiver(); MockVendingMessageRepository messageRepository = new MockVendingMessageRepository(); ProductRepository productRepository = new ProductRepository(); WalletRepository walletRepository = new WalletRepository(); SoldRecord saleRecord = new SoldRecord(); VendingMachineController vendingMachineController = new VendingMachineController(displayPanel, paymentReceiver, orderPanel, productRepository, walletRepository, saleRecord, messageRepository); InitProductRepository(productRepository, 0, 0); // !!! setup order state vendingMachineController.VendingMachineState = VendingMachineState.Order; // Test subject Action - out of stock orderPanel.InvokeOrderAction(OrderCmdEvent.OutOfStock, null); Assert.Equal(VendingMachineState.OutOfStock, vendingMachineController.VendingMachineState); // verify - out of stock Assert.True(orderPanel.OffCalled); Assert.Equal(0, productRepository.CountProduct(PrdA.Code)); // verify the message flow List <MessageCode> TestCatchedCodes = new List <MessageCode> { MessageCode.OutOfStock }; Assert.Equal((IEnumerable <MessageCode>)TestCatchedCodes, (IEnumerable <MessageCode>)messageRepository.CatchedCodes); Assert.Equal((IEnumerable <string>)messageRepository.ReturnList, (IEnumerable <string>)displayPanel.DisplayList); }
public void TestSelectOrderFromOrderPanel() { // setup the tested class instance and dependencies with the test case initialization. MockDisplayPanel displayPanel = new MockDisplayPanel(); MockOrderPanel orderPanel = new MockOrderPanel(); MockPaymentReceiver paymentReceiver = new MockPaymentReceiver(); MockVendingMessageRepository messageRepository = new MockVendingMessageRepository(); ProductRepository productRepository = new ProductRepository(); WalletRepository walletRepository = new WalletRepository(); SoldRecord saleRecord = new SoldRecord(); VendingMachineController vendingMachineController = new VendingMachineController(displayPanel, paymentReceiver, orderPanel, productRepository, walletRepository, saleRecord, messageRepository); InitProductRepository(productRepository, 1, 1); // !!! setup order state vendingMachineController.VendingMachineState = VendingMachineState.Order; // Test subject Action - select order as product A orderPanel.InvokeOrderAction(OrderCmdEvent.Select, PrdA); Assert.Equal(VendingMachineState.Payment, vendingMachineController.VendingMachineState); // verify - select order as product A Assert.True(orderPanel.OffCalled); Assert.True(paymentReceiver.OnCalled); Assert.Equal(0, productRepository.CountProduct(PrdA.Code)); // verify the message flow List <MessageCode> TestCatchedCodes = new List <MessageCode> { MessageCode.Checkout }; Assert.Equal(TestCatchedCodes, messageRepository.CatchedCodes); Assert.Equal(messageRepository.ReturnList, displayPanel.DisplayList); }
public async Task <WalletRecord> IncomeOfOrderRebate(UserIdentifier userIdentifier, decimal money, string remark, Order order) { WalletRecord walletRecord = BuildWalletRecord(WalletRecordType.Recharge, userIdentifier.UserId, money, remark); WalletRecordRepository.Insert(walletRecord); Wallet wallet = GetWalletOfUser(userIdentifier); wallet.Money += money; WalletRepository.Update(wallet); CurrentUnitOfWork.SaveChanges(); string openid = WechatUserManager.GetOpenid(userIdentifier); if (!string.IsNullOrEmpty(openid)) { OrderRebateTemplateMessageData data = new OrderRebateTemplateMessageData( new TemplateDataItem(remark), new TemplateDataItem(order.Number), new TemplateDataItem(order.PayMoney.ToString()), new TemplateDataItem(order.PaymentDatetime.ToString()), new TemplateDataItem(money.ToString()), new TemplateDataItem(L("ThankYouForYourPatronage")) ); await TemplateMessageManager.SendTemplateMessageOfOrderRebateAsync(order.TenantId, openid, null, data); } return(walletRecord); }
public StoreOnChainWalletsController( IAuthorizationService authorizationService, BTCPayWalletProvider btcPayWalletProvider, BTCPayNetworkProvider btcPayNetworkProvider, WalletRepository walletRepository, ExplorerClientProvider explorerClientProvider, CssThemeManager cssThemeManager, NBXplorerDashboard nbXplorerDashboard, WalletsController walletsController, PayjoinClient payjoinClient, DelayedTransactionBroadcaster delayedTransactionBroadcaster, EventAggregator eventAggregator, WalletReceiveService walletReceiveService) { _authorizationService = authorizationService; _btcPayWalletProvider = btcPayWalletProvider; _btcPayNetworkProvider = btcPayNetworkProvider; _walletRepository = walletRepository; _explorerClientProvider = explorerClientProvider; _cssThemeManager = cssThemeManager; _nbXplorerDashboard = nbXplorerDashboard; _walletsController = walletsController; _payjoinClient = payjoinClient; _delayedTransactionBroadcaster = delayedTransactionBroadcaster; _eventAggregator = eventAggregator; _walletReceiveService = walletReceiveService; }
private ReturnObject AddSendTransactionToBlockchainAddress(UserSendTransaction sendTransaction) { try { using (var walletRepository = new WalletRepository(_connectionDb)) { var walletBusiness = new WalletBusiness.WalletBusiness(_vakapayRepositoryFactory, false); var wallet = walletRepository.FindByUserAndNetwork(sendTransaction.UserId, sendTransaction.Currency); if (wallet == null) { return(new ReturnObject() { Status = Status.STATUS_ERROR, Message = $"UserId {sendTransaction.UserId} with {sendTransaction.Currency} wallet is not found!" }); } var res = walletBusiness.Withdraw(wallet, sendTransaction.To, sendTransaction.Amount, sendTransaction.PricePerCoin, sendTransaction.Description); return(res); } } catch (Exception e) { _logger.Error(e.Message); throw; } }
public void TestOff() { // setup the tested class instance and dependencies with the test case initialization. MockDisplayPanel displayPanel = new MockDisplayPanel(); MockOrderPanel orderPanel = new MockOrderPanel(); MockPaymentReceiver paymentReceiver = new MockPaymentReceiver(); MockVendingMessageRepository messageRepository = new MockVendingMessageRepository(); ProductRepository productRepository = new ProductRepository(); WalletRepository walletRepository = new WalletRepository(); SoldRecord saleRecord = new SoldRecord(); VendingMachineController vendingMachineController = new VendingMachineController(displayPanel, paymentReceiver, orderPanel, productRepository, walletRepository, saleRecord, messageRepository); // Test subject Action - off vendingMachineController.Off(); // verify - off Assert.True(orderPanel.OffCalled); Assert.True(paymentReceiver.OffCalled); Assert.Equal(VendingMachineState.TurnedOff, vendingMachineController.VendingMachineState); // verify the message flow List <MessageCode> TestCatchedCodes = new List <MessageCode> { MessageCode.OutOfServise }; Assert.Equal((IEnumerable <MessageCode>)TestCatchedCodes, (IEnumerable <MessageCode>)messageRepository.CatchedCodes); Assert.Equal((IEnumerable <string>)messageRepository.ReturnList, (IEnumerable <string>)displayPanel.DisplayList); }
protected override void Load(ContainerBuilder builder) { var connectionString = _dbSettings.Nested(x => x.DataConnString); builder .Register(c => WalletRepository.Create(connectionString, c.Resolve <ILogFactory>())) .As <IWalletRepository>() .SingleInstance(); builder .Register(c => BlockchainWalletsRepository.Create(connectionString, c.Resolve <ILogFactory>())) .As <IBlockchainWalletsRepository>() .SingleInstance(); builder .Register(c => FirstGenerationBlockchainWalletRepository.Create(_dbSettings.Nested(x => x.ClientPersonalInfoConnString), c.Resolve <ILogFactory>())) .As <IFirstGenerationBlockchainWalletRepository>() .SingleInstance(); builder .Register(c => MonitoringSubscriptionRepository.Create(connectionString, c.Resolve <ILogFactory>())) .As <IMonitoringSubscriptionRepository>() .SingleInstance(); builder .Register(c => WalletCredentialsHistoryRepository.Create(_dbSettings.Nested(x => x.ClientPersonalInfoConnString), c.Resolve <ILogFactory>())) .As <IWalletCredentialsHistoryRepository>() .SingleInstance(); }
public GreenfieldStoreOnChainWalletsController( IAuthorizationService authorizationService, BTCPayWalletProvider btcPayWalletProvider, BTCPayNetworkProvider btcPayNetworkProvider, WalletRepository walletRepository, ExplorerClientProvider explorerClientProvider, NBXplorerDashboard nbXplorerDashboard, PoliciesSettings policiesSettings, UIWalletsController walletsController, PayjoinClient payjoinClient, DelayedTransactionBroadcaster delayedTransactionBroadcaster, EventAggregator eventAggregator, WalletReceiveService walletReceiveService, IFeeProviderFactory feeProviderFactory, LabelFactory labelFactory ) { _authorizationService = authorizationService; _btcPayWalletProvider = btcPayWalletProvider; _btcPayNetworkProvider = btcPayNetworkProvider; _walletRepository = walletRepository; _explorerClientProvider = explorerClientProvider; PoliciesSettings = policiesSettings; _nbXplorerDashboard = nbXplorerDashboard; _walletsController = walletsController; _payjoinClient = payjoinClient; _delayedTransactionBroadcaster = delayedTransactionBroadcaster; _eventAggregator = eventAggregator; _walletReceiveService = walletReceiveService; _feeProviderFactory = feeProviderFactory; _labelFactory = labelFactory; }
public void ExceptionsWalletTest() { WalletRepository wallet = new WalletRepository(); Assert.Throws <InvalidDataException>(() => { wallet.AddToWallet(p10, -1); }); Assert.Throws <ArgumentNullException>(() => { wallet.AddToWallet(null, 1); }); Assert.Throws <ArgumentNullException>(() => { wallet.AddToWallet(null, 0); }); Assert.Throws <ArgumentNullException>(() => { wallet.AddToWallet(null, -1); }); Assert.Throws <InvalidDataException>(() => { wallet.RemoveFromWallet(p10, 1); }); wallet.AddToWallet(p10, 1); Assert.Throws <InvalidDataException>(() => { wallet.RemoveFromWallet(p10, -1); }); Assert.Throws <InvalidDataException>(() => { wallet.RemoveFromWallet(p10, 2); }); wallet.RemoveFromWallet(p10, 1); Assert.Throws <InvalidDataException>(() => { wallet.RemoveFromWallet(p10, 1); }); Assert.Throws <ArgumentNullException>(() => { wallet.RemoveFromWallet(null, -1); }); Assert.Throws <ArgumentNullException>(() => { wallet.RemoveFromWallet(null, 0); }); Assert.Throws <ArgumentNullException>(() => { wallet.RemoveFromWallet(null, 1); }); Assert.Throws <NotImplementedException>(() => { wallet.ClearMoney(); }); try { PaymentWalletRepository pwallet = new PaymentWalletRepository(); pwallet.ClearMoney(); } catch { Assert.True(false); } }
public void AddWalletTest() { WalletRepository wallet = new WalletRepository(); // Add wallet.AddToWallet(p5, 1); wallet.AddToWallet(p10, 2); wallet.AddToWallet(p20, 3); wallet.AddToWallet(p50, 4); wallet.AddToWallet(p100, 5); // verify var content = wallet.WalletList; Assert.Single(content.Where(c => c.Item1.MoneyValue == p5.MoneyValue)); Assert.Single(content.Where(c => c.Item1.MoneyValue == p10.MoneyValue)); Assert.Single(content.Where(c => c.Item1.MoneyValue == p20.MoneyValue)); Assert.Single(content.Where(c => c.Item1.MoneyValue == p50.MoneyValue)); Assert.Single(content.Where(c => c.Item1.MoneyValue == p100.MoneyValue)); Assert.Equal(1, content.Single(c => c.Item1.Nominal == p5.Nominal).Item2); Assert.Equal(2, content.Single(c => c.Item1.Nominal == p10.Nominal).Item2); Assert.Equal(3, content.Single(c => c.Item1.Nominal == p20.Nominal).Item2); Assert.Equal(4, content.Single(c => c.Item1.Nominal == p50.Nominal).Item2); Assert.Equal(5, content.Single(c => c.Item1.Nominal == p100.Nominal).Item2); }
public async Task GetLastWalletEntryAsync_SingleEntry_ReturnsTheEntry() { //// Arrange // Setup In-Memory Database at desired state DbContextOptions <WalletContext> dbContextOptions = new DbContextOptionsBuilder <WalletContext>() .UseInMemoryDatabase(databaseName: "GetLastWalletEntryAsync_SingleEntry_ReturnsTheEntry") .Options; WalletEntry expectedEntry = new WalletEntry { Id = Guid.NewGuid().ToString(), EventTime = DateTime.UtcNow, Amount = 10, BalanceBefore = 0 }; using (WalletContext context = new WalletContext(dbContextOptions)) { context.Add(expectedEntry); context.SaveChanges(); } //// Act WalletEntry actualEntry; using (WalletContext context = new WalletContext(dbContextOptions)) { IWalletRepository walletRepository = new WalletRepository(context); actualEntry = await walletRepository.GetLastWalletEntryAsync(); } //// Assert Assert.NotNull(actualEntry); actualEntry.ShouldCompare(expectedEntry); }
public void TestGetUserWalletSubscriptionAndLastPaymentsInner() { var user = conn.PLATFORM_USER.First(u => u.SUBSCRIPTION.Count > 2 && u.TRANSFER.Count > 5); var subsCount = user.SUBSCRIPTION.Count; int paymentsTotal; List <Contract.Entity.Subscription> subscriptions; List <Transfer> transfers; WalletError error; var repo = new WalletRepository(); var wallet = repo.GetUserWalletSubscriptionAndLastPaymentsInner(user.Login, 100, out paymentsTotal, out subscriptions, out transfers, out error); Assert.AreEqual(WalletError.OK, error, "GetUserWalletSubscriptionAndLastPaymentsInner - должно быть ОК"); Assert.IsNotNull(wallet, "GetUserWalletSubscriptionAndLastPaymentsInner - кошелек должен быть получен"); Assert.Greater(paymentsTotal, 5, "GetUserWalletSubscriptionAndLastPaymentsInner - платежей должно быть больше N"); Assert.Greater(transfers.Count, 0, "GetUserWalletSubscriptionAndLastPaymentsInner - платежи должны быть получены"); Assert.AreEqual(subscriptions.Count, subsCount, "GetUserWalletSubscriptionAndLastPaymentsInner - подписки должны быть получены"); var distinctSubscriptionServiceAccounts = subscriptions.Select(s => s.PaidService.AccountId).Distinct().Count(); Assert.AreEqual(distinctSubscriptionServiceAccounts, subscriptions.Count, "GetUserWalletSubscriptionAndLastPaymentsInner - инф. о подписке должна быть заполнена"); }
public async Task InsertWalletAsync_MissingId_ThrowsInvalidOperationException() { //// Arrange // Setup In-Memory Database at desired state DbContextOptions <WalletContext> dbContextOptions = new DbContextOptionsBuilder <WalletContext>() .UseInMemoryDatabase(databaseName: "InsertWalletAsync_MissingId_ThrowsInvalidOperationException") .Options; // Initialize Entry WalletEntry missingIdEntry = new WalletEntry { Id = null, EventTime = DateTime.UtcNow, Amount = 10, BalanceBefore = 0 }; //// Act / Assert using (WalletContext context = new WalletContext(dbContextOptions)) { IWalletRepository walletRepository = new WalletRepository(context); await Assert.ThrowsAsync <InvalidOperationException>(() => walletRepository.InsertWalletEntryAsync(missingIdEntry) ); } }
public async Task InsertWalletAsync_NoEntries_SingleWalletEntry() { //// Arrange // Setup In-Memory Database at desired state DbContextOptions <WalletContext> dbContextOptions = new DbContextOptionsBuilder <WalletContext>() .UseInMemoryDatabase(databaseName: "InsertWalletAsync_NoEntries_SingleWalletEntry") .Options; // Initialize Entry WalletEntry expectedEntry = new WalletEntry { Id = Guid.NewGuid().ToString(), EventTime = DateTime.UtcNow, Amount = 10, BalanceBefore = 0 }; //// Act using (WalletContext context = new WalletContext(dbContextOptions)) { IWalletRepository walletRepository = new WalletRepository(context); await walletRepository.InsertWalletEntryAsync(expectedEntry); } //// Assert DbSet <WalletEntry> actualWalletEntries; using (WalletContext context = new WalletContext(dbContextOptions)) { actualWalletEntries = context.Transactions; Assert.Collection(actualWalletEntries, actualWalletEntry => actualWalletEntry.ShouldCompare(expectedEntry)); } }
public unit_test_WalletRepo() { //Setting up In memory dbs. userdb = new SqliteConnection("DataSource=:memory:"); passdb = new SqliteConnection("DataSource=:memory:"); walletdb = new SqliteConnection("DataSource=:memory:"); userdb.Open(); passdb.Open(); walletdb.Open(); var userbuild = new DbContextOptionsBuilder <UserModelContext>() .UseSqlite(userdb).Options; var passbuild = new DbContextOptionsBuilder <PassModelContext>() .UseSqlite(passdb).Options; var walletbuild = new DbContextOptionsBuilder <WalletContext>() .UseSqlite(walletdb).Options; var userContext = new UserModelContext(userbuild); var passContext = new PassModelContext(passbuild); var walletContext = new WalletContext(walletbuild); //Drop and create userContext.Database.EnsureDeleted(); userContext.Database.EnsureCreated(); passContext.Database.EnsureDeleted(); passContext.Database.EnsureCreated(); walletContext.Database.EnsureDeleted(); walletContext.Database.EnsureCreated(); //Seeding data to test on SeedUsers.seedUsers(userContext, passContext, walletContext); _uut = new WalletRepository(walletContext); }
public void TestOrderPaymentChangeGivenFromOrderPanel() { // setup the tested class instance and dependencies with the test case initialization. MockDisplayPanel displayPanel = new MockDisplayPanel(); MockOrderPanel orderPanel = new MockOrderPanel(); MockPaymentReceiver paymentReceiver = new MockPaymentReceiver(); MockVendingMessageRepository messageRepository = new MockVendingMessageRepository(); ProductRepository productRepository = new ProductRepository(); WalletRepository walletRepository = new WalletRepository(); SoldRecord saleRecord = new SoldRecord(); VendingMachineController vendingMachineController = new VendingMachineController(displayPanel, paymentReceiver, orderPanel, productRepository, walletRepository, saleRecord, messageRepository); InitProductRepository(productRepository, 1, 1); // !!! setup order state vendingMachineController.VendingMachineState = VendingMachineState.Order; // setup wallet repository walletRepository.AddToWallet(new Coin(5), 1); walletRepository.AddToWallet(new Coin(10), 1); walletRepository.AddToWallet(new Coin(20), 1); walletRepository.AddToWallet(new Coin(50), 1); var before = walletRepository.WalletList.Aggregate(Money.Zero, (m, p) => m + new Money(0, (int)p.Item1.Nominal * p.Item2)); // Test subject Action - select order as product A orderPanel.InvokeOrderAction(OrderCmdEvent.Select, PrdA); Assert.Equal(VendingMachineState.Payment, vendingMachineController.VendingMachineState); // verify reserved product Assert.Equal(PrdA, vendingMachineController.OrderedProducts[0]); // complete payment without change paymentReceiver.InvokeCoinAction(PaymentCmdEvent.Payment, new Coin(100)); // verify switch back to order state Assert.True(paymentReceiver.OffCalled); Assert.True(orderPanel.OnCalled); Assert.Equal(VendingMachineState.Order, vendingMachineController.VendingMachineState); // verify money in the wallet var total = walletRepository.WalletList.Aggregate(Money.Zero, (m, p) => m + new Money(0, (int)p.Item1.Nominal * p.Item2)); Assert.Equal(before + PrdA.Price, total); // verify the message flow List <MessageCode> TestCatchedCodes = new List <MessageCode> { MessageCode.Checkout, MessageCode.BalancePayment, MessageCode.GivenChange, MessageCode.GivenChange, MessageCode.GivenChange, MessageCode.CollectYourPurchase, MessageCode.ReadyToService, }; Assert.Equal((IEnumerable <MessageCode>)TestCatchedCodes, (IEnumerable <MessageCode>)messageRepository.CatchedCodes); Assert.Equal((IEnumerable <string>)messageRepository.ReturnList, (IEnumerable <string>)displayPanel.DisplayList); }
public GameController(IOptions <ConnectionStrings> connIn) { _gameRepo = new GameRepository(connIn.Value.DefaultConnection); _engine = new GameEngineRepository(connIn.Value.DefaultConnection); _diceRepo = new DiceRepository(connIn.Value.DefaultConnection); _shake = new ShakeValueRepository(connIn.Value.DefaultConnection); _wallets = new WalletRepository(connIn.Value.DefaultConnection); }
public UnitOfWorkMock(IPlayersWalletContext context) { Context = context; Players = new PlayerRepository(Context); Wallets = new WalletRepository(Context); Transactions = new TransactionRepository(Context); TransactionResponseCache = new TransactionResponseCacheRepository(Context); }
public LabelFactory( LinkGenerator linkGenerator, WalletRepository walletRepository ) { _linkGenerator = linkGenerator; _walletRepository = walletRepository; }
public ReturnObject ValidateWithdrawAmount(string userId, bool sendByBlockchainAddress, decimal amount, string sendTransactionFee, string currency) { try { // Validate amount if (amount <= 0) { return(new ReturnObject() { Status = Status.STATUS_ERROR, Message = "Withdraw balance must be positive." }); } using (var walletRepository = new WalletRepository(_connectionDb)) { var wallet = walletRepository.FindByUserAndNetwork(userId, currency); if (sendByBlockchainAddress == true) { if (amount + GetFee(currency) > wallet.Balance) { return(new ReturnObject() { Status = Status.STATUS_ERROR, Message = "Withdraw balance + fee is larger than wallet balance." }); } } else { if (amount > wallet.Balance) { return(new ReturnObject() { Status = Status.STATUS_ERROR, Message = "Withdraw balance larger than wallet balance." }); } } return(new ReturnObject() { Status = Status.STATUS_SUCCESS }); } } catch (Exception e) { return(new ReturnObject() { Status = Status.STATUS_ERROR, Message = "Validate amount throw exception." }); } }
public async Task UpdateBalance_ReturnsUpdatedWalletForExistingTransaction() { string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json"); var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID); string walletsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Wallets.json"); var wallet = JsonConvert.DeserializeObject <List <Wallet> >(walletsJson).First(w => w.User.Id == TESTING_USER_ID); string categoriesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Categories.json"); var category = JsonConvert.DeserializeObject <List <Category> >(categoriesJson) .First(c => c.IsCustom && c.User.Id == TESTING_USER_ID); string transactionsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Transactions.json"); var transaction = JsonConvert.DeserializeObject <List <Transaction> >(transactionsJson) .First(t => t.User.Id == TESTING_USER_ID && t.Category.Id == category.Id); transaction.User = user; transaction.Category = category; transaction.Wallet = wallet; double initBalance = wallet.Balance; const string newTitle = "Test title"; const double newAmount = 100; DateTime newDate = DateTime.Today.AddDays(-1); var newTransaction = new Transaction { Id = transaction.Id, User = user, Category = category, Wallet = wallet, Amount = newAmount, Title = newTitle, Date = newDate }; WalletRepository.Setup(w => w.Update(wallet)).ReturnsAsync(wallet); var resultWallet = await WalletService.UpdateBalance(newTransaction, transaction, isUpdate : true); Assert.NotNull(resultWallet); Assert.NotNull(resultWallet.Currency); Assert.Equal(wallet.Currency.Abbreviation, resultWallet.Currency.Abbreviation); Assert.Equal(wallet.Name, resultWallet.Name); Assert.Equal(wallet.IsDefault, resultWallet.IsDefault); if (category.Type.Name == TransactionType.Options.Income.ToString()) { Assert.Equal(initBalance - transaction.Amount - newAmount, resultWallet.Balance); } else if (category.Type.Name == TransactionType.Options.Expense.ToString()) { Assert.Equal(initBalance + transaction.Amount - newAmount, resultWallet.Balance); } }
public WalletControllerTest(ContextFixture contextFixture) { var walletRepository = new WalletRepository(contextFixture.ApiContext); var cryptoRepository = new CryptoRepository(contextFixture.ApiContext); var emailEmailService = new EmailService(); var coinMarketCapApiService = new WalletOperationsService(emailEmailService); _walletController = new WalletController(walletRepository, cryptoRepository, coinMarketCapApiService); }
public async Task Delete_ReturnsDeletedTransaction() { string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json"); var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID); string categoriesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Categories.json"); var category = JsonConvert.DeserializeObject <List <Category> >(categoriesJson) .First(c => c.IsCustom && c.User.Id == TESTING_USER_ID); string walletsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Wallets.json"); var wallet = JsonConvert.DeserializeObject <List <Wallet> >(walletsJson) .First(w => w.IsDefault); string transactionsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Transactions.json"); var transaction = JsonConvert.DeserializeObject <List <Transaction> >(transactionsJson) .First(u => u.User.Id == TESTING_USER_ID && u.Category.Id == category.Id); double initBalance = wallet.Balance; transaction.User = user; transaction.Category = category; transaction.Wallet = wallet; WalletRepository.Setup(w => w.Update(wallet)).ReturnsAsync(wallet); TransactionRepository.Setup(t => t.GetByKey(transaction.Id)).Returns(transaction); TransactionRepository.Setup(t => t.Delete(transaction.Id)).ReturnsAsync(transaction); ContextProvider .Setup(c => c.GetService <IWalletService>()) .Returns(WalletService); var resultTransaction = await TransactionService.Delete(transaction.Id); Assert.NotNull(resultTransaction); Assert.NotNull(resultTransaction.User); Assert.NotNull(resultTransaction.Category); Assert.NotNull(resultTransaction.Wallet); Assert.Equal(TESTING_USER_ID, resultTransaction.User.Id); Assert.Equal(category.Id, resultTransaction.Category.Id); Assert.Equal(wallet.Id, resultTransaction.Wallet.Id); Assert.Equal(transaction.Title, resultTransaction.Title); Assert.Equal(transaction.Amount, resultTransaction.Amount); Assert.Equal(transaction.Date, resultTransaction.Date); if (category.Type.Name == TransactionType.Options.Income.ToString()) { Assert.Equal(initBalance - transaction.Amount, resultTransaction.Wallet.Balance); } else if (category.Type.Name == TransactionType.Options.Expense.ToString()) { Assert.Equal(initBalance + transaction.Amount, resultTransaction.Wallet.Balance); } }
public ControlCashDbContext() : base("name=ControlCashDb") { LimitRepository = new LimitRepository(this); MovimentHistoryRepository = new MovimentHistoryRepository(this); UserRepository = new UserRepository(this); WalletRepository = new WalletRepository(this); LimitHistoryRepository = new LimitHistoryRepository(this); }
public void SetUp() { _wallet = new PlayerWallet(); _repository = Substitute.For <WalletRepository>(); _repository.Get().Returns(Observable.Return(_wallet)); _walletService = new WalletService(_repository); }
public async Task Create_ReturnsNewTransaction() { string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json"); var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID); string categoriesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Categories.json"); var category = JsonConvert.DeserializeObject <List <Category> >(categoriesJson) .First(c => !c.IsCustom || c.User.Id == TESTING_USER_ID); string walletsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Wallets.json"); var wallet = JsonConvert.DeserializeObject <List <Wallet> >(walletsJson) .First(w => !w.IsDefault && w.User.Id == TESTING_USER_ID); const string newTitle = "Test title"; const double newAmount = 101; string newInterval = RegularTransaction.IntervalOptions.Month.ToString(); DateTime newNextDate = DateTime.Today.AddDays(7); var newTransaction = new RegularTransaction { Title = newTitle, Amount = newAmount, CategoryId = category.Id, NextTransactionDate = newNextDate, Interval = newInterval, WalletId = wallet.Id }; UserRepository.Setup(u => u.GetByKey(TESTING_USER_ID)).Returns(user); CategoryRepository.Setup(c => c.GetByKey(category.Id)).Returns(category); RecurringTransactionRepository .Setup(t => t.Create(newTransaction)) .ReturnsAsync(newTransaction); WalletRepository.Setup(w => w.GetByKey(wallet.Id)).Returns(wallet); var resultTransaction = await RecurringTransactionService.Create(newTransaction); Assert.NotNull(resultTransaction); Assert.NotNull(resultTransaction.User); Assert.NotNull(resultTransaction.Category); Assert.NotNull(resultTransaction.Wallet); Assert.Equal(TESTING_USER_ID, resultTransaction.User.Id); Assert.Equal(category.Id, resultTransaction.Category.Id); Assert.Equal(wallet.Id, resultTransaction.Wallet.Id); Assert.Equal(newTitle, resultTransaction.Title); Assert.Equal(newAmount, resultTransaction.Amount); Assert.Equal(newInterval, resultTransaction.Interval); Assert.Equal(DateTime.Today, resultTransaction.Date); Assert.Equal(newNextDate, resultTransaction.NextTransactionDate); }
private Wallet CreateWalletOfUser(UserIdentifier userIdentifier) { Wallet wallet = new Wallet() { UserId = userIdentifier.UserId }; WalletRepository.Insert(wallet); unitOfWorkManager.Current.SaveChanges(); return(wallet); }