public void Throw_InvalidOperationException_If_Amount_Is_Lesser_Than_OverdraftLimit()
{
Assert.Throws <InvalidOperationException>(() =>
{
var balance = Balance.Create(-600m);
});
}
public void Bank_statement_should_have_separator_after_credit()
{
var transaction = Transaction.Create(new Credit(1000));
var bankStatement = transaction.BankStatement(Balance.Create(500));
Compare(bankStatement, "01/01/2016 || 1000.00 ||");
}
public void Debit_Bank_statement_should_not_have_any_credit_information()
{
var transaction = Transaction.Create(new Debit(1000));
var bankStatement = transaction.BankStatement(Balance.Create(500));
Compare(bankStatement, "01/01/2016 || || 1000.00 ||");
}
public void Create_Itself_From_Money()
{
var money = new Money(123);
var balance = Balance.Create(money);
Assert.AreEqual(money.Value, balance.Value);
}
public void Bank_statement_should_have_balance_at_the_end()
{
var transaction = Transaction.Create(new Debit(1000));
var bankStatement = transaction.BankStatement(Balance.Create(2500));
Compare(bankStatement, "01/01/2016 || || 1000.00 || 2500.00");
}
public void Bank_statement_should_begin_with_today()
{
var transaction = Transaction.Create(new Credit(1000));
var bankStatement = transaction.BankStatement(Balance.Create(500));
Compare(bankStatement, "01/01/2016 ");
}
public void EncodingTest()
{
var accountId = new AccountId();
accountId.Create("0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d");
var balance = new Balance();
balance.Create(100);
var callArguments = new GenericExtrinsicCall("", "", accountId, balance);
switch (Constants.AddressVersion)
{
case 0:
Assert.AreEqual("D43593C715FDD31C61141ABD04A99FD6822C8558854CCDE39A5684E7A56DA27D9101",
Utils.Bytes2HexString(callArguments.Encode(), Utils.HexStringFormat.Pure));
break;
case 1:
Assert.AreEqual("FFD43593C715FDD31C61141ABD04A99FD6822C8558854CCDE39A5684E7A56DA27D9101",
Utils.Bytes2HexString(callArguments.Encode(), Utils.HexStringFormat.Pure));
break;
case 2:
Assert.AreEqual("00D43593C715FDD31C61141ABD04A99FD6822C8558854CCDE39A5684E7A56DA27D9101",
Utils.Bytes2HexString(callArguments.Encode(), Utils.HexStringFormat.Pure));
break;
}
}
public void Throw_InvalidOperationException_If_Amount_Have_More_Than_Two_Decimal_Points()
{
Assert.Throws <InvalidOperationException>(() =>
{
var balance = Balance.Create(0.001m);
});
}
public void Credit_Bank_statement_should_be_displayed_after_date()
{
var transaction = Transaction.Create(new Credit(1000));
var bankStatement = transaction.BankStatement(Balance.Create(500));
Compare(bankStatement, "01/01/2016 || 1000.00");
}
public void Create_Account_With_Balance()
{
BankAccount bankAccount = BankAccount.CreateBankAccountWithBalance(Balance.Create(123));
var actualBalance = bankAccount.Balance;
Assert.AreEqual(Balance.Create(123), actualBalance);
}
internal Balance GetBalance()
{
return(Balance.Create(
currency,
decimal.Round(decimal.Parse(balanceAvailable.ToString()), 2),
decimal.Round(decimal.Parse(balanceCurrent.ToString()), 2),
Util.EpochTimeMillis(),
new List <TypedBalance>()));
}
private DateTimeOffset[] GetOccurredOns()
{
var accountCreatedWithBalance = new AccountCreatedWithBalance(Balance.Create(123m));
var accountCreatedWithEmptyBalance = new AccountCreatedWithEmptyBalance();
var depositedMoney = new DepositedMoney(new Money(123m));
var withdrawnMoney = new WithdrawnMoney(new Money(123m));
return(new[] { accountCreatedWithBalance.OccurredOn, accountCreatedWithEmptyBalance.OccurredOn, depositedMoney.OccurredOn, withdrawnMoney.OccurredOn });
}
public void Initialize_Balance()
{
var balance = Balance.Create(123m);
var accountCreatedWithBalance = new AccountCreatedWithBalance(balance);
var actual = accountCreatedWithBalance.Balance;
Assert.AreEqual(balance, actual);
}
public void Configure(EntityTypeBuilder <Account> builder)
{
builder.ToTable("Accounts", "account");
builder.HasKey(p => p.Id);
builder.HasOne(p => p.Client).WithMany(p => p.Accounts);
builder.Property(p => p.Iban).HasColumnType("nvarchar(34)");
builder.Property(p => p.Balance).HasConversion(p => p.Value, p => Balance.Create(p));
builder.HasMany(p => p.Transactions).WithOne(p => p.Account);
}
public void Withdraw_Money()
{
var money = new Money(100m);
var balance = Balance.Create(300m);
var newBalance = balance.Withdraw(money);
var actual = newBalance.Value;
Assert.AreEqual(balance.Value - money.Value, actual);
}
public void Have_Overriden_Equality_Members()
{
var balance1 = Balance.Create(123m);
var balance2 = Balance.Create(123m);
var balance3 = Balance.Create(122m);
Assert.IsTrue(balance1 == balance2);
Assert.IsTrue(balance2.Equals(balance1));
Assert.IsTrue(balance1 != balance3);
Assert.IsTrue(!balance3.Equals(balance2));
}
public void Have_Zero_As_StoredEventVersion_After_Initialization()
{
var bankAccount1 = BankAccount.CreateEmptyBankAccount();
var bankAccount2 = BankAccount.CreateBankAccountWithBalance(Balance.Create(123));
var actual1 = bankAccount1.StoredEventVersion;
var actual2 = bankAccount2.StoredEventVersion;
Assert.AreEqual(default(int), actual1);
Assert.AreEqual(default(int), actual2);
}
public void Deposit_Money()
{
BankAccount bankAccount = BankAccount.CreateEmptyBankAccount();
var money = new Money(123);
bankAccount.Deposit(money);
var actualBalance = bankAccount.Balance;
Assert.AreEqual(Balance.Create(money), actualBalance);
}
public void Withdraw_Money()
{
BankAccount bankAccount = BankAccount.CreateEmptyBankAccount();
var money = new Money(123);
bankAccount.Withdraw(money);
var actualBalance = bankAccount.Balance;
Assert.AreEqual(Balance.Create(-123), actualBalance);
}
public void MogwaiBiosTest()
{
var mogwaiBiosStr = "0x0b1b9f0f79a9e3971baf6188ed98623284f1c3bb275883602164b7097789523f000000000881f7a106cc0f747e85deedaf2946297ebacbe008a7a4887c334448fcc4c4888c00000000000000000000000000000000010426df010000";
var mogwaiBiosA = new MogwaiBios();
mogwaiBiosA.Create(mogwaiBiosStr);
var mogwaiBiosB = new MogwaiBios();
var id = new Hash();
id.Create(mogwaiBiosA.Id.Value);
Assert.AreEqual("0x0B1B9F0F79A9E3971BAF6188ED98623284F1C3BB275883602164B7097789523F", mogwaiBiosA.Id.Value);
var state = new U32();
state.Create(mogwaiBiosA.State.Value);
Assert.AreEqual(0, mogwaiBiosA.State.Value);
var metaXy = new Vec <U8Arr16>();
metaXy.Create(mogwaiBiosA.MetaXy.Bytes);
Assert.AreEqual(2, mogwaiBiosA.MetaXy.Value.Count);
Assert.AreEqual("0x0881F7A106CC0F747E85DEEDAF2946297EBACBE008A7A4887C334448FCC4C4888C", Utils.Bytes2HexString(mogwaiBiosA.MetaXy.Bytes));
Assert.AreEqual("0x81F7A106CC0F747E85DEEDAF2946297E", Utils.Bytes2HexString(metaXy.Value[0].Bytes));
var intrinsic = new Balance();
intrinsic.Create(mogwaiBiosA.Intrinsic.Value);
var level = new U8();
level.Create(mogwaiBiosA.Level.Value);
var phases = new Vec <BlockNumber>();
phases.Create(mogwaiBiosA.Phases.Bytes);
var adaptations = new Vec <Hash>();
adaptations.Create(mogwaiBiosA.Adaptations.Bytes);
mogwaiBiosB.Create(id, state, metaXy, intrinsic, level, phases, adaptations);
Assert.AreEqual(mogwaiBiosB.Id.Value, mogwaiBiosA.Id.Value);
Assert.AreEqual(mogwaiBiosB.State.Value, mogwaiBiosA.State.Value);
Assert.AreEqual(mogwaiBiosB.MetaXy.Value[0].Bytes, mogwaiBiosA.MetaXy.Value[0].Bytes);
Assert.AreEqual(mogwaiBiosB.Intrinsic.Value, mogwaiBiosA.Intrinsic.Value);
Assert.AreEqual(mogwaiBiosB.Level.Value, mogwaiBiosA.Level.Value);
Assert.AreEqual(mogwaiBiosB.Phases.Value[0].Bytes, mogwaiBiosA.Phases.Value[0].Bytes);
Assert.AreEqual(mogwaiBiosB.Adaptations.Value, mogwaiBiosA.Adaptations.Value);
}
public static GenericExtrinsicCall BalanceTransfer(string address, BigInteger balanceAmount)
{
var accountId = new AccountId();
accountId.Create(Utils.GetPublicKeyFrom(address));
var balance = new Balance();
balance.Create(balanceAmount);
return(BalanceTransfer(accountId, balance));
}
public void BalanceTest()
{
var balance1 = new Balance();
balance1.Create("0x518fd3f9a8503a4f7e00000000000000");
Assert.AreEqual("2329998717451725147985", balance1.Value.ToString());
var balance2 = new Balance();
balance2.Create(Utils.HexToByteArray("518fd3f9a8503a4f7e00000000000000"));
Assert.AreEqual("2329998717451725147985", balance2.Value.ToString());
}
public void Update_DomainEventVersion_On_Every_Mutation()
{
var bankAccount1 = BankAccount.CreateBankAccountWithBalance(Balance.Create(123));
var bankAccount2 = BankAccount.CreateEmptyBankAccount();
bankAccount2.Deposit(new Money(1));
bankAccount2.Withdraw(new Money(3));
var actual1 = bankAccount1.DomainEventVersion;
var actual2 = bankAccount2.DomainEventVersion;
Assert.AreEqual(1, actual1);
Assert.AreEqual(3, actual2);
}
public void Initialize_Identity()
{
BankAccount bankAccount1 = BankAccount.CreateEmptyBankAccount();
BankAccount bankAccount2 = BankAccount.CreateBankAccountWithBalance(Balance.Create(123));
BankAccount bankAccount3 =
BankAccount.ReconstructBankAccount(new BankAccountSnapshot(1, 23, Guid.NewGuid()),
new List <DomainEvent>());
var actual1 = bankAccount1.Id;
var actual2 = bankAccount2.Id;
var actual3 = bankAccount3.Id;
Assert.AreNotEqual(default(Guid), actual1);
Assert.AreNotEqual(default(Guid), actual2);
Assert.AreNotEqual(default(Guid), actual3);
}
public void Store_Event_For_Every_Mutation()
{
var bankAccountWithBalance = BankAccount.CreateBankAccountWithBalance(Balance.Create(123));
var bankAccount = BankAccount.CreateEmptyBankAccount();
bankAccount.Deposit(new Money(1));
bankAccount.Withdraw(new Money(3));
var actualBankAccountWithBalanceEvent = bankAccountWithBalance.Changes[0];
var actualEmptyBankAccountEvent = bankAccount.Changes[0];
var actualDepositEvent = bankAccount.Changes[1];
var actualWithdrawEvent = bankAccount.Changes[2];
Assert.IsInstanceOf <AccountCreatedWithBalance>(actualBankAccountWithBalanceEvent);
Assert.IsInstanceOf <AccountCreatedWithEmptyBalance>(actualEmptyBankAccountEvent);
Assert.IsInstanceOf <DepositedMoney>(actualDepositEvent);
Assert.IsInstanceOf <WithdrawnMoney>(actualWithdrawEvent);
}
public void MogwaiStructTest()
{
var mogwaiStructStr = "0x89ab510f57802886c16922685a376edb536f762584dda569cda67381c4e4dec889ab510f57802886c16922685a376edb536f762584dda569cda67381c4e4dec871000000000000000000000000000000000000000000000000";
var mogwaiStructA = new MogwaiStruct();
mogwaiStructA.Create(mogwaiStructStr);
var mogwaiStructB = new MogwaiStruct();
var id = new Hash();
id.Create(mogwaiStructA.Id.Value);
var dna = new Hash();
dna.Create(mogwaiStructA.Dna.Value);
var genesis = new BlockNumber();
genesis.Create(mogwaiStructA.Genesis.Value);
var price = new Balance();
price.Create(mogwaiStructA.Price.Value);
var gen = new U32();
gen.Create(mogwaiStructA.Gen.Value);
var rarity = new EnumType <RarityType>();
rarity.Create(mogwaiStructA.Rarity.Bytes);
mogwaiStructB.Create(id, dna, genesis, price, gen, rarity);
Assert.AreEqual(mogwaiStructB.Id.Value, mogwaiStructA.Id.Value);
Assert.AreEqual(mogwaiStructB.Dna.Value, mogwaiStructA.Dna.Value);
Assert.AreEqual(mogwaiStructB.Genesis.Value, mogwaiStructA.Genesis.Value);
Assert.AreEqual(mogwaiStructB.Price.Value, mogwaiStructA.Price.Value);
Assert.AreEqual(mogwaiStructB.Gen.Value, mogwaiStructA.Gen.Value);
Assert.AreEqual(mogwaiStructB.Rarity.Value, mogwaiStructA.Rarity.Value);
}
public void Reconstruct_Itself_From_Snapshot_And_Non_Empty_List_Of_Domain_Events()
{
var bankAccount = BankAccount.CreateEmptyBankAccount();
bankAccount.Deposit(new Money(100));
bankAccount.Deposit(new Money(100));
bankAccount.Deposit(new Money(100));
var snapshot = bankAccount.Snapshot();
var reconstructedAccount = BankAccount.ReconstructBankAccount(snapshot, new List <DomainEvent>
{
new WithdrawnMoney(new Money(100)),
new WithdrawnMoney(new Money(100))
});
Assert.AreEqual(Balance.Create(new Money(100)), reconstructedAccount.Balance);
Assert.AreEqual(0, reconstructedAccount.Changes.Count);
Assert.AreEqual(reconstructedAccount.DomainEventVersion, reconstructedAccount.StoredEventVersion);
}
public void Create_Itself_From_Decimal_Value()
{
var balance = Balance.Create(123m);
Assert.AreEqual(123m, balance.Value);
}
public BankAccount()
{
_balance = Balance.Create(0);
}
public async Task <WalletResult> PayoutToUser <T>(RequestContext <T> requestContext, GameResult gr, BonusExtraInfo bei, bool isEndGame, string debitTrxId = "")
{
using (logger.BeginScope(new Dictionary <string, object>
{
["SessionKey"] = requestContext.UserSession.SessionKey,
["UserId"] = requestContext.UserSession.UserId,
["GameKey"] = requestContext.GameKey,
["Platform"] = requestContext.Platform,
["GameTransactionId"] = gr.TransactionId,
["Amount"] = gr.Win,
["CurrentRoundId"] = gr.RoundId,
["WalletReference"] = bei.BetId,
}))
{
logger.LogInformation("Payout to user");
if (gr.RoundId <= 0)
{
var msg = String.Format("RoundID can not be zero or less than zero, please always set RoundID to GameResult. Current value is {0}", gr.RoundId);
throw new ArgumentException(msg, "RoundID");
}
if (isEndGame && gr.RoundId > 0)
{
logger.LogDebug($"[WIN:ENDGAME] BetId:{bei.BetId} RoundId:{gr.RoundId}");
}
gr.Balance = Balance.Create(0);
var user = requestContext.UserSession.User;
var game = requestContext.Game;
WalletResult result;
try
{
var wallet = await userService.GetWallet(requestContext.UserSession);
result = await wallet.Credit(gr.Win, game.Id, gr.TransactionId, 0, gr.RoundId, bei.BetId, (int)gr.PlatformType, debitTrxId, gr.TransactionId.ToString(), isEndGame);
if (result.Balance <= 0)
{
var x = await wallet.GetBalance(game.Id, (int)gr.PlatformType);
result.Balance = x.IsError ? 0m : x.Value;
}
gr.ExchangeRate = result.ExchangeRate;
}
catch (Exception ex)
{
gr.ErrorSource = ErrorSource.Wallet;
logger.LogError(ex, $"[WIN:CREDIT] UserId:{user.Id} GameId:{game.Id} TransactionId:{gr.TransactionId} BetId:{bei.BetId} RoundId:{gr.RoundId} Message:{ex.Message}");
throw;
}
if (!gr.ExchangeRate.HasValue)
{
gr.ExchangeRate = 1;
}
gr.Balance = Balance.Create(result.Balance);
return(result);
}
}
