public static async Task <TransactionsResponse> GetAllTransactions(this ITransactionApi myPontoApi, Guid accountId)
{
var allTransactionsResponse = new TransactionsResponse();
allTransactionsResponse.Data = new List <TransactionResource>();
var transactionResponse = await myPontoApi.GetTransactions(accountId);
allTransactionsResponse.Meta = transactionResponse.Meta;
allTransactionsResponse.Meta.Paging = null;
TransactionsResponse nextPage = await transactionResponse.Links.GetFirstPage();
allTransactionsResponse.Data.AddRange(nextPage.Data);
if (nextPage.Links.Next != null)
{
do
{
nextPage = await nextPage.Links.GetNextPage();
allTransactionsResponse.Data.AddRange(nextPage.Data);
allTransactionsResponse.Links = nextPage.Links;
} while (nextPage.Links.Next != null);
}
return(allTransactionsResponse);
}
public async Task GetTransactionsAnd200()
{
var accountNumber = "12345";
var postCode = "E8 1DY";
var transactionsResponse = new TransactionsResponse
{
TransactionRequest = new TransactionRequest
{
PaymentRef = accountNumber,
PostCode = postCode
},
Transactions = new List <LBHTransactions>
{
new LBHTransactions
{
Balance = "123.00",
Date = DateTime.Now.ToString(),
Description = "Some description",
valueIn = "123.00"
}
}
};
_getTransactionsUseCase.Setup(x => x.Execute(accountNumber, postCode)).ReturnsAsync(transactionsResponse);
var response = await _classUnderTest.GetTransactions(accountNumber, postCode).ConfigureAwait(true) as IActionResult as OkObjectResult;
response.Should().NotBeNull();
response.StatusCode.Should().Be(200);
response.Value.Should().BeOfType <TransactionsResponse>();
response.Value.Should().BeEquivalentTo(transactionsResponse);
}
public IResponse createHistoryResultsResponse(List <SaleEN> pSalesList, string pToken)
{
TransactionsResponse response = new TransactionsResponse();
HistoryResponse history = new HistoryResponse();
history.transactions = new List <Sale>();
foreach (var item in pSalesList)
{
Sale sale = new Sale();
sale.Amount = item.Amount;
sale.currency = item.Currency;
sale.date = item.Date; //Date is actually server's date. Used by Android clients, as android sets displayed dates based on TimeZone set on device
sale.FormattedAmount = item.FormattedAmount;
sale.id = item.ID.ToString();
sale.msisdn = item.Msisdn;
sale.Operator = item.OperatorName;
sale.paid = item.Paid;
sale.Pais = item.CountryName;
sale.salesman = item.PersonName;
sale.serverDateGMT = item.ISOServerDate;
sale.status = (item.Success) ? "Exitosa" : "Fallida";
sale.transaction_id = item.TransactionID;
history.transactions.Add(sale);
}
response.History = history;
response.count = history.transactions.Count;
response.token = pToken;
return(response);
}
public async Task ReturnsCorrectResponseWhenTransactionExists()
{
var accountNumber = "12345";
var postCode = "E8 1DY";
var transactionsResponse = new TransactionsResponse
{
TransactionRequest = new TransactionRequest
{
PaymentRef = accountNumber,
PostCode = postCode
},
Transactions = new List <LBHTransactions>
{
new LBHTransactions
{
Balance = "123.00",
Date = DateTime.Now.ToString(),
Description = "Some description",
valueIn = "123.00"
}
}
};
_mockTransactionsGateway.Setup(x => x.GetTransactions(accountNumber, postCode)).ReturnsAsync(transactionsResponse);
var response = await _classUnderTest.Execute(accountNumber, postCode).ConfigureAwait(true);
response.Should().NotBeNull();
response.Should().BeOfType <TransactionsResponse>();
response.Should().Equals(transactionsResponse);
}
public IResponse createHistoryResultsResponseGMT(List <SaleEN> pSalesList, string pToken)
{
TransactionsResponse response = new TransactionsResponse();
HistoryResponse history = new HistoryResponse();
history.transactions = new List <Sale>();
foreach (var item in pSalesList)
{
Sale sale = new Sale();
sale.Amount = item.Amount;
sale.currency = item.Currency;
sale.date = item.Date; //Server date on 'date' property in response for iOS clients
sale.FormattedAmount = item.FormattedAmount;
sale.id = item.ID.ToString();
sale.msisdn = item.Msisdn;
sale.Operator = item.OperatorName;
sale.paid = item.Paid;
sale.Pais = item.CountryName;
sale.salesman = item.PersonName;
sale.serverDateGMT = item.ISOServerDate;
sale.status = (item.Success) ? "Exitosa" : "Fallida";
sale.transaction_id = item.TransactionID;
history.transactions.Add(sale);
}
response.History = history;
response.count = history.transactions.Count;
response.token = pToken;
return(response);
}
public void AddTransactions(IReadOnlyCollection <Transaction> transactions)
{
progress.AppendLine($"Added {transactions.Count} transactions for {budget.Name}/{account.Name}");
transactionSinceOldest = GetTransactionSinceDate(transactions.Min(item => item.Date));
foreach (var transaction in transactions)
{
AddTransaction(transaction);
}
if (updateTransactions.Any())
{
logger.Trace("Updated: " + JsonConvert.SerializeObject(updateTransactions, Formatting.Indented));
ynabApi.Transactions.UpdateTransactions(budget.Id.ToString(), new UpdateTransactionsWrapper(updateTransactions));
progress.AppendLine($"Updated: {updateTransactions.Count}");
}
if (!saveTransactions.Any())
{
return;
}
logger.Trace("New: " + JsonConvert.SerializeObject(saveTransactions, Formatting.Indented));
ynabApi.Transactions.CreateTransaction(budget.Id.ToString(), new SaveTransactionsWrapper(null, saveTransactions));
progress.AppendLine($"New: {saveTransactions.Count}");
}
/// <summary>
/// Retrieves all transactions since the given transactionId (inclusive)
/// </summary>
/// <param name="accountId">the id of the account to which the transaction belongs</param>
/// <param name="transactionId">the id of the first transaction to retrieve</param>
/// <returns>List of transaction objects</returns>
public static async Task <List <ITransaction> > GetTransactionsSinceIdAsync(string accountId, long transactionId)
{
string requestString = Server(EServer.Account) + "accounts/" + accountId + "/transactions/sinceid";
requestString += "?id=" + transactionId;
TransactionsResponse response = await MakeRequestAsync <TransactionsResponse>(requestString);
return(response.transactions);
}
public async Task <IActionResult> Get([FromQuery] PagedTransactionRequest request)
{
var response = _dataService.GetTransactionsAsync(request);
var count = _dataService.GetTotalTransactionCountAsync(request.IgnorePayments);
var trxResp = new TransactionsResponse()
{
Data = await response, Total = await count, Skip = request.Skip, Take = request.Take
};
return(Ok(trxResp));
}
public override Task <TransactionsResponse> GetTransactions(AccountRequest request, ServerCallContext context)
{
TransactionsResponse response = new TransactionsResponse();
var transactions = Transaction.GetTransactions(request.Address);
foreach (Transaction trx in transactions)
{
TrxModel mdl = ConvertTrxModel(trx);
response.Transactions.Add(mdl);
}
return(Task.FromResult(response));
}
private async Task <List <TransactionDetail> > GetVenmoDeposits(Database.Models.VenmoUser venmoUser, Configuration configuration)
{
TransactionsApi transactionsApi = new TransactionsApi(configuration);
TransactionsResponse transactions = await transactionsApi.GetTransactionsByAccountAsync(Default, venmoUser.YNAB !.DefaultAccount);
var venmoDeposits = transactions.Transactions
.Where(t => t.PayeeName != null && t.PayeeName.ToLower().Contains("from venmo"))
.OrderByDescending(t => t.Date)
.ToList();
return(venmoDeposits);
}
public TransactionAdder(TransactionsResponse transactionSinceOldest, Transaction transaction)
{
id = transaction.Id;
hasTransactionId = !string.IsNullOrEmpty(id);
date = transaction.Date.Date;
mcc = transaction.Mcc;
memo = GetMemo(transaction.Memo);
payee = GetPayee(transaction.Payee);
amount = GetAmount(transaction.Amount);
transactionsWithSameAmountAndDate = transactionSinceOldest.Data.Transactions.Where(item => item.Amount == amount && item.Date.Date == transaction.Date.Date).ToList();
logger.Trace("Old transaction with same amount and same date: " + JsonConvert.SerializeObject(transactionsWithSameAmountAndDate, Formatting.Indented));
}
public ServiceResult <TransactionsResponse> GetTransactions(Guid stockId, DateRange dateRange)
{
if (_Portfolio == null)
{
return(ServiceResult <TransactionsResponse> .NotFound());
}
var transactions = _Portfolio.Transactions.ForHolding(stockId, dateRange);
var response = new TransactionsResponse();
response.Transactions.AddRange(transactions.Select(x => x.ToTransactionItem(dateRange.ToDate)));
return(ServiceResult <TransactionsResponse> .Ok(response));
}
public async Task <TransactionsResponse> GetTransactions(GetTransactionsRequest request)
{
var message = CreateHttpRequest(HttpMethod.Post, $"{HOST}/api/transaction/get");
string postContent = JsonConvert.SerializeObject(request);
message.Content = new StringContent(postContent, Encoding.UTF8, "application/json");
HttpResponseMessage response = await _httpClient.SendAsync(message);
response.EnsureSuccessStatusCode();
string responseContent = await response.Content.ReadAsStringAsync();
TransactionsResponse result = JsonConvert.DeserializeObject <TransactionsResponse>(responseContent);
return(result);
}
public void GetTransactionsBothDates()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var response = new TransactionsResponse();
var service = mockRepository.Create <IPortfolioTransactionService>();
service.Setup(x => x.GetTransactions(new DateRange(new Date(2000, 01, 01), new Date(2000, 12, 31)))).Returns(ServiceResult <TransactionsResponse> .Ok(response)).Verifiable();
var controller = new PortfolioController();
var result = controller.GetTransactions(service.Object, new DateTime(2000, 01, 01), new DateTime(2000, 12, 31));
result.Result.Should().BeOkObjectResult().Value.Should().Be(response);
mockRepository.VerifyAll();
}
public void GetTransactionsNoDates()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var response = new TransactionsResponse();
var service = mockRepository.Create <IPortfolioTransactionService>();
service.Setup(x => x.GetTransactions(new DateRange(Date.Today.AddYears(-1).AddDays(1), Date.Today))).Returns(ServiceResult <TransactionsResponse> .Ok(response)).Verifiable();
var controller = new PortfolioController();
var result = controller.GetTransactions(service.Object, null, null);
result.Result.Should().BeOkObjectResult().Value.Should().Be(response);
mockRepository.VerifyAll();
}
//Version 1.0.4
static void Main(string[] args)
{
//Create class with the API Key
WhaleAlert whaleAlert = new WhaleAlert("API Key here");
//Get request --> Reponse Status Object
StatusResponse Status = whaleAlert.GetStatus();
//Error Handling
if (Status.Success == false)
{
Console.WriteLine(Status.Error.Message);
return;
}
//Success
Console.WriteLine(Status.Status.Result);
//Blockchain Count
Console.WriteLine(Status.Status.BlockchainCount);
//List of all Blockchains
foreach (Blockchain entry in Status.Status.Blockchains)
{
string symbols = "";
foreach (string s in entry.Symbols)
{
symbols += s + ",";
}
Console.WriteLine($"{entry.Name} [{symbols}]: {entry.Status}");
}
Console.WriteLine("\n");
//Get request --> Reponse Transactions Object
TransactionsResponse transactionsResponse = whaleAlert.GetTransactions(1550237797);
//List of Transcations
int counter = 0;
foreach (Transactions entry in transactionsResponse.Transactions.Transactions)
{
counter++;
Console.WriteLine($"{counter}. {entry.Symbol}: {entry.Amount}; USD: {entry.AmountUsd}");
}
}
public static void SearchTransResponse(Form1 form, String JSONString)
{
DataContractJsonSerializer serializer1 = new DataContractJsonSerializer(typeof(TransactionsResponse));
TransactionsResponse response = null;
Console.WriteLine(JSONString);
try
{
response = Deserialize <TransactionsResponse>(JSONString);
}
catch (Exception e)
{
Console.WriteLine("Parsing response get Exception: " + e.Message);
throw e;
}
Console.WriteLine("rows count: " + response.rows.Length);
for (int i = 0; i < response.rows.Length; i++)
{
form.TransFromNexioList.Rows.Add(false, response.rows[i].id, response.rows[i].amount);
}
}
public async Task ReturnsCorrectResponseWhenTransactionDoesNotExist()
{
var accountNumber = "12345";
var postCode = "E8 1DY";
var transactionsResponse = new TransactionsResponse
{
TransactionRequest = new TransactionRequest
{
PaymentRef = accountNumber,
PostCode = postCode
},
Transactions = new List <LBHTransactions>()
};
_mockTransactionsGateway.Setup(x => x.GetTransactions(accountNumber, postCode)).ReturnsAsync(transactionsResponse);
var response = await _classUnderTest.Execute(accountNumber, postCode).ConfigureAwait(true);
response.Should().NotBeNull();
response.Should().BeOfType <TransactionsResponse>();
response.Should().Equals(transactionsResponse);
response.Transactions.Count.Should().Equals(0);
}
public async Task GetEmptyTransactions()
{
var accountNumber = "12345";
var postCode = "E8 1DY";
var transactionsResponse = new TransactionsResponse
{
TransactionRequest = new TransactionRequest
{
PaymentRef = accountNumber,
PostCode = postCode
},
Transactions = new List <LBHTransactions>()
};
_getTransactionsUseCase.Setup(x => x.Execute(accountNumber, postCode)).ReturnsAsync(transactionsResponse);
var response = await _classUnderTest.GetTransactions(accountNumber, postCode).ConfigureAwait(true) as IActionResult as OkObjectResult;
response.Should().NotBeNull();
response.StatusCode.Should().Be(200);
var transactionResponse = (TransactionsResponse)response.Value;
transactionResponse.Transactions.Count.Should().Equals(0);
}
public async Task GetTransactions()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var portfolioId = Guid.NewGuid();
var dateRange = new DateRange(new Date(2001, 02, 03), new Date(2008, 06, 30));
var response = new TransactionsResponse();
var messageHandler = mockRepository.Create <IRestClientMessageHandler>();
messageHandler.SetupProperty(x => x.Portfolio, portfolioId);
messageHandler.Setup(x => x.GetAsync <TransactionsResponse>(It.Is <string>(x => x == "portfolio/" + portfolioId + "/transactions?fromdate=2001-02-03&todate=2008-06-30")))
.Returns(Task <TransactionsResponse> .FromResult(response))
.Verifiable();
var resource = new PortfolioResource(messageHandler.Object);
var result = await resource.GetTransactions(dateRange);
result.Should().Be(response);
mockRepository.Verify();
}
public override Task <TransactionsResponse> GetTransactions(AccountRequest request, ServerCallContext context)
{
var response = new TransactionsResponse();
var transactions = this.blockChain
.GetTransactions(request.Address)
.Select(t => new TransactionModel()
{
TransactionID = t.Hash,
TimeStamp = t.TimeStamp,
Sender = t.Sender,
Recipient = t.Recipient,
Amount = t.Amount,
Fee = t.Fee,
});
foreach (var trx in transactions)
{
response.Transactions.Add(trx);
}
return(Task.FromResult(response));
}
public static async Task <TransactionsResponse> GetNewTransactions(this ITransactionApi myPontoApi, Guid accountId, Guid lastKnownTransactionId)
{
var allTransactionsResponse = new TransactionsResponse();
allTransactionsResponse.Data = new List <TransactionResource>();
var transactionResponse = await myPontoApi.GetTransactionsBefore(accountId, lastKnownTransactionId);
allTransactionsResponse.Meta = transactionResponse.Meta;
allTransactionsResponse.Meta.Paging = null;
allTransactionsResponse.Data.AddRange(transactionResponse.Data);
if (transactionResponse.Links.Prev != null)
{
do
{
transactionResponse = await transactionResponse.Links.GetPreviousPage();
allTransactionsResponse.Data.AddRange(transactionResponse.Data);
allTransactionsResponse.Links = transactionResponse.Links;
} while (transactionResponse.Links.Prev != null);
}
return(allTransactionsResponse);
}
public ActionResult <TransactionsResponse> GetTransactions(Guid userId)
{
TransactionsResponse transactionsResponse = new TransactionsResponse
{
Purchases = new List <PurchaseBE>(),
Tickets = new List <TicketBE>(),
Vouchers = new List <VoucherBE>(),
Orders = new List <OrderBE>()
};
using (UnitOfWork unitOfWork = new UnitOfWork(_context))
{
User user = unitOfWork.Users.GetWithRelated(userId);
if (user == null)
{
return(NotFound("User"));
}
user.Purchases.ForEach(p =>
{
Purchase purchase = unitOfWork.Purchases.GetWithRelated(p.Id);
transactionsResponse.Purchases.Add(new PurchaseBE
{
Id = purchase.Id,
PerformanceId = purchase.PerformanceId,
PerformanceName = purchase.Performance.Name,
PerformanceDate = purchase.Performance.Date,
PaidValue = purchase.PaidValue,
TicketAmount = unitOfWork.Purchases.GetPurchaseTicketAmount(p.Id)
});
purchase.Tickets.ForEach(t =>
{
if (!t.Used)
{
transactionsResponse.Tickets.Add(new TicketBE
{
Id = t.Id,
PerformanceId = purchase.Performance.Id,
PerformanceName = purchase.Performance.Name,
PerformanceDate = purchase.Performance.Date,
PlaceInRoom = t.PlaceInRoom
});
}
});
});
user.Vouchers.ForEach(v =>
{
if (v.OrderId == null)
{
transactionsResponse.Vouchers.Add(new VoucherBE
{
Id = v.Id,
Type = v.Type
});
}
});
user.Orders.ForEach(o =>
{
Order order = unitOfWork.Orders.GetWithRelated(o.Id);
List <string> acceptedVoucherTypes = new List <string>();
order.Vouchers.ForEach(v =>
{
acceptedVoucherTypes.Add(v.Type);
});
List <OrderProductBE> orderProducts = new List <OrderProductBE>();
order.OrdersProducts.ForEach(op =>
{
Product product = unitOfWork.Products.Get(op.ProductId);
orderProducts.Add(new OrderProductBE
{
Id = product.Id,
Name = product.Name,
Price = product.Price,
Quantity = op.Quantity
});
});
transactionsResponse.Orders.Add(new OrderBE
{
Id = o.Id,
PaidValue = o.PaidValue,
AcceptedVoucherTypes = acceptedVoucherTypes,
OrdersProducts = orderProducts
});
});
}
return(Ok(transactionsResponse));
}
public async Task Run(
[TimerTrigger("0 */5 * * * *")] TimerInfo timerInfo,
[DurableClient] IDurableOrchestrationClient starter)
{
if (starter is null)
{
throw new ArgumentNullException(nameof(starter));
}
var allGlobalXSettings = await _mediator.Send(new GlobalXOrgSettingsQuery()
{
TransactionSyncEnabled = true
});
var allExceptions = new List <Exception>();
foreach (var globalXSettings in allGlobalXSettings)
{
var latestTransactionId = globalXSettings.LatestTransactionId;
try
{
var validator = new GlobalXOrgSettings.Validator();
validator.ValidateAndThrow(globalXSettings);
}
catch (ValidationException vex)
{
allExceptions.Add(vex);
_logger.LogError(vex, $"Error encountered processing transactions for org key'{globalXSettings?.ActionstepOrgKey}'. Settings are invalid.");
}
TransactionsResponse transactionsResponse = null;
try
{
transactionsResponse = await _globalXService.GetTransactions(new TransactionsQuery()
{
UserId = globalXSettings.GlobalXAdminId,
TransId = globalXSettings.LatestTransactionId + 1,
UserType = UserType.AllChildren
});
}
catch (Exception ex)
{
allExceptions.Add(ex);
_logger.LogError(ex, $"Error encountered while retrieving transactions for" +
$" org '{globalXSettings?.ActionstepOrgKey}', GlobalX Admin ID: '{globalXSettings?.GlobalXAdminId}'");
}
if (!(transactionsResponse is null))
{
foreach (var transaction in transactionsResponse.Transactions)
{
try
{
var transactionSyncInstanceId = GlobalXTransactionSyncOrchestrator.InstancePrefix + transaction.TransactionId.ToString(CultureInfo.InvariantCulture);
var existingInstance = await starter.GetStatusAsync(transactionSyncInstanceId);
if (existingInstance is null)
{
await starter.StartNewAsync(
orchestratorFunctionName : nameof(GlobalXTransactionSyncOrchestrator),
instanceId : transactionSyncInstanceId,
input : new CreateDisbursementsCommand()
{
ActionstepUserId = globalXSettings.ActionstepSyncUserId,
Transaction = transaction,
ActionstepOrgKey = globalXSettings.ActionstepOrgKey,
MinimumMatterIdToSync = globalXSettings.MinimumMatterIdToSync,
TaxCodeIdWithGST = globalXSettings.TaxCodeIdWithGST.Value,
TaxCodeIdNoGST = globalXSettings.TaxCodeIdNoGST.Value
});
}
else
{
_logger.LogWarning($"Orchestration '{nameof(GlobalXTransactionSyncOrchestrator)}' with id '{transactionSyncInstanceId}' is already running, so does not need to be started");
}
if (transaction.TransactionId > latestTransactionId)
{
latestTransactionId = transaction.TransactionId;
}
}
catch (Exception ex)
{
allExceptions.Add(ex);
_logger.LogError(ex, $"Error encountered processing transaction '{transaction?.TransactionId}' for" +
$" org '{globalXSettings?.ActionstepOrgKey}', GlobalX Admin ID: '{globalXSettings?.GlobalXAdminId}'");
}
}
}
if (latestTransactionId > globalXSettings.LatestTransactionId)
{
await _mediator.Send(new SetLatestGlobalXTransactionIdCommand(globalXSettings.ActionstepOrgKey, latestTransactionId));
}
}
if (allExceptions.Count > 0)
{
// If there were any failures, throwing ensures that the TimerJob shows up as failed.
throw new AggregateException("One or more failures encountered while processing GlobalX transactions.", allExceptions);
}
}
