public void CorrelationData_ToTransactionData_ShouldReturnSameData()
{
try
{
Correlation = new Correlation(new MemoryCorrelationHandler(), CallContextManagerInstance, MachineInformation);
Correlation.CorrelationStart(null);
CorrelationData data = Correlation.CurrentCorrelation;
TransactionData transaction = data.ToTransactionData();
Assert.True(data.CallDepth == transaction.CallDepth, "Call depth properties should be equal.");
Assert.True(data.EventSequenceNumber == transaction.EventSequenceNumber, "EventSequenceNumber properties should be equal.");
Assert.True(data.TransactionId == transaction.TransactionId, "TransactionId properties should be equal.");
Assert.True(data.UserHash == transaction.UserHash, "UserHash properties should be equal.");
Assert.True(data.VisibleId == transaction.CorrelationId, "VisibleId and CorrelationId properties should be equal.");
}
finally
{
EndRequest();
}
}
void CorrectOnOneTransactionTypeExists()
{
if (CurrentPriceIndex == -1 && transactions.Count != 0)
{
int lastIndex = transactions.Count - 1;
string transantionType = transactions[0].Bid == 0 ? "Bid" : "Ask";
int volume = transactions[lastIndex].Volume + 5;
double price;
if (comparer.GetType() == typeof(PriceAscedingComparer))
{
price = IsDownMoving(transantionType) ? transactions[lastIndex].Price + 0.5 : transactions[0].Price - 0.5;
}
else
{
price = IsDownMoving(transantionType) ? transactions[lastIndex].Price - 0.5 : transactions[0].Price + 0.5;
}
TransactionData tdvm = new TransactionData(transantionType, volume, price);
transactions.Add(tdvm);
CurrentPriceIndex = transactions.IndexOf(tdvm);
}
}
public bool addTransaction(TransactionData transaction)
{
MySQLSuperManager dbm = GetLockedConnection();
try {
return(dbm.Manager.addTransaction(transaction));
}
#pragma warning disable CS0168 // Variable ist deklariert, wird jedoch niemals verwendet
catch (MySql.Data.MySqlClient.MySqlException e) {
#pragma warning restore CS0168 // Variable ist deklariert, wird jedoch niemals verwendet
dbm.Manager.Reconnect();
return(dbm.Manager.addTransaction(transaction));
}
catch (Exception e) {
m_log.Error(e.ToString());
return(false);
}
finally {
dbm.Release();
}
}
public static int LoadTransactionData(string filepath, char separator = ',', bool hasHeader = true)
{
using StreamReader reader = new StreamReader(filepath);
if (hasHeader)
{
reader.ReadLine();
}
int count = 0;
List <TransactionData> data = new List <TransactionData>();
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
data.Add(TransactionData.Parse(line, separator));
++count;
}
Transactions = data;
return(count);
}
public void GetCurrentData(GameData data)
{
PlasticData plasticData = new PlasticData();
data.PlasticData = _plastic.GetData(plasticData);
TransactionData transactionData = new TransactionData();
data.TransactionData = _transaction.GetData(transactionData);
List <PickerData> pickerDatas = new List <PickerData>();
for (int i = 0; i < _pickerList.Count; i++)
{
PickerData pickerData = new PickerData();
pickerDatas.Add(_pickerList[i].GetData(pickerData));
data.PickerDataList.Add(pickerDatas[i]);
}
}
public IHttpActionResult SaveTransaction(TransactionData transactionData)
{
var ua = UserAccess.GetUserAccess(User.Identity.Name);
if (ua.current_access == UserAccess.access_type.no_access)
{
return(Unauthorized());
}
transactionData.created_by_ip_address = ((HttpContextWrapper)Request.Properties["MS_HttpContext"]).Request.UserHostAddress;
transactionData.SetUserProperties(ua);
if (!transactionData.ValidateTransaction(ua)) // add check for C transactionin this validation function
{
if (!transactionData.can_accept_deposit && transactionData.transaction_type == "D")
{
return(Unauthorized());
}
if (transactionData.error_text.Length == 0)
{
transactionData.error_text = "There was an issue with some of the data";
}
return(Ok(transactionData));
}
// TODO: new receipt needs to be a TransactionView
var td = transactionData.SaveTransactionData();
if (transactionData.transaction_id == -1)
{
new ErrorLog("Error saving the transaction", "transactionData.ErrorText: " + transactionData.error_text, "TransactionDataController.SaveTransaction() >> transactionData.SaveTransactionData()", "", "");
}
if (td)
{
return(Ok(TransactionData.GetTransactionData("TransactionDataController.Save()", transactionData.transaction_id, ua.employee_id, ua)));
}
else
{
return(Ok(transactionData));
}
}
public IHttpActionResult EditPaymentMethod(PaymentMethodData payment_method_data)
{
if (payment_method_data.payment_method_data_id == -1)
{
return(BadRequest());
}
var ua = UserAccess.GetUserAccess(User.Identity.Name);
if (!TransactionData.ValidateEdit(payment_method_data.transaction_id, ua))
{
return(Unauthorized());
}
//var user_ip_address = ((HttpContextWrapper)Request.Properties["MS_HttpContext"]).Request.UserHostAddress;
payment_method_data.SetUserName(ua.user_name);
if (ua.current_access == UserAccess.access_type.no_access)
{
return(Unauthorized());
}
if (!payment_method_data.ValidateChange())
{
if (payment_method_data.error_text.Length == 0)
{
return(Ok("There was an issue with validating the payment method."));
}
}
else
{
payment_method_data.added_after_save = false;
if (!payment_method_data.SavePaymentMethod())
{
if (payment_method_data.error_text.Length == 0)
{
return(Ok("There was an issue editing the payment method."));
}
}
}
return(Ok());
}
public void Given_AWatchedAddress_When_ATransactionIsReceived_ThenTransactionDataIsAddedToTheAddress()
{
// Arrange.
DataFolder dataFolder = CreateDataFolder(this);
// Create the wallet to watch.
WatchOnlyWallet wallet = this.CreateAndPersistAWatchOnlyWallet(dataFolder);
// Create the address to watch.
Script newScript = BitcoinAddress.Create("mnSmvy2q4dFNKQF18EBsrZrS7WEy6CieEE", Network.TestNet).ScriptPubKey;
string newAddress = newScript.GetDestinationAddress(Network.TestNet).ToString();
// Create a transaction to be received.
string transactionHex = "010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff230384041200fe0eb3a959fe1af507000963676d696e6572343208000000000000000000ffffffff02155e8b09000000001976a9144bfe90c8e6c6352c034b3f57d50a9a6e77a62a0788ac0000000000000000266a24aa21a9ed0bc6e4bfe82e04a1c52e66b72b199c5124794dd8c3c368f6ab95a0ba6cde277d0120000000000000000000000000000000000000000000000000000000000000000000000000";
Transaction transaction = Transaction.Load(transactionHex, Network.TestNet);
// Act.
var walletManager = new WatchOnlyWalletManager(DateTimeProvider.Default, this.LoggerFactory.Object, Network.TestNet, dataFolder);
walletManager.Initialize();
walletManager.WatchAddress("mnSmvy2q4dFNKQF18EBsrZrS7WEy6CieEE");
walletManager.ProcessTransaction(transaction);
// Assert.
WatchOnlyWallet returnedWallet = walletManager.GetWatchOnlyWallet();
Assert.NotNull(returnedWallet);
WatchedAddress addressInWallet = returnedWallet.WatchedAddresses[newScript.ToString()];
Assert.NotNull(addressInWallet);
Assert.False(addressInWallet.Transactions.IsEmpty);
Assert.Single(addressInWallet.Transactions);
TransactionData transactionExpected = addressInWallet.Transactions.Single().Value;
Assert.Equal(transactionHex, transactionExpected.Hex);
Assert.Null(transactionExpected.BlockHash);
Assert.Null(transactionExpected.MerkleProof);
}
public bool ValidateTransactionData(TransactionData transactionData)
{
if (transactionData.department_control_data.Count() == 0 && controls_dict.Count() == 0)
{
return(true);
}
// We treat the Data.TransactionData class as a department class because it has all of the
// departmental data we'll need to validate
// first we'll see if this department is active or not. If it's not, we shouldn't be allowing
// data to be saved
if (controls_dict.Count() == 0 && transactionData.department_control_data.Count() > 0)
{
transactionData.error_text = "There was an issue validating the department information";
new ErrorLog(
"Error: Control dictionary is not being populated.",
"Cannot validate department controls",
"controls_dict.Count(): " + controls_dict.Count().ToString(),
"Transaction.Department.ValidateTransactionData()",
"");
}
if (!GetCachedDict()[transactionData.department_id].is_active)
{
transactionData.error_text = "Department is no longer active.";
return(false);
}
// let's make sure the department controls are valid
if (!ValidateDepartmentControls(transactionData))
{
transactionData.error_text = "There was an issue validating some of the data";
return(false);
}
return(true);
// if (!ValidatePaymentTypes(transactionData)) return transactionData;
}
protected void HandleTransactionData(TransactionData data)
{
SaveContractDetailsIfNeeded <OptionContract>(data.GetContract());
//_session.Evict(data);
using (ITransaction transaction = _session.BeginTransaction())
{
var nmsg = $"Write Transaction {data.OptionKey}";
int tdId = 0;
try
{
if (_session.Get <TransactionData>(data.Id) == null)
{
Logger.InfoFormat($"!@#$%^&* - Try to save new transaction:(Id={tdId}) '{data.OptionKey}'.");
tdId = (int)_session.Save(data);
}
else
{
tdId = data.Id;
Logger.InfoFormat($"!@#$%^&* - Try to Merge to existing transaction:(Id={tdId}) ==>'{data.OptionKey}'.");
_session.Merge(data);
}
}
catch (Exception ex)
{
Logger.Error($"!@#$%^&* - Trying save transaction:(Id={data.Id}) ==> '{data.OptionKey}'. was failed: {ex.Message}.", ex);
}
try
{
transaction.Commit();
_transactionDataCommited = transaction.WasCommitted;
//var obj = _session.Load<TransactionData>(tdId);
//_session.Evict(obj);
}
catch (Exception exception)
{
Logger.Error("!@#$%^&* - Could not write to DB (Id={tdId})", exception);
}
}
}
internal static List <TransactionData> GetTransactionData()
{
using (var context = new AirportInventoryEntities())
{
var transactionList = context.Transactions.
Where(h => 1 == 1).ToList();
List <TransactionData> allTransaction = new List <TransactionData>();
string transactionType = "";
if (transactionList != null)
{
foreach (var transaction in transactionList)
{
if (transaction.Transaction_Type)
{
transactionType = "IN";
}
else
{
transactionType = "OUT";
}
TransactionData transactionData = new TransactionData()
{
transaction_id = transaction.Transaction_Id,
transaction_date_time = transaction.Transaction_DateTime.ToString(),
aircraft_id = transaction.Aircraft_Id,
airport_id = transaction.Airport_Id,
transaction_type = transactionType,
quantity = transaction.Quantity,
transaction_parent_id = transaction.Transaction_Parent_Id
};
allTransaction.Add(transactionData);
}
return(allTransaction);
}
else
{
return(null);
}
}
}
public void LoadTransactionListFromFile()
{
transactionGameObjectDict = new Dictionary <string, TransactionSummaryGameObjectList>();
TransactionData transactionData = new TransactionData();
string[] splitMainePanelName = selectedMainPanelKey.Split('_');
if (isOwnerSelected)
{
transactionSummaryDataList = transactionData.GetTransactionsSortedByOwner();
headerPanelDate.GetComponent <Text>().text = "Transaction Date: " + splitMainePanelName[1] + " " + splitMainePanelName[2] + " " + splitMainePanelName[3];
headerPanelOwner.GetComponent <Text>().text = "Owner: " + splitMainePanelName[0];
}
else
{
transactionSummaryDataList = transactionData.GetTransactionsSortedByDate();
headerPanelDate.GetComponent <Text>().text = "Transaction Date: " + splitMainePanelName[0] + " " + splitMainePanelName[1] + " " + splitMainePanelName[2];
headerPanelOwner.GetComponent <Text>().text = "Owner: " + splitMainePanelName[3];
}
displayTransactionDetails(false, "");
}
static async Task MakeTransaction(TransactionData transactionData)
{
var transactionType = transactionData.Deposits > decimal.Zero ? TransactionType.Deposit : TransactionType.Withdrawal;
var transactionAmount = transactionData.Deposits > decimal.Zero ? transactionData.Deposits : transactionData.Withdrawals;
var transactionInput = new TransactionInput()
{
Date = transactionData.Date,
TransactionType = transactionType,
Amount = Convert.ToDecimal(transactionAmount),
Description = transactionData.TransactionDetails
};
var transactionResult = new TransactionResult();
if (transactionType == TransactionType.Deposit)
{
transactionResult = await DepositAsync(transactionInput);
}
else if (transactionType == TransactionType.Withdrawal)
{
transactionResult = await WithdrawAsync(transactionInput);
}
if (transactionResult.IsSuccessful)
{
Console.WriteLine($"Status: {transactionResult.Message}");
Console.WriteLine($"Account No: {transactionResult.AccountNumber}");
Console.WriteLine($"Current Balance: {transactionResult.Balance}");
Console.WriteLine($"Currency: {transactionResult.Currency}");
}
else
{
Console.WriteLine($"Status: Transaction failed");
Console.WriteLine($"Message: {transactionResult.Message}");
}
Console.WriteLine();
}
public void TestPurgeTransactionRecord()
{
RecoveryFileLogger logger = new RecoveryFileLogger();
logger.Location = nonDefaultLogLocation;
logger.Initialize(this.resourceManagerId.ToString());
TransactionData transactionData01 = new TransactionData();
logger.LogRecoveryInfo(transactionData01.Transaction, transactionData01.RecoveryData);
TransactionData transactionData02 = new TransactionData();
logger.LogRecoveryInfo(transactionData02.Transaction, transactionData02.RecoveryData);
Assert.IsTrue(File.Exists(this.GetFilename(logger, transactionData01)), "Recovery File was not created");
Assert.IsTrue(File.Exists(this.GetFilename(logger, transactionData02)), "Recovery File was not created");
logger.Purge();
this.AssertFileIsDeleted(this.GetFilename(logger, transactionData01), 1000);
this.AssertFileIsDeleted(this.GetFilename(logger, transactionData02), 1000);
}
bool UpdateNonStackable(TransactionData ns)
{
if (ns.amount_diff > 0)
{
context.tb_nonstackable_items.Add(new NonStackable
{
owner_id = owner_id,
type = ns.item_type
});
}
else
{
context.tb_nonstackable_items.Remove(new NonStackable
{
owner_id = owner_id,
type = ns.item_type,
dbid = ns.dbid
});
}
return(true);
}
private void SaveTransaction()
{
if (TransactionAlreadySaved)
{
return;
}
//Create Transuction Data object and send it:
var transaction = new TransactionData()
{
TransactionTime = DateTime.Now,
OrderStatus = OrderStatusData,
Order = OrderStatusData.Order,
OptionData = OptionData,
OptionKey = OptionData.OptionKey,
Symbol = UnlManager.Symbol,
RequieredMargin = RequieredMargin,
};
//Update about the new transaction
UnlManager.Distributer.Enqueue(transaction);
TransactionAlreadySaved = true;
}
public async Task MoveCarouse__TransactionQueue_DeviceResponse_Positive()
{
//Assume
IDeviceResponse expected = new DeviceResponse()
{
HasError = false
};
CarouselFactory carouselFactory = new CarouselFactory();
Utility utility = new Utility();
CarouselManager objCarouselManager = new CarouselManager(_configuration, _logger.Object, carouselFactory, _socket.Object, _deviceResponse.Object);
TransactionData data = CreateTransactionQueueData();
await objCarouselManager.CreateCarousel(data);
Slot slot = await utility.BuildStorageSpaceItem(data.Devices.FirstOrDefault(dev => dev.Type.Equals("Carousel"))?.StorageSpaces);
//Act
IDeviceResponse actual = await objCarouselManager.MoveCarousel(data, slot);
//Assert
Assert.Equal(expected.HasError, actual.HasError);
}
/// <summary>
/// Determines whether or not the input's address exists in the wallet's set of addresses.
/// </summary>
/// <param name="addresses">The wallet's external and internal addresses.</param>
/// <param name="txDictionary">The set of transactions to check against.</param>
/// <param name="txIn">The input to check.</param>
/// <returns><c>true</c>if the input's address exist in the wallet.</returns>
bool IsTxInMine(IEnumerable <HdAddress> addresses, Dictionary <uint256, TransactionData> txDictionary, TxIn txIn)
{
TransactionData previousTransaction = null;
txDictionary.TryGetValue(txIn.PrevOut.Hash, out previousTransaction);
if (previousTransaction == null)
{
return(false);
}
var previousTx = this.blockStore.GetTransactionById(previousTransaction.Id);
if (txIn.PrevOut.N >= previousTx.Outputs.Count)
{
return(false);
}
// We now need to check if the scriptPubkey is in our wallet.
// See https://github.com/bitcoin/bitcoin/blob/011c39c2969420d7ca8b40fbf6f3364fe72da2d0/src/script/ismine.cpp
return(IsAddressMine(addresses, previousTx.Outputs[txIn.PrevOut.N].ScriptPubKey));
}
/// <summary>
/// Returns spreading with custom date range
/// </summary>
/// <param name="startDate">minimum date</param>
/// <param name="endDate">max date</param>
/// <returns>List with statistic items.</returns>
public static ObservableCollection <StatisticItem> GetSpreading(DateTime startDate, DateTime endDate)
{
if (AllTransaction == null)
{
TransactionData.LoadList();
}
if (AllCategories == null)
{
CateogryData.LoadList();
}
var transactionListFunc =
new Func <List <FinancialTransaction> >(() =>
AllTransaction
.Where(x => x.Category != null)
.Where(x => x.Date >= startDate.Date && x.Date <= endDate.Date)
.Where(x => x.Type == (int)TransactionType.Spending)
.ToList());
return(GetSpreadingStatisticItems(transactionListFunc));
}
public void IsMothlyFeeAdded()
{
decimal fee1 = 0m;
decimal fee2 = 0m;
FeeCalculator SUT = new FeeCalculator();
ITransactionData transaction = new TransactionData()
{
Date = new DateTime(2020, 5, 25),
MerchantName = "TELIA",
Fee = 1.2m
};
fee1 = SUT.AddMonthlyFee(transaction);
transaction.Date = transaction.Date.AddMonths(1);
transaction.Fee = 1.2m;
fee2 = SUT.AddMonthlyFee(transaction);
Assert.AreEqual(fee1, fee2);
// Test if monthly fee is added if the basic fee was 0 and now 1.2.
SUT = new FeeCalculator();
transaction = new TransactionData()
{
Date = new DateTime(2020, 5, 25),
MerchantName = "TELIA",
Fee = 0
};
fee1 = SUT.AddMonthlyFee(transaction);
Assert.AreEqual(0m, fee1);
transaction.Fee = 1.2m;
transaction.Date = new DateTime(2020, 5, 26);
fee2 = SUT.AddMonthlyFee(transaction);
Assert.AreEqual(30.2m, (fee2 - fee1));
}
public async Task <TResult> ExecuteTransactionAsync <TResult>(TransactionData data, Action <BaseResult> baseResult = null)
{
var command = new HttpCommand(this)
{
Api = CommandApi.Transaction,
Method = HttpMethod.Post
};
if (data.Action != null)
{
data.Action = data.Action.Replace("\r\n", " ");
}
var result = await command.RequestGenericSingleResult <TResult, InheritedCommandResult <TResult> >(data).ConfigureAwait(false);
if (baseResult != null)
{
baseResult(result.BaseResult);
}
return(result.Result);
}
private Transaction Map(DbDataReader reader)
{
TransactionData data = new TransactionData()
{
Id = reader.GetGuid(0),
Revision = reader.GetInt32(1),
Created = reader.GetDateTime(2),
Expires = reader.IsDBNull(3) ? default(DateTime?) : reader.GetFieldValue <DateTime>(3),
Expired = reader.IsDBNull(4) ? default(DateTime?) : reader.GetFieldValue <DateTime>(4),
Payload = reader.IsDBNull(5) ? null : JsonConvert.DeserializeObject <ExpandoObject>(reader.GetString(5)),
Script = reader.IsDBNull(6) ? null : reader.GetString(6)
};
Guid?pid = reader.IsDBNull(7) ? default(Guid?) : reader.GetFieldValue <Guid>(7);
if (pid != null)
{
data.Parent = new TransactionRevision(pid.Value, reader.GetInt32(8));
}
data.Status = (TransactionStatus)reader.GetInt32(9);
data.Error = reader.IsDBNull(10) ? null : JsonConvert.DeserializeObject <ExpandoObject>(reader.GetString(10));
return(new Transaction(data, this));
}
public void Undo()
{
SwitchOffOtherFunctionality();
if (UndoStack.state == TransactionData.States.spawned)
{
//delete
print("delete-Undo");
UndoStack._object.SetActive(false);
redoStack = UndoStack;
redoStack.state = TransactionData.States.deleted;
}
else if (UndoStack.state == TransactionData.States.deleted)
{
//Spawn
print("Spwan-Undo");
UndoStack._object.SetActive(true);
redoStack = UndoStack;
redoStack.state = TransactionData.States.spawned;
}
undoBtn.SetActive(false);
redoBtn.SetActive(true);
}
public Error(CapturedException capturedException, Transaction transaction, string parentId, IApmLogger loggerArg)
{
Timestamp = TimeUtils.TimestampNow();
Id = RandomGenerator.GenerateRandomBytesAsString(new byte[16]);
Exception = capturedException;
TraceId = transaction.TraceId;
TransactionId = transaction.Id;
ParentId = parentId;
Transaction = new TransactionData(transaction.IsSampled, transaction.Type);
if (transaction.IsSampled)
{
Context = transaction.Context;
}
IApmLogger logger = loggerArg?.Scoped($"{nameof(Error)}.{Id}");
logger.Trace()
?.Log("New Error instance created: {Error}. Time: {Time} (as timestamp: {Timestamp})",
this, TimeUtils.FormatTimestampForLog(Timestamp), Timestamp);
}
public void UpdateDocumentStatus(updateStatusRequest updateStatusRequest)
{
for (int i = 0; i < updateStatusRequest.transactionDataID.Count(); i++)
{
TransactionData transactionData =
repository.Single <TransactionData>(o => o.TransGUID == updateStatusRequest.transactionDataID[i].TransGUID &&
o.DocumentNumber == updateStatusRequest.transactionDataID[i].DocumentNumber &&
o.Key1 == updateStatusRequest.transactionDataID[i].Key1 &&
o.Key2 == updateStatusRequest.transactionDataID[i].Key2 &&
o.Key3 == updateStatusRequest.transactionDataID[i].Key3);
if (transactionData != null)
{
transactionData.RowStatus = updateStatusRequest.transactionDataID[i].TransStatus;
EntityHelper.SetAuditForUpdate(transactionData, "SERA");
repository.Update(transactionData);
repository.UnitOfWork.SaveChanges();
}
else if (transactionData == null)
{
break;
}
}
}
public IHttpActionResult GetAllTransactionData(
int page_number = -1
, string display_name_filter = ""
, string completed_filter = ""
, int department_id_filter = -1
, string transaction_type_filter = ""
, string transaction_number_filter = ""
, bool has_been_modified = false
//,long transaction_id_filter = -1
)
{
var ua = UserAccess.GetUserAccess(User.Identity.Name);
if (ua.current_access == UserAccess.access_type.no_access)
{
return(Unauthorized());
}
var tr = TransactionData.GetTransactionList
(ua
, page_number
, display_name_filter
, completed_filter
, transaction_type_filter
, transaction_number_filter
, department_id_filter
, has_been_modified // only true matters
// ,transaction_id_filter
);
if (tr == null)
{
return(InternalServerError());
}
return(Ok(tr));
}
public async Task GetCategoryStatisticByDateRangeTest()
{
var category1 = CategoryData.CreateCategory(Guid.NewGuid(), "Products", "Orange", Enums.CategoryType.Expenditure);
var category2 = CategoryData.CreateCategory(Guid.NewGuid(), "Products", "Cheese", Enums.CategoryType.Expenditure);
var startDate = new DateTime(2018, 1, 1);
var endDate = new DateTime(2018, 1, 2);
var transaction0 = TransactionData.CreateTransaction(Guid.NewGuid(), startDate, 200, category1);
var transaction1 = TransactionData.CreateTransaction(Guid.NewGuid(), endDate, 100, category2);
var transaction2 = TransactionData.CreateTransaction(Guid.NewGuid(), new DateTime(2017, 1, 1));
var transaction3 = TransactionData.CreateTransaction(Guid.NewGuid(), new DateTime(2019, 1, 1));
await _transactionRepository.CreateAsync(transaction0);
await _transactionRepository.CreateAsync(transaction1);
await _transactionRepository.CreateAsync(transaction2);
await _transactionRepository.CreateAsync(transaction3);
var query = new CategoryStatisticQuery(
new DateRangeQuery(new DateQuery(startDate), new DateQuery(endDate)),
Enums.CategoryType.Expenditure);
var statistic = await _statisticService.GetCategoryStatisticAsync(query);
var expected = new CategoryStatistic(new[]
{
new CategoryStatisticItem(category1, 200),
new CategoryStatisticItem(category2, 100)
},
300);
var actual = statistic;
Assert.That(expected, Is.EqualTo(actual));
}
public async Task FindByDateTest()
{
var date = new DateTime(2018, 1, 1);
var dateQuery = new DateQuery(date);
var category = CategoryData.CreateCategory(Guid.NewGuid());
var transaction1 = TransactionData.CreateTransaction(Guid.NewGuid(), date, category: category);
var transaction2 = TransactionData.CreateTransaction(Guid.NewGuid(), date.AddDays(1), category: category);
var transaction3 = TransactionData.CreateTransaction(Guid.NewGuid(), date.AddDays(2), category: category);
var transaction4 = TransactionData.CreateTransaction(Guid.NewGuid(), date.AddDays(3), category: category);
await CommitCreateAsync(category);
await CommitCreateAsync(transaction1);
await CommitCreateAsync(transaction2);
await CommitCreateAsync(transaction3);
await CommitCreateAsync(transaction4);
var foundTransactions = await TransactionRepository.FindAsync(
new TransactionQuery(new DateRangeQuery(dateQuery, dateQuery)));
Assert.That(foundTransactions, Is.EquivalentTo(new[] { transaction1 }));
}
public async Task FindByDateRange_WhenOutOfRange_Test()
{
var startDate = new DateTime(2018, 1, 1);
var endDate = new DateTime(2017, 1, 4);
var category = CategoryData.CreateCategory(Guid.NewGuid());
var transaction1 = TransactionData.CreateTransaction(Guid.NewGuid(), startDate, category: category);
var transaction2 = TransactionData.CreateTransaction(Guid.NewGuid(), startDate.AddDays(1), category: category);
var transaction3 = TransactionData.CreateTransaction(Guid.NewGuid(), startDate.AddDays(2), category: category);
var transaction4 = TransactionData.CreateTransaction(Guid.NewGuid(), startDate.AddDays(3), category: category);
await CommitCreateAsync(category);
await CommitCreateAsync(transaction1);
await CommitCreateAsync(transaction2);
await CommitCreateAsync(transaction3);
await CommitCreateAsync(transaction4);
var dateRangeQuery = new DateRangeQuery(new DateQuery(startDate), new DateQuery(endDate));
var foundTransactions = await TransactionRepository.FindAsync(new TransactionQuery(dateRangeQuery));
Assert.That(foundTransactions, Is.Empty);
}
private static void VerifyTransaction(CreateTransactionRequest request)
{
TransactionData transaction = new TransactionData
{
From = request.From,
To = request.To,
Value = request.Value,
Fee = request.Fee,
DateCreated = request.DateCreated,
Data = request.Data,
SenderPubKey = request.SenderPubKey
};
string transactionJson = JsonUtils.Serialize(transaction, false);
byte[] transactionDataHash = HashUtils.ComputeSha256(transactionJson.GetBytes());
BigInteger r = new BigInteger(request.SenderSignature[0], 16);
BigInteger s = new BigInteger(request.SenderSignature[1], 16);
ECPoint publicKey = EncryptionUtils.DecompressKey(request.SenderPubKey);
bool valid = EncryptionUtils.VerifySignature(publicKey, r, s, transactionDataHash);
Console.WriteLine("Signature valid: " + valid);
}
public void AddTransaction(TransactionData transaction)
{
if (transaction == null)
{
throw new ArgumentNullException("transaction");
}
this.transactionAdditions.Add(new OrderedGuid
{
Guid = transaction.TransactionId,
Order = this.orderIndex++,
});
}
public void Serialize(TransactionData tran)
{
Serialize(Magic.TypeTransactionData);
if (tran.Creates != null) {
Serialize(tran.Creates.Count);
for (int index = 0; index < tran.Creates.Count; index++)
Serialize(tran.Creates[index]);
} else {
Serialize(0);
}
if (tran.Updates != null) {
Serialize(tran.Updates.Count);
for (int index = 0; index < tran.Updates.Count; index++)
Serialize(tran.Updates[index]);
} else {
Serialize(0);
}
if (tran.Deletes != null) {
Serialize(tran.Deletes.Count);
for (int index = 0; index < tran.Deletes.Count; index++)
Serialize(tran.Deletes[index]);
} else {
Serialize(0);
}
}
static public StringBuilder Serialize(StringBuilder sb, TransactionData tran)
{
sb.Append(TypeTransactionData);
for (int index = 0; index < tran.creates.Count; index++)
Serialize(sb, tran.creates[index]);
for (int index = 0; index < tran.updates.Count; index++)
Serialize(sb, tran.updates[index]);
for (int index = 0; index < tran.deletes.Count; index++)
Serialize(sb, tran.deletes[index]);
sb.Append(' ');
return sb;
}
/// <remarks/>
public void StopTransactionAsync(int transactionId, string idTag, System.DateTime timestamp, int meterStop, TransactionData[] transactionData)
{
this.StopTransactionAsync(transactionId, idTag, timestamp, meterStop, transactionData, null);
}
/// <remarks/>
public System.IAsyncResult BeginStopTransaction(int transactionId, string idTag, System.DateTime timestamp, int meterStop, TransactionData[] transactionData, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("StopTransaction", new object[] {
transactionId,
idTag,
timestamp,
meterStop,
transactionData}, callback, asyncState);
}
/// <remarks/>
public void StopTransactionAsync(int transactionId, string idTag, System.DateTime timestamp, int meterStop, TransactionData[] transactionData, object userState)
{
if ((this.StopTransactionOperationCompleted == null)) {
this.StopTransactionOperationCompleted = new System.Threading.SendOrPostCallback(this.OnStopTransactionOperationCompleted);
}
this.InvokeAsync("StopTransaction", new object[] {
transactionId,
idTag,
timestamp,
meterStop,
transactionData}, this.StopTransactionOperationCompleted, userState);
}
public void AddTransaction(TransactionData transaction)
{
}
static public bool IsTransactionDataEmpty(TransactionData td) {
return (td.Updates == null || td.Updates.Count == 0)
&& (td.Creates == null || td.Creates.Count == 0)
&& (td.Deletes == null || td.Deletes.Count == 0)
;
}
