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))));
}
