public string GetTransactionsFromApi(string fromDate, string toDate)
{
TransactionFilter transactionFilter = new TransactionFilter()
{
FromServiceDate = fromDate, ToServiceDate = toDate
};
TransactionFieldsToReturn transactionFieldsToReturn = new TransactionFieldsToReturn();
GetTransactionsResp response = null;
GetTransactionsReq request = new GetTransactionsReq()
{
RequestHeader = _requestHeader,
Filter = transactionFilter,
Fields = transactionFieldsToReturn
};
response = _kareoServices.GetTransactions(request);
if (response.ErrorResponse.IsError)
{
return(response.ErrorResponse.ErrorMessage);
}
if (response.Transactions == null || response.Transactions.Length == 0)
{
return("No results. Check Customer Key is valid in .config file.");
}
List <TransactionData> responseData = response.Transactions.ToList();
string fileName = @"\Transactions_" + fromDate + "_" + toDate + ".xls";
return(ExportTransactions(responseData, fileName));
}
public void QueryTransaction_Rapidv40_Test()
{
if (GetVersion() > 31)
{
var client = CreateRapidApiClient();
//Arrange
var transaction = TestUtil.CreateTransaction();
//Act
var response = client.Create(PaymentMethod.Direct, transaction);
var filter = new TransactionFilter()
{
TransactionID = response.TransactionStatus.TransactionID
};
var queryResponse = client.QueryTransaction(filter);
var queryResponse2 = client.QueryTransaction(response.TransactionStatus.TransactionID);
//Assert
Assert.IsNotNull(queryResponse);
Assert.IsNotNull(queryResponse2);
Assert.AreEqual(response.TransactionStatus.TransactionID, queryResponse.TransactionStatus.TransactionID);
Assert.AreEqual(response.TransactionStatus.TransactionID, queryResponse2.TransactionStatus.TransactionID);
Assert.AreEqual(response.TransactionStatus.Total, queryResponse2.TransactionStatus.Total);
Assert.AreEqual("036", queryResponse2.Transaction.CurrencyCode);
Assert.AreEqual(response.TransactionStatus.Total, queryResponse2.Transaction.MaxRefund);
}
else
{
Assert.Inconclusive();
}
}
/// <summary>
/// Gets the filtered transactions ssynchronously.
/// <remarks>If this method is consumed, make sure to hook to the <seealso cref="ITransactionRepository.GetTransactionsCompleted"/> event of this instance of <see cref="ITransactionRepository"/>.</remarks>
/// <param name="filter">The instance of <see cref="TransactionFilter"/> that wraps all filter values.</param>
/// </summary>
void ITransactionRepository.GetTransactionsAsync(TransactionFilter filter)
{
QueueAsyncTask(() =>
{
Exception exception = null;
string message = null;
IList <Transaction> transList = null;
try
{
//This treachery is for faking a web service call.
Thread.Sleep(2000);
transList = GetTransactions(filter);
LogUtil.LogInfo("TransactionRepository", "ITransactionRepository.GetTransactionsAsync", "Successfully acquired the list.");
}
catch (Exception ex)
{
LogUtil.LogError("TransactionRepository", "ITransactionRepository.GetTransactionsAsync", ex);
exception = ex;
message = ErrorMessages.ERR_FAILED_TO_LOAD_TRNS;
}
finally
{
if (null != _getTransactionsCompleted)
{
_getTransactionsCompleted(this, new GetTransactionFinishedEventArg(exception, message, transList));
}
}
});
}
public void OnResourceExecuted_WithExceptionRollsback()
{
ActionContext action = new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor());
ResourceExecutedContext context = new ResourceExecutedContext(action, Array.Empty <IFilterMetadata>());
DbContext currentContext = TestingContext.Create();
DbContext testingContext = TestingContext.Create();
Role role = ObjectsFactory.CreateRole(0);
context.Exception = new Exception();
testingContext.Drop();
TransactionFilter filter = new TransactionFilter(testingContext);
testingContext.Add(role);
testingContext.SaveChanges();
Assert.Empty(currentContext.Set <Role>());
Assert.Single(testingContext.Set <Role>());
filter.OnResourceExecuted(context);
Assert.Empty(currentContext.Set <Role>());
Assert.Empty(testingContext.Set <Role>());
}
/// <summary>
/// query all nep transactions(on chain)
/// </summary>
/// <returns></returns>
public async Task <object> QueryNep5Transactions(int pageIndex = 1, int limit = 100, UInt160 address = null, UInt160 asset = null, uint?blockHeight = null)
{
using var db = new TrackDB();
var filter = new TransactionFilter()
{
BlockHeight = blockHeight,
PageIndex = pageIndex,
PageSize = limit
};
if (address != null)
{
filter.FromOrTo = new List <UInt160>()
{
address
};
}
if (asset != null)
{
filter.Contracts = new List <UInt160>()
{
asset
};
}
var trans = db.QueryTransactions(filter, true);
var result = new PageList <TransactionPreviewModel>
{
TotalCount = trans.TotalCount,
PageSize = trans.PageSize,
PageIndex = pageIndex,
List = ConvertToTransactionPreviewModel(trans.List),
};
return(result);
}
public void GetTransactions_FilterByTag_FilteredTransactions()
{
var target = TestHelper.CreateClient();
var filter = new TransactionFilter();
filter.TagId = TestHelper.TagId;
var actual = target.GetTransactions(filter);
Assert.AreNotEqual(0, actual.TotalCount);
foreach (var t in actual.Entities)
{
Assert.IsTrue(t.TagNames.Contains(TestHelper.TagName));
}
filter.TagId = null;
filter.TagName = TestHelper.TagName;
actual = target.GetTransactions(filter);
Assert.AreNotEqual(0, actual.TotalCount);
foreach (var t in actual.Entities)
{
Assert.IsTrue(t.TagNames.Contains(TestHelper.TagName));
}
}
protected override void ConfigureInMemoryReceiveEndpoint(IInMemoryReceiveEndpointConfigurator configurator)
{
_myConsumer = new MyConsumer(GetTask <A>());
_transactionFilter = new TransactionFilter(GetTask <bool>(), GetTask <bool>());
configurator.Consumer(() => _myConsumer, x => x.UseFilter(_transactionFilter));
}
public void AddTransaction_Transaction_Added()
{
var target = TestHelper.CreateClient();
var transaction = new Transaction()
{
Description = "Test transaction from BuxferSharp.FunctionalTest",
Amount = 1,
AccountName = TestHelper.AccountName,
Date = DateTime.Now.AddYears(1)
};
var actual = target.AddTransaction(transaction);
Assert.IsTrue(actual);
var filter = new TransactionFilter()
{
AccountName = TestHelper.AccountName
};
var lastTransactions = target.GetTransactions(filter);
var last = lastTransactions.Entities.First();
Assert.AreEqual(transaction.Description, last.Description);
Assert.AreEqual(transaction.Amount, last.Amount);
Assert.AreEqual(transaction.AccountName, last.AccountName);
}
/// <summary>
/// Gets the transactions.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
private IList <Transaction> GetTransactions(TransactionFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException("filter");
}
using (var session = SessionProvider.SessionFactory.OpenSession())
{
//Build the criteria.
ICriteria criteria = session.CreateCriteria <Transaction>();
if (filter.FromDate.HasValue && filter.ToDate.HasValue)
{
criteria.Add(Restrictions.Between("TransactionDate", filter.FromDate.Value, filter.ToDate.Value));
}
if (filter.FromAmount.HasValue && filter.ToAmount.HasValue)
{
criteria.Add(Restrictions.Between("Amount", filter.FromAmount.Value, filter.ToAmount.Value));
}
if (!string.IsNullOrEmpty(filter.Username))
{
criteria.Add(Restrictions.Eq("CreatedBy", filter.Username));
}
return(criteria.List <Transaction>());
}
}
public IActionResult Get([FromQuery] TransactionFilter parameters = null)
{
try
{
var model = repository.GetByFilter(parameters).Select(a => new
{
a.PurchaseId,
a.ReceiptNum,
a.DateTimeOut,
a.VehicleNum,
a.SupplierName,
a.RawMaterialDesc,
a.RawMaterialDescPOType,
a.PONum,
a.POType,
a.GrossWt,
a.TareWt,
a.NetWt,
a.MC,
a.SourceCategoryDesc,
a.DriverName,
a.WeigherOutName,
});
return(Ok(model));
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessages());
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.FetchError));
}
}
public void Test_AddTransactionFilter_After_Dispose()
{
using var context = new DdeContext();
IDdeTransactionFilter filter = new TransactionFilter();
context.Dispose();
Assert.Throws<ObjectDisposedException>(() => context.AddTransactionFilter(filter));
}
private async Task <List <TransactionDayGroup> > ListTransactionDayGroup(TransactionDayGroupFilter filter)
{
// Khoi tao List chua ket qua
List <TransactionDayGroup> result = new List <TransactionDayGroup>();
// Lay het ngay trong thang filter ra
List <DateTime> dates = GetDates(filter.Year, filter.Month);
// Trong moi ngay ma co Transaction thi tao 1 TransactionDayGroup
foreach (DateTime date in dates)
{
// Tao filter theo tung ngay trong thang
TransactionFilter transactionFilter = new TransactionFilter
{
Date = new DateTimeFilter {
Equal = date
},
WalletName = new StringFilter {
Equal = filter.WalletName
},
UserId = new GuidFilter {
Equal = filter.UserId
}
};
// List transactions trong ngay hom do
List <Transaction> transactions = await List(transactionFilter);
// Neu ngay hom do co transactions thi tao 1 TransactionDayGroup moi
if (transactions != null)
{
if (transactions.Count > 0)
{
decimal inflow = 0;
decimal outflow = 0;
transactions.ForEach(t =>
{
if (t.Amount < 0)
{
outflow += t.Amount;
}
else
{
inflow += t.Amount;
}
});
result.Add(new TransactionDayGroup
{
Date = date,
Transactions = transactions,
Inflow = inflow,
Outflow = outflow
});
}
}
}
// Tra ket qua
return(result);
}
public async Task <TransactionResponse> GetTransactions(TransactionFilter filter)
{
var income = await _incomeService.FilterAsync(filter);
var expense = await _expenseService.FilterAsync(filter);
var adjustment = await _adjustmentService.FilterAsync(filter);
return(new TransactionResponse
{
Adjustment = new TransactionCollection <BalanceAdjustment>
{
Items = adjustment.records,
TotalCount = adjustment.count
},
Expense = new TransactionCollection <Expense>
{
Items = expense.records,
TotalCount = expense.count
},
Income = new TransactionCollection <Income>
{
Items = income.records,
TotalCount = income.count
}
});
}
public async Task AddLegacy_Transaction_Transaction_Added()
{
var target = TestClientFactory.BuildClient(out var settings);
var transaction = new Transaction
{
Description = "Test transaction from BuxferSharp.FunctionalTest",
Amount = 1,
AccountName = settings.AccountName,
Date = DateTime.Now.AddYears(1)
};
var actual = await target.AddTransactionAsSms(transaction);
Assert.IsTrue(actual);
var filter = new TransactionFilter
{
AccountName = settings.AccountName
};
var lastTransactions = await target.GetTransactions(filter);
var last = lastTransactions.Entities.First();
Assert.AreEqual(transaction.Description, last.Description);
Assert.AreEqual(transaction.Amount, last.Amount);
Assert.AreEqual(transaction.AccountName, last.AccountName);
}
public async Task <int> Count(TransactionFilter filter)
{
IQueryable <TransactionDAO> transactions = wASContext.Transaction;
transactions = DynamicFilter(transactions, filter);
return(await transactions.CountAsync());
}
public QueryTransactionResponse QueryTransaction(TransactionFilter filter)
{
if (!filter.IsValid)
{
return(SdkInternalErrorsResponse <QueryTransactionResponse>());
}
var response = new TransactionSearchResponse();
if (filter.IsValidTransactionID)
{
response = _rapidService.QueryTransaction(filter.TransactionID);
}
else if (filter.IsValidAccessCode)
{
response = _rapidService.QueryTransaction(filter.AccessCode);
}
else if (filter.IsValidInvoiceRef)
{
response = _rapidService.QueryInvoiceRef(filter.InvoiceReference);
}
else if (filter.IsValidInvoiceNum)
{
response = _rapidService.QueryInvoiceNumber(filter.InvoiceNumber);
}
return(_mappingService.Map <TransactionSearchResponse, QueryTransactionResponse>(response));
}
public async Task Run()
{
var blockchainProxyService = new BlockchainProxyService("https://rinkeby.infura.io/v3/25e7b6dfc51040b3bfc0e47317d38f60");
var transactionHandler = new SimpleTransactionHandler();
var handlers = new HandlerContainer {
TransactionHandler = transactionHandler
};
//only tx sent to this address
var transactionFilter = TransactionFilter.To("0xc0e15e11306334258d61fee52a22d15e6c9c59e0");
var filter = new FilterContainer(transactionFilter);
var blockProcessor = BlockProcessorFactory.Create(
blockchainProxyService,
handlers,
filter,
processTransactionsInParallel: false);
var processingStrategy = new ProcessingStrategy(blockProcessor);
var blockchainProcessor = new BlockchainProcessor(processingStrategy);
var result = await blockchainProcessor.ExecuteAsync(2830143, 2830153);
Assert.True(result);
Assert.Equal(12, transactionHandler.TransactionsHandled.Count);
Assert.Empty(transactionHandler.ContractCreationTransactionsHandled);
}
#pragma warning disable CS1573 // Parameter has no matching param tag in the XML comment (but other parameters do)
public async Task <IActionResult> TransactionDetailsByBundle(string hash, TransactionFilter filter)
#pragma warning restore CS1573 // Parameter has no matching param tag in the XML comment (but other parameters do)
{
if (!CommonHelpers.IsValidHash(hash))
{
return(BadRequest("Incorect format of the bundle hash")); //return 400 error
}
HashSet <TransactionContainer> res;
try
{
res = await _repository.GetDetailedTransactionsByBundle(hash);
}
catch (Exception e)
{
_logger.LogError(e, "Error occured in " + nameof(TransactionDetailsByBundle));
return(StatusCode(504)); //returns 504
}
List <TransactionContainer> sorted;
if (filter == TransactionFilter.All)
{ // all transactions
sorted = (from i in res orderby i.Transaction.Timestamp descending select i).ToList();
}
else
{ // only confirmed
sorted = (from i in res where (bool)i.IsConfirmed orderby i.Transaction.Timestamp descending select i).ToList();
}
return(Json(sorted));
}
public async Task GetTransactions_FilterByTag_FilteredTransactions()
{
var target = TestClientFactory.BuildClient(out var settings);
var filter = new TransactionFilter();
filter.TagId = settings.TagId;
var actual = await target.GetTransactions(filter);
Assert.AreNotEqual(0, actual.TotalCount);
foreach (var t in actual.Entities)
{
Assert.IsTrue(t.TagNames.Contains(settings.TagName));
}
filter.TagId = null;
filter.TagName = settings.TagName;
actual = await target.GetTransactions(filter);
Assert.AreNotEqual(0, actual.TotalCount);
foreach (var t in actual.Entities)
{
Assert.IsTrue(t.TagNames.Contains(settings.TagName));
}
}
public async Task Run()
{
var web3 = new Web3.Web3(TestConfiguration.BlockchainUrls.Infura.Rinkeby);
var transactionHandler = new SimpleTransactionHandler();
var handlers = new HandlerContainer {
TransactionHandler = transactionHandler
};
//only tx sent to this address
var transactionFilter = TransactionFilter.To("0xc0e15e11306334258d61fee52a22d15e6c9c59e0");
var filter = new FilterContainer(transactionFilter);
var blockProcessor = BlockProcessorFactory.Create(
web3,
handlers,
filter,
processTransactionsInParallel: false);
var processingStrategy = new ProcessingStrategy(blockProcessor);
var blockchainProcessor = new BlockchainProcessor(processingStrategy);
var result = await blockchainProcessor.ExecuteAsync(2830143, 2830153);
Assert.True(result);
Assert.Equal(12, transactionHandler.TransactionsHandled.Count);
Assert.Empty(transactionHandler.ContractCreationTransactionsHandled);
}
public void Test_RemoveTransactionFilter()
{
using var context = new DdeContext();
var filter = new TransactionFilter();
context.AddTransactionFilter(filter);
context.RemoveTransactionFilter(filter);
}
private static void ApplyFilter(OrderItemSpecification specification, TransactionFilter filter)
{
if (filter.From.HasValue)
{
specification.Where(transaction => transaction.CreationDate.Date >= filter.From.Value.Date);
}
if (filter.To.HasValue)
{
specification.Where(transaction => transaction.CreationDate <= filter.To.Value.Date);
}
if (filter.paymentMethod.HasValue)
{
specification.Where(orderItem => orderItem.Transactions
.Any(Transaction =>
Transaction.PaymentMethod.Type == filter.paymentMethod));
}
if (filter.Status.HasValue)
{
specification.Where(orderItem => orderItem.Transactions
.Any(Transaction =>
filter.Status == TransactionStatus.All ||
Transaction.Status == filter.Status));
}
if (!string.IsNullOrEmpty(filter.Patient))
{
filter.Patient = filter.Patient.Trim();
specification.Where(orderItem =>
orderItem.Patient.FirstName == filter.Patient ||
orderItem.Patient.LastName == filter.Patient ||
orderItem.Patient.Email == filter.Patient);
}
}
public void QueryTransaction_ByInvoiceRef_Test()
{
var client = CreateRapidApiClient();
//Arrange
var transaction = TestUtil.CreateTransaction();
var r = new Random();
var randomInvoiceRef = r.Next(100000, 999999);
transaction.PaymentDetails.InvoiceReference = randomInvoiceRef.ToString();
//Act
var response = client.Create(PaymentMethod.Direct, transaction);
var filter = new TransactionFilter()
{
InvoiceReference = response.Transaction.PaymentDetails.InvoiceReference
};
var queryResponse = client.QueryTransaction(filter);
var queryResponse2 = client.QueryInvoiceRef(response.Transaction.PaymentDetails.InvoiceReference);
//Assert
Assert.IsNotNull(queryResponse);
Assert.AreEqual(response.TransactionStatus.TransactionID, queryResponse.TransactionStatus.TransactionID);
Assert.IsNotNull(queryResponse2);
Assert.AreEqual(response.TransactionStatus.TransactionID, queryResponse2.TransactionStatus.TransactionID);
TestUtil.AssertReturnedCustomerData_VerifyAddressAreEqual(response.Transaction.Customer,
queryResponse.Transaction.Customer);
TestUtil.AssertReturnedCustomerData_VerifyAddressAreEqual(response.Transaction.Customer,
queryResponse2.Transaction.Customer);
}
public void QueryTransaction_ByTransactionId_Test()
{
var client = CreateRapidApiClient();
//Arrange
var transaction = TestUtil.CreateTransaction();
//Act
var response = client.Create(PaymentMethod.Direct, transaction);
var filter = new TransactionFilter()
{
TransactionID = response.TransactionStatus.TransactionID
};
var queryResponse = client.QueryTransaction(filter);
var queryResponse2 = client.QueryTransaction(response.TransactionStatus.TransactionID);
//Assert
Assert.IsNotNull(queryResponse);
Assert.IsNotNull(queryResponse2);
Assert.AreEqual(response.TransactionStatus.TransactionID, queryResponse.TransactionStatus.TransactionID);
Assert.AreEqual(response.TransactionStatus.TransactionID, queryResponse2.TransactionStatus.TransactionID);
Assert.AreEqual(response.TransactionStatus.Total, queryResponse2.TransactionStatus.Total);
//TestUtil.AssertReturnedCustomerData_VerifyAddressAreEqual(response.Transaction.Customer,
// queryResponse.Transaction.Customer);
//TestUtil.AssertReturnedCustomerData_VerifyAllFieldsAreEqual(response.Transaction.Customer,
// queryResponse.Transaction.Customer);
//TestUtil.AssertReturnedCustomerData_VerifyAddressAreEqual(response.Transaction.Customer,
// queryResponse2.Transaction.Customer);
//TestUtil.AssertReturnedCustomerData_VerifyAllFieldsAreEqual(response.Transaction.Customer,
// queryResponse2.Transaction.Customer);
}
public RecurringBatchTransactionViewModel GetTransactionViewWithPaging(TransactionFilter filter)
{
try
{
var batchReport = batchReportRepository.GetSingle(filter.BatchId);
var transactionViewModel = new RecurringBatchTransactionViewModel
{
AgreementNumber = batchReport.MerchantAgreementNumber,
BatchStatus = batchReport.BatchStatus,
DbaName = batchReport.DbaName,
MerchantAssignedBatchNumber = batchReport.MerchantAssignedBatchNumber,
MerchantName = batchReport.MerchantName,
MerchantNationalId = batchReport.AuxiliaryField02,
ProcessingEndTime = batchReport.ProcessingEndTime,
ProcessingStartTime = batchReport.ProcessingStartTime,
BatchId = filter.BatchId
};
var transactionReports = transactionReportRepository.GetPagedTransactionList(filter);
foreach (var transactionReport in transactionReports.Transactions)
{
var transactionDataViewModel = new RecurringBatchTransactionDataViewModel
{
ReferenceNumber = transactionReport.ReferenceNumber,
TransId = transactionReport.TransId,
AuthorizationCode = transactionReport.AuthCode,
CardNumber = transactionReport.AuxiliaryField05,
Amount = transactionReport.Amount,
TransactionId = transactionReport.Id,
VirtualAccountNumber = transactionReport.ReceivedVirtualAccount,
UpdatedVirtualAccountNumber = transactionReport.UpdatedVirtualAccount
};
if (transactionReport.UpdatedVirtualAccount != guid.Empty)
{
transactionDataViewModel.NewCardNumber =
virtualNumberApiAccess.Get6Plus4CardForVirtualNumber(transactionReport.UpdatedVirtualAccount);
}
transactionViewModel.Transactions.Add(transactionDataViewModel);
}
transactionViewModel.TransactionFilter = filter;
transactionViewModel.Pagination = new PaginationViewModel
{
CurrentPage = transactionReports.CurrentPage,
IsNextPage = transactionReports.IsNextPage,
IsPreviousPage = transactionReports.IsPreviousPage,
TotalCount = transactionReports.TotalCount,
TotalPages = transactionReports.TotalPages,
PaginationFunctionUrl = "RecurringBatchTransaction/GetPage"
};
return(transactionViewModel);
}
catch (Exception exception)
{
//logger.LogError("Unexpected error occurred when filtering and mapping RecurringBatch", exception);
return(null);
}
}
public IEnumerable <GetActiveContractsResponse> GetActiveContractsSync(
TransactionFilter transactionFilter,
bool verbose = true,
string accessToken = null,
TraceContext traceContext = null)
{
return(GetActiveContractsImpl(transactionFilter, verbose, accessToken, traceContext).ToListAsync().Result);
}
public void Test_AddTransactionFilter()
{
using (DdeContext context = new DdeContext())
{
IDdeTransactionFilter filter = new TransactionFilter();
context.AddTransactionFilter(filter);
}
}
public void Test_AddTransactionFilter()
{
using (DdeContext context = new DdeContext())
{
IDdeTransactionFilter filter = new TransactionFilter();
context.AddTransactionFilter(filter);
}
}
public IAsyncEnumerator <GetActiveContractsResponse> GetActiveContracts(
TransactionFilter transactionFilter,
bool verbose = true,
string accessToken = null,
TraceContext traceContext = null)
{
return(GetActiveContractsImpl(transactionFilter, verbose, accessToken, traceContext).ReadAllAsync().GetAsyncEnumerator());
}
public async Task TransactionFilter_ToOrEmpty_When_Address_Is_Different_Returns_False()
{
var tx = new Transaction {
To = Address2
};
var filter = TransactionFilter.ToOrEmpty(Address1);
Assert.False(await filter.IsMatchAsync(tx));
}
public async Task TransactionFilter_FromAndTo_Reports_Matches()
{
var tx = new Transaction {
From = Address1, To = Address2
};
var filter = TransactionFilter.FromAndTo(Address1, Address2);
Assert.True(await filter.IsMatchAsync(tx));
}
public async Task TransactionFilter_FromAndTo_Reports_Non_Matches(string from, string to)
{
var tx1 = new Transaction {
From = from, To = to
};
var filter = TransactionFilter.FromAndTo(Address1, Address2);
Assert.False(await filter.IsMatchAsync(tx1));
}
public async Task TransactionFilter_To_Reports_Matches()
{
var tx = new Transaction {
To = Address1
};
var filter = TransactionFilter.To(Address1);
Assert.True(await filter.IsMatchAsync(tx));
}
public void GetTransactions_FilterByDate_FilteredTransactions()
{
var target = TestHelper.CreateClient();
var filter = new TransactionFilter();
filter.StartDate = DateTime.UtcNow.AddDays(-20);
filter.EndDate = DateTime.UtcNow.AddDays(-10);
var actual = target.GetTransactions(filter);
Assert.AreNotEqual(0, actual.TotalCount);
foreach (var t in actual.Entities)
{
Assert.IsTrue(t.Date >= filter.StartDate.Value);
Assert.IsTrue(t.Date <= filter.EndDate.Value);
}
}
public void GetTransactions_FilterByString_FilteredTransactions()
{
var target = TestHelper.CreateClient();
var filter = new TransactionFilter();
filter.AccountName = TestHelper.AccountName;
var actual = target.GetTransactions(filter);
Assert.AreNotEqual(0, actual.TotalCount);
foreach (var t in actual.Entities)
{
if (t.Type != TransactionType.Transfer)
{
Assert.AreEqual(TestHelper.AccountName, t.AccountName);
}
}
}
public void GetTransactions_Page2_DiffResultPage1()
{
var target = TestHelper.CreateClient();
var filter = new TransactionFilter();
var actual = target.GetTransactions(filter);
var page1FirstTransaction = actual.Entities.First();
filter.Page = 2;
actual = target.GetTransactions(filter);
var page2FirstTransaction = actual.Entities.First();
Assert.AreNotEqual(page1FirstTransaction.Id, page2FirstTransaction.Id);
}
public void Test_RemoveTransactionFilter_After_Dispose()
{
using (DdeContext context = new DdeContext())
{
TransactionFilter filter = new TransactionFilter();
context.AddTransactionFilter(filter);
context.Dispose();
context.RemoveTransactionFilter(filter);
}
}
public void Test_TransactionFilter()
{
using (DdeContext context = new DdeContext())
{
TransactionFilter filter = new TransactionFilter();
context.AddTransactionFilter(filter);
context.Initialize();
using (DdeServer server = new TestServer(ServiceName))
{
server.Register();
}
Assert.IsTrue(filter.Received.WaitOne(Timeout, false));
}
}