public async Task AddMultipleTransaction() { var mockRepository = new MockRepository(MockBehavior.Strict); var portfolioId = Guid.NewGuid(); var transactions = new List <Transaction>(); transactions.AddRange(TransactionTypesData().Select(x => (Transaction)x[0])); var messageHandler = mockRepository.Create <IRestClientMessageHandler>(); messageHandler.SetupGet(x => x.Portfolio).Returns(portfolioId); messageHandler.Setup(x => x.PostAsync <IEnumerable <Transaction> >( It.Is <string>(x => x == "portfolio/" + portfolioId + "/transactions"), It.Is <IEnumerable <Transaction> >(x => x.Count() == transactions.Count))) .Returns(Task.CompletedTask) .Verifiable(); var resource = new TransactionResource(messageHandler.Object); await resource.Add(transactions); mockRepository.Verify(); }
public async Task GetTransaction(Transaction transaction) { var mockRepository = new MockRepository(MockBehavior.Strict); var portfolioId = Guid.NewGuid(); var transactionId = Guid.NewGuid(); transaction.Id = transactionId; var messageHandler = mockRepository.Create <IRestClientMessageHandler>(); messageHandler.SetupGet(x => x.Portfolio).Returns(portfolioId); messageHandler.Setup(x => x.GetAsync <Transaction>(It.Is <string>(x => x == "portfolio/" + portfolioId + "/transactions/" + transactionId))) .Returns(Task <Transaction> .FromResult(transaction as Transaction)) .Verifiable(); var resource = new TransactionResource(messageHandler.Object); var result = await resource.Get(transactionId); result.Should().BeOfType(transaction.GetType()).And.BeEquivalentTo(new { Id = transactionId }); mockRepository.Verify(); }
public ConfirmPage(WizardData wizardData) { InitializeComponent(); AccountResource account = wizardData.Account; try { IJKEService channel = ServiceManager.GetChannel(); string today = DateTime.Now.ToShortDateString(); TransactionResource previewTansaction = channel.GetTransactionPreview(account.AccountNumber, wizardData.Organization.Name, today, wizardData.Percentage); wizardData.PreviewTransaction = previewTansaction; AccountResource previewAccount = new AccountResource(); previewAccount.Balance = previewTansaction.PostBalance; previewAccount.Dividends = account.Dividends; previewAccount.DividendsETD = account.DividendsETD; previewAccount.Contributions = account.Contributions + previewTansaction.Amount; previewAccount.ContributionsETD = account.ContributionsETD + previewTansaction.Amount; wizardData.PreviewAccount = previewAccount; } catch (Exception ex) { MessageBox.Show(ex.Message); } // Bind wizard state to UI this.DataContext = wizardData; }
public void GetTransactionsForAccountTest() { using (JKEFactory factory = ServiceManager.CreateFactory()) { IJKEService target = factory.CreateChannel(); string userId = "jbrown"; AccountResource[] accounts = target.GetUserAccounts(userId); Assert.IsNotNull(accounts); Assert.IsTrue(accounts.Length > 0); AccountResource account = accounts[0]; TransactionResource[] transactions = target.GetTransactionsForAccount(userId, account.Type); Assert.IsNotNull(transactions); if (transactions.Length > 0) { foreach (TransactionResource transaction in transactions) { Assert.AreEqual(account.AccountNumber, transaction.AccountNumber); } TransactionResource lastTransaction = transactions[transactions.Length - 1]; Assert.AreEqual(account.Balance, lastTransaction.PostBalance); } } }
public Client(Credentials credentials, IEnvironment env = null) { if (credentials == null) { throw new ArgumentNullException(nameof(credentials)); } environment = env ?? Environments.Production; requester = new Requester(credentials, environment, null, this.apiVersion); Account = new AccountResource(requester); Balance = new BalanceResource(requester); Charges = new ChargeResource(requester); Customers = new CustomerResource(requester); Disputes = new DisputeResource(requester); Events = new EventResource(requester); Forex = new ForexResource(requester); Links = new LinkResource(requester); Occurrences = new OccurrenceResource(requester); Sources = new PaymentSourceResource(requester); Receipts = new ReceiptResource(requester); Recipients = new RecipientResource(requester); Refunds = new RefundResource(requester); Schedules = new ScheduleResource(requester); Tokens = new TokenResource(requester); Transactions = new TransactionResource(requester); Transfers = new TransferResource(requester); }
public async Task AddTransaction(Transaction transaction) { var mockRepository = new MockRepository(MockBehavior.Strict); var portfolioId = Guid.NewGuid(); var transactionId = Guid.NewGuid(); transaction.Id = transactionId; var messageHandler = mockRepository.Create <IRestClientMessageHandler>(); messageHandler.SetupGet(x => x.Portfolio).Returns(portfolioId); messageHandler.Setup(x => x.PostAsync <Transaction>( It.Is <string>(x => x == "portfolio/" + portfolioId + "/transactions"), It.Is <Transaction>(x => x.GetType() == transaction.GetType() && x.Id == transactionId))) .Returns(Task.CompletedTask) .Verifiable(); var resource = new TransactionResource(messageHandler.Object); await resource.Add(transaction); mockRepository.Verify(); }
public async Task GetTransactionsForCorporateAction() { var mockRepository = new MockRepository(MockBehavior.Strict); var portfolioId = Guid.NewGuid(); var stockId = Guid.NewGuid(); var corporateActionId = Guid.NewGuid(); var transactions = new List <Transaction>() { new OpeningBalance() { Id = Guid.NewGuid(), Units = 10 }, new ReturnOfCapital() { Id = Guid.NewGuid(), Amount = 50.45m }, }; var messageHandler = mockRepository.Create <IRestClientMessageHandler>(); messageHandler.SetupGet(x => x.Portfolio).Returns(portfolioId); messageHandler.Setup(x => x.GetAsync <List <Transaction> >(It.Is <string>(x => x == "portfolio/" + portfolioId + "/transactions/" + stockId + "/corporateactions/" + corporateActionId))) .Returns(Task <List <Transaction> > .FromResult(transactions)) .Verifiable(); var resource = new TransactionResource(messageHandler.Object); var result = await resource.GetTransactionsForCorporateAction(stockId, corporateActionId); result.Should().BeEquivalentTo(transactions); mockRepository.Verify(); }
private TransactionResource GenerateTransactionResource(IEnumerable <Expense> transactionList) { var transactions = mapper.Map <IEnumerable <Expense>, List <Transaction> >(transactionList); var transactionResource = new TransactionResource(); var banks = transactionList.Where(i => i.BankAccount != null).Select(i => i.BankAccount.Name).Distinct(); transactionResource.Transactions = transactions; transactionResource.AvailableColumns.AddRange(banks); return(transactionResource); }
public async Task <ActionResult> GetTransaction(int id) { var transactionInDb = await _transactionRepository.GetTransactionAsync(id, includeRelated : true); if (transactionInDb == null) { return(NotFound()); } return(Ok(TransactionResource.FromData(transactionInDb, includeRelated: true))); }
public async Task <IActionResult> PostAsync([FromBody] TransactionResource resource) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessages())); } var result = await _transactionService.SaveAsync(resource); if (!result.Success) { _logger.LogError($"Error occured while saving transaction for account {resource.AccountId}"); return(BadRequest(result.Message)); } return(Ok(result.Transaction)); }
public async Task <AddTransactionResponse> SaveAsync(TransactionResource resource) { var transaction = _mapper.Map <TransactionResource, Transaction>(resource); try { await _transactionRepository.AddAsync(transaction); await _unitOfWork.CompleteAsync(); return(new AddTransactionResponse(_mapper.Map <Transaction, TransactionResource>(transaction))); } catch (Exception ex) { return(new AddTransactionResponse($"An error occurred when saving the transaction: {ex.Message}")); } }
public Client(Credentials credentials) { if (credentials == null) throw new ArgumentNullException("credentials"); requester = new Requester(credentials); Account = new AccountResource(requester); Balance = new BalanceResource(requester); Cards = new CardResourceShim(requester); Charges = new ChargeResource(requester); Customers = new CustomerResource(requester); Disputes = new DisputeResource(requester); Events = new EventResource(requester); Recipients = new RecipientResource(requester); Refunds = new RefundResourceShim(requester); Tokens = new TokenResource(requester); Transactions = new TransactionResource(requester); Transfers = new TransferResource(requester); }
public void PostTransactionTest() { using (JKEFactory factory = ServiceManager.CreateFactory()) { IJKEService target = factory.CreateChannel(); string userId = "jbrown"; AccountResource[] accounts = target.GetUserAccounts(userId); Assert.IsNotNull(accounts); Assert.IsTrue(accounts.Length > 0); AccountResource account = accounts[0]; OrganizationResource[] organizations = target.GetOrganizations(); Assert.IsNotNull(organizations); Assert.IsTrue(organizations.Length > 0); OrganizationResource organization = organizations[0]; TransactionResource[] transactions = target.GetTransactionsForAccount(userId, account.Type); Assert.IsNotNull(transactions); int before = transactions.Length; double percentage = 2; double amount = account.Dividends * percentage / 100; string today = DateTime.Now.ToShortDateString(); TransactionResource newTransaction = target.PostTransaction(account.AccountNumber, organization.Name, today, percentage); Assert.IsNotNull(newTransaction); Assert.AreEqual(amount, newTransaction.Amount); Assert.AreEqual(account.AccountNumber, newTransaction.AccountNumber); DateTime newDate = Convert.ToDateTime(newTransaction.Date, CultureInfo.InvariantCulture); Assert.AreEqual(today, newDate.ToShortDateString()); Assert.AreEqual(organization.Name, newTransaction.Source); Assert.AreEqual(account.Balance - amount, newTransaction.PostBalance); transactions = target.GetTransactionsForAccount(userId, account.Type); Assert.IsNotNull(transactions); int after = transactions.Length; Assert.AreEqual(before + 1, after); } }
public ReturnPage(WizardData wizardData) { InitializeComponent(); try { IJKEService channel = ServiceManager.GetChannel(); string today = DateTime.Now.ToShortDateString(); TransactionResource transaction = channel.PostTransaction(wizardData.Account.AccountNumber, wizardData.Organization.Name, today, wizardData.Percentage); wizardData.Transaction = transaction; } catch (Exception ex) { MessageBox.Show(ex.Message); } // Bind wizard state to UI this.DataContext = wizardData; }
public Client(Credentials credentials) { if (credentials == null) { throw new ArgumentNullException(nameof(credentials)); } requester = new Requester(credentials); Account = new AccountResource(requester); Balance = new BalanceResource(requester); Cards = new CardResourceShim(requester); Charges = new ChargeResource(requester); Customers = new CustomerResource(requester); Disputes = new DisputeResource(requester); Events = new EventResource(requester); Links = new LinkResource(requester); Recipients = new RecipientResource(requester); Refunds = new RefundResourceShim(requester); Tokens = new TokenResource(requester); Transactions = new TransactionResource(requester); Transfers = new TransferResource(requester); }
public IActionResult AddTransaction([FromBody] TransactionResource receivedTransaction) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // if (!this._nodeService.CheckSenderBalance(receivedTransaction.From, receivedTransaction.Value)) // { // return BadRequest("Insufficient funds."); // } Transaction transaction = new Transaction(new Address(receivedTransaction.From), new Address(receivedTransaction.To), receivedTransaction.Value, receivedTransaction.Fee, receivedTransaction.SenderPublicKey, receivedTransaction.SenderSignature) { DateCreated = receivedTransaction.DateCreated }; transaction.TransactionHash = this._transactionService.CalculateTransactionHash(transaction); if (!this._transactionService.Validate(transaction)) { return(BadRequest("Invalid transaction signature.")); } if (this._nodeService.CheckForCollison(transaction.TransactionHash)) { return(BadRequest("Transaction already exists.")); } this._nodeService.AddTransaction(transaction); TransactionResource resource = this._mapper.Map <Transaction, TransactionResource>(transaction); return(Ok(resource)); }
private AddTransactionResponse(bool success, string message, TransactionResource transaction) : base(success, message) { Transaction = transaction; }
public AddTransactionResponse(TransactionResource transaction) : this(true, string.Empty, transaction) { }
public async Task <ActionResult> GetTransactions(int kidId = 0) { return(Ok((await _transactionRepository.GetTransactionsAsync(kidId, includeRelated: true)).Select(t => TransactionResource.FromData(t, includeRelated: true)))); }