public void SerializeXML_OK() { //Arrange CommissionAccount acc = new CommissionAccount("myCommissionXML_SerializeTest", 10.234m, Currency.CHF); //Act CommissionAccountSerializer.SerializeXML(acc); //Assert Assert.True(File.Exists("myCommissionXML_SerializeTest.xml")); }
public void SerializeBinaryOK() { //Arrange CommissionAccount acc = new CommissionAccount("myCommission", 10.234m, Currency.CHF); //Act CommissionAccountSerializer.SerializeBinary(acc); //Assert Assert.True(File.Exists("myCommission.txt")); }
public void AccountUnsubscribeFromCommissionFail() { //Arrange CommissionAccount acc = new CommissionAccount("123", 10, Currency.AUD); //Assert AccountManager nothing = null; var ex = Assert.Throws <ArgumentNullException>(() => acc.UnsubscribeFromCommission(nothing)); Assert.AreEqual($"{ExceptionMessages.AccountUnsubscribeNullParam() + Environment.NewLine}Parameter name: accountManager", ex.Message); }
protected double GetCoeffMethod(CommissionMethod method, CommissionAccount account) { switch (method) { case CommissionMethod.QUANTITY_PERCENT: return(0.01); case CommissionMethod.TERM_TICKS: return(Security.TickSize); } return(1); }
public void DeserializeXML_OK() { //Arrange CommissionAccount baseAcc = new CommissionAccount("myCommissionXML_DeserializeTest", 10.234m, Currency.CHF); //Act CommissionAccountSerializer.SerializeXML(baseAcc); CommissionAccount newAcc = CommissionAccountSerializer.DeserializeXML("myCommissionXML_DeserializeTest.xml"); //Assert Assert.AreEqual(baseAcc.AccountID, newAcc.AccountID); Assert.AreEqual(baseAcc.Money.Amount, newAcc.Money.Amount); Assert.AreEqual(baseAcc.Money.Curr, newAcc.Money.Curr); }
public void DeserializeBinaryOK() { //Arrange CommissionAccount baseAcc = new CommissionAccount("myCommissionBin_test", 10.234m, Currency.CHF); //Act CommissionAccountSerializer.SerializeBinary(baseAcc); CommissionAccount newAcc = CommissionAccountSerializer.DeserializeBinary("myCommissionBin_test.txt"); //Assert Assert.AreEqual(baseAcc.AccountID, newAcc.AccountID); Assert.AreEqual(baseAcc.Money.Amount, newAcc.Money.Amount); Assert.AreEqual(baseAcc.Money.Curr, newAcc.Money.Curr); }
protected void CheckCommissions(bool isPassive) { if (Order.Side == Side.BUY) { CommissionAccount account = (CommissionAccount)TestContent.TradeSettings.Settings.BuyerCommissionAccount; CommissionMethod method = (CommissionMethod)TestContent.TradeSettings.Settings.BuyerCommissionMethod; double pv = !isPassive ? (double)TestContent.TradeSettings.Settings.BuyerTakerCommissionProgressive : (double)TestContent.TradeSettings.Settings.BuyerMakerCommissionProgressive; List <TransactionDto> currencyForCommission = account == CommissionAccount.SOURCE_ACCOUNT ? TestContent.TermTransactions : TestContent.BaseTransactions; double commissions = currencyForCommission.FindAll(t => t.Type == Type.trading_commission).Sum(t => t.Amount); if (method == CommissionMethod.TERM_TICKS) { currencyForCommission = account == CommissionAccount.SOURCE_ACCOUNT ? TestContent.BaseTransactions : TestContent.TermTransactions; } CalcCommissions(currencyForCommission, method, account, pv, commissions); } if (Order.Side == Side.SELL) { CommissionAccount account = (CommissionAccount)TestContent.TradeSettings.Settings.SellerCommissionAccount; CommissionMethod method = (CommissionMethod)TestContent.TradeSettings.Settings.SellerCommissionMethod; double pv = !isPassive ? (double)TestContent.TradeSettings.Settings.SellerTakerCommissionProgressive : (double)TestContent.TradeSettings.Settings.SellerMakerCommissionProgressive; List <TransactionDto> currencyForCommission = account == CommissionAccount.SOURCE_ACCOUNT ? TestContent.BaseTransactions : TestContent.TermTransactions; double commissions = currencyForCommission.FindAll(t => t.Type == Type.trading_commission).Sum(t => t.Amount); if (method == CommissionMethod.TERM_TICKS) { currencyForCommission = account == CommissionAccount.SOURCE_ACCOUNT ? TestContent.TermTransactions : TestContent.BaseTransactions; } CalcCommissions(currencyForCommission, method, account, pv, commissions); } }
public void AccountContextOK() { IAccountManager manager = new AccountManager10percent(); AccountContext context = new AccountContext(manager); Account accFrom = new Account("from", 200m, Currency.USD); Account accTo = new Account("to", 50m, Currency.USD); CommissionAccount accCommission = new CommissionAccount("commission", 0m, Currency.USD); accCommission.SubscribeToCommission(context.Manager); context.Transaction(accFrom, accTo, 100m, Currency.USD); Assert.AreEqual(90m, accFrom.Money.Amount); Assert.AreEqual(150m, accTo.Money.Amount); Assert.AreEqual(10m, accCommission.Money.Amount); }
public void AccountCheckComission() { //Arrange AccountManager accountManager = new AccountManager(0.01m, Currency.CHF); Account accFrom = new Account("from", 547.345m, Currency.USD); Account accTo = new Account("to", 56.234m, Currency.EUR); CommissionAccount commissionAccount = new CommissionAccount("our money", Currency.CHF); commissionAccount.SubscribeToCommission(accountManager); //Act accountManager.Transaction(accFrom, accTo, 78.12m); //Assert Assert.AreEqual(0.771934968m, commissionAccount.Money.Amount); }
public void AccountManagerConversionOK() { //Arrange AccountManager accM = new AccountManager(0.01m, Currency.USD); Account acc1 = new Account("1", 10, Currency.USD); Account acc2 = new Account("2", 20, Currency.GBP); Account acc3 = new Account("3", 5000, Currency.JPY); CommissionAccount commissionAccount = new CommissionAccount("ourMoney", Currency.USD); commissionAccount.SubscribeToCommission(accM); //Act accM.Conversion(acc1, Currency.EUR); accM.Conversion(acc2, Currency.AUD); accM.Conversion(acc3, Currency.USD); //Assert Assert.AreEqual(0.808618m, commissionAccount.Money.Amount); }
public async Task <TransactionCheckResult> TransactionAsync(string accFromName, string userFromName, string accToName, string userToName, decimal amount) { TransactionCheckResult result = new TransactionCheckResult(); if (accFromName == accToName && userFromName == userToName) { result.IsSameAccs = true; return(result); } AccountEntity accEntityFrom = await GetAccountEntityAsync(accFromName, userFromName); AccountEntity accEntityTo = await GetAccountEntityAsync(accToName, userToName); Account accFrom = new Account(accEntityFrom, AccountCreationOptions.EmptyName); Account accTo = new Account(accEntityTo, AccountCreationOptions.EmptyName); decimal coefficient = await _globalRates.GetRateAsync(accFrom.Money.Curr, accTo.Money.Curr); accFrom.Money.AdjustExchangeRate(accFrom.Money.Curr, accTo.Money.Curr, coefficient); accTo.Money.AdjustExchangeRate(accFrom.Money.Curr, accTo.Money.Curr, coefficient); AccountManager accManager = await GetAccountManagerAsync(accEntityFrom, userFromName); AccountEntity commissionAccEntity = await GetCommissionAccount(); CommissionAccount commissionAcc = new CommissionAccount(commissionAccEntity, AccountCreationOptions.CurrencyOnly); commissionAcc.SubscribeToCommission(accManager); try { accManager.Transaction(accFrom, accTo, amount); } catch (Exception ex) { if (ex.Message == ExceptionMessages.TransactionInsufficientFunds()) { result.IsEnough = false; return(result); } else { throw new Exception(ex.Message); } } commissionAcc.UnsubscribeFromCommission(accManager); result.IsEnough = true; result.SendAmount = accEntityFrom.Amount - accFrom.Money.Amount; result.Commission = result.SendAmount - amount; result.Receive = accTo.Money.Amount - accEntityTo.Amount; result.CommissionOwner = commissionAccEntity.User.UserName; result.CommissionAccName = commissionAccEntity.AccountName; result.CurrFrom = accEntityFrom.Currency; result.CurrTo = accEntityTo.Currency; accEntityFrom.Amount = accFrom.Money.Amount; accEntityTo.Amount = accTo.Money.Amount; commissionAccEntity.Amount += commissionAcc.Money.Amount; DBContext.Accounts.Update(accEntityFrom); DBContext.Accounts.Update(accEntityTo); DBContext.Accounts.Update(commissionAccEntity); await DBContext.SaveChangesAsync(); return(result); }
private CommissionBank() { commissionAcc = new CommissionAccount("commAcc", 0, Currency.USD); }
/* * public void Invoke(string testName) * { * // attribute type we search * System.Type attributeType = typeof(TestCommissionAttribute); * * // find method * var methodInfo = this.GetType().GetMethods().FirstOrDefault(m => * m.GetCustomAttributes(attributeType).Cast<TestCommissionAttribute>().Any() && * string.Equals(m.Name, testName, StringComparison.InvariantCultureIgnoreCase)); * * if (methodInfo != null) * { * // method found * PrintTestName(methodInfo.Name); * InitializeTestContent(); * try * { * methodInfo.Invoke(this, new object[] { methodInfo.Name }); * } * catch (Exception ex) * { * Console.WriteLine(ex.Message); * } * } * } * * public void InvokeAll() * { * System.Type attributeType = typeof(TestCommissionAttribute); * * var methodsInfo = this.GetType().GetMethods().Where(m => * m.GetCustomAttributes(attributeType).Cast<TestCommissionAttribute>().Any()).ToList(); * * foreach (var method in methodsInfo) * { * PrintTestName(method.Name); * InitializeTestContent(); * try * { * method.Invoke(this, new object[] { method.Name }); * } * catch (Exception ex) * { * Console.WriteLine(ex.Message); * } * } * } * * private void PrintTestName(string testName) * { * Console.WriteLine("Start test: {0}", testName); * } */ public void TestsConstructor(string testName, OrderType orderType, Side orderSide, CommissionAccount account, CommissionMethod method, bool isPassive) { InitializeTestContent(); TestContent.TradeSettings.Settings.BuyerTakerCommissionProgressive = 7; TestContent.TradeSettings.Settings.SellerTakerCommissionProgressive = 5; TestContent.TradeSettings.Settings.BuyerMakerCommissionProgressive = 6; TestContent.TradeSettings.Settings.SellerMakerCommissionProgressive = 4; if (orderSide == Side.BUY) { TestContent.TradeSettings.Settings.BuyerCommissionAccount = account; TestContent.TradeSettings.Settings.BuyerCommissionMethod = method; } if (orderSide == Side.SELL) { TestContent.TradeSettings.Settings.SellerCommissionAccount = account; TestContent.TradeSettings.Settings.SellerCommissionMethod = method; } ConfiguratorService.SaveTradeSetting(User.UserId, TestContent.TradeSettings.Settings); Order = new OrderCrypto() { Destination = Exchange, Quantity = method == CommissionMethod.TERM_TICKS ? 2 : 0.01, Side = orderSide, Type = orderType, SecurityId = Symbol, }; if (orderType == OrderType.LIMIT) { Order.Price = CalcAggressiveOrderPrice(orderSide); Order.TimeInForce = isPassive ? TimeInForce.DAY : TimeInForce.IOC; } GeneralCheck(testName, isPassive); }
protected void CalcCommissions(List <TransactionDto> currencyForCommission, CommissionMethod method, CommissionAccount account, double pv, double commissions) { string currency = currencyForCommission[0].CurrencyId; int precision = currency == BaseSymbol || method == CommissionMethod.TERM_TICKS ? 4 : 3; double calcCommissions = 0; if (method == CommissionMethod.EXACT_VALUE) { calcCommissions = Math.Round(TestContent.BaseTransactions.FindAll(t => t.Type == Type.profit_loss).Sum(t => t.Amount) * pv, precision); } if (method == CommissionMethod.QUANTITY_PERCENT) { calcCommissions = Math.Round(currencyForCommission.FindAll(t => t.Type == Type.profit_loss).Sum(t => t.Amount) * pv * GetCoeffMethod(method, account), precision); } if (method == CommissionMethod.TERM_TICKS) { calcCommissions = Math.Round(Math.Pow(TestContent.BaseTransactions.FindAll(t => t.Type == Type.profit_loss).Sum(t => t.Amount), 2) * pv * GetCoeffMethod(method, account) / currencyForCommission.FindAll(t => t.Type == Type.profit_loss).Sum(t => t.Amount), precision); } calcCommissions = calcCommissions > 0 ? -calcCommissions : calcCommissions; if (CompareDouble(commissions, calcCommissions)) { Console.WriteLine("{0} Commissions: {1}, Calculate commissions: {2}", currency, commissions, calcCommissions); } else { Console.WriteLine("Error! {0} Commissions: {1}, Calculate commissions: {2}", currency, commissions, calcCommissions); TestContent.IsSuccess = false; } }