public void ShowMenu()
{
bool showMenu = true;
while (showMenu)
{
PrintMenu();
bool converted = Int32.TryParse(Console.ReadLine(), out int input);
if (converted && input <= 0)
{
showMenu = false;
}
else if (converted && input <= bankStrings.Count)
{
IBank bankInstance = CreateBank(input);
if (bankInstance != null)
{
ShowInstanceMenu(bankInstance);
}
else
{
Console.WriteLine("Bank Account failed to be created");
}
}
}
}
private Builder(Option <Currency> currency, Option <decimal> distributionUnit, Option <IRoundingStrategy> roundingStrategy, IBank bank)
{
_targetCurrency = currency;
_distributionUnit = distributionUnit;
_roundingStrategy = roundingStrategy;
_bank = bank;
}
public void BankStatementDownload()
{
// You need to get your own bank details into an IBank object.
IBank bank = GetMyBankInfo();
// You need to get your own account details into an IAccount object.
IAccount account = GetMyAccountInfo();
OfxRequestBuilder builder = OfxFactory.Builder.Create();
builder.BuildOfxRequest(() =>
{
builder.Signon.BuildMessageSet(bank);
builder.Bank.BuildMessageSet(() =>
{
// in your app, you'd have to determine an appropiate date to start with.
DateTime fromDate = new DateTime(2018, 1, 1);
builder.Bank.BuildStatementRequest(account, fromDate, null, true);
// add another statement request if you've got another account at the same bank
});
});
// Send request to the bank and get the response
string response = GetResponseFromBank(builder.RequestText);
// Transform response string. Ready to go.
OfxResponse ofx = OfxFactory.Response.Create(response);
}
private void PrintBankOperations(IBank targetBank)
{
Console.WriteLine(targetBank.ToString());
Console.WriteLine("0. Exit");
Console.WriteLine("1. Send Money");
Console.WriteLine("2. Balance");
}
static void Main(string[] args)
{
//Account account = new Account();
//IBank<Account> ordinaryBank = new Bank<Account>();
//ordinaryBank.DoOperation(account);
//DepositAccount depositAcc = new DepositAccount();
//IBank<DepositAccount> depositBank = ordinaryBank;
//ordinaryBank.DoOperation(depositAcc);
//Console.ReadLine();
IBank <DepositAccount> depositBank = new Bank();
depositBank.DoOperation();
IBank <Account> ordinaryBank = depositBank;
ordinaryBank.DoOperation();
Console.ReadLine();
Console.WriteLine("GENRIC INTERFACE");
var driver = DriverFactory.Get(1);
driver.Do();
driver = DriverFactory.Get(2);
driver.Do();
Console.ReadLine();
}
/// <summary>
/// Seal parcel after modification
/// May call this method on parcels in either Creating or Modifying states.
/// Bank is used to create the ReplicationVersionInfo which is depends on store/bank implementation.
/// Parcels can replicate only within stores/technologies that have sealed them
/// </summary>
public void Seal(IBank bank)
{
if (bank == null)
{
throw new DistributedDataAccessException(StringConsts.ARGUMENT_ERROR + "Parcel.Seal(bank==null)");
}
if (m_State != ParcelState.Creating && m_State != ParcelState.Modifying)
{
throw new DistributedDataAccessException(StringConsts.DISTRIBUTED_DATA_PARCEL_INVALID_OPERATION_ERROR.Args("Seal", GetType().FullName, m_State));
}
Validate(bank);
if (ValidationExceptions.Any())
{
throw ParcelSealValidationException.ForErrors(GetType().FullName, ValidationExceptions);
}
m_ReplicationVersionInfo = bank.GenerateReplicationVersionInfo(this);
DoSeal(bank);
m_State = ParcelState.Sealed;
m_NewlySealed = true;
}
public override void OnSaved(object sender, EntityAfterEventArgs e)
{
base.OnSaved(sender, e);
Entity entity = (Entity)sender;
//UserConnection = entity.UserConnection;
var amountFC = entity.GetTypedColumnValue <decimal>("AmountFC");
var date = entity.GetTypedColumnValue <DateTime>("TransactionDate");
var currencyId = entity.GetTypedColumnValue <Guid>("CurrencyId");
string shortCurrency = entity.FindValueById <string>("Currency", currencyId, "ShortName");
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.BOC);
IBankResult result = null;
Task.Run(async() =>
{
result = await ibank.GetRateAsync(shortCurrency, date);
}).Wait();
entity.SetColumnValue("FxRate", result.ExchangeRate);
entity.SetColumnValue("AmountHC", amountFC * result.ExchangeRate);
entity.Save();
_log.Info($"rate:{result.ExchangeRate} on {result.RateDate:dd-MMM-yyyy}");
}
public void BalanceShowsAllBalances()
{
//Arrange
ICollection <Account> expectedResult = new List <Account>()
{
new Account()
{
AccountNumber = 1
},
new Account()
{
AccountNumber = 3
},
new Account()
{
AccountNumber = 2
}
};
IBank fakeBank = Mock.Create <IBank>();
Mock.Arrange(() => fakeBank.GetAllAccounts()).Returns(expectedResult).MustBeCalled();
HomeController controller = new HomeController(fakeBank);
// Act
ViewResult result = controller.Balance() as ViewResult;
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result.Model, typeof(IEnumerable <Account>));
Assert.IsTrue((expectedResult as IEnumerable <Account>).SequenceEqual <Account>(result.Model as IEnumerable <Account>));
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.Bank == null))
{
IBank bankCasted = item.As <IBank>();
if ((bankCasted != null))
{
this._parent.Bank = bankCasted;
return;
}
}
if ((this._parent.ServiceSupplier == null))
{
IServiceSupplier serviceSupplierCasted = item.As <IServiceSupplier>();
if ((serviceSupplierCasted != null))
{
this._parent.ServiceSupplier = serviceSupplierCasted;
return;
}
}
IBankStatement bankStatementsCasted = item.As <IBankStatement>();
if ((bankStatementsCasted != null))
{
this._parent.BankStatements.Add(bankStatementsCasted);
}
}
public void WithdrawMoreThanBalanceGivesError()
{
//Arrange
Account testAccount = new Account(new Transaction[] {
new Transaction()
{
ID = 1, Amount = 100, BalanceAccountNumber = 987654
},
new Transaction()
{
ID = 2, Amount = -0.05, BalanceAccountNumber = 123456
}
})
{
AccountNumber = 7
};
IBank fakeBank = Mock.Create <IBank>();
Mock.Arrange(() => fakeBank.GetAccountByNumber(7)).Returns(testAccount).MustBeCalled();
HomeController controller = new HomeController(fakeBank);
double expectedResult = testAccount.Balance;
// Act
ViewResult result = controller.Withdraw(7, 100) as ViewResult;
Assert.IsNotNull(result);
Account account = result.Model as Account;
string actualResult = result.ViewBag.ErrorMessage;
// Assert
Assert.IsTrue(actualResult.Contains("Insufficient funds."));
Assert.AreEqual(expectedResult, account.Balance); //No change done to the account
}
public void WithdrawNegGivesError()
{
//Arrange
Account testAccount = new Account(new Transaction[] {
new Transaction()
{
ID = 1, Amount = 100, BalanceAccountNumber = 987654
},
new Transaction()
{
ID = 2, Amount = -0.05, BalanceAccountNumber = 123456
}
})
{
AccountNumber = 7
};
IBank fakeBank = Mock.Create <IBank>();
Mock.Arrange(() => fakeBank.GetAccountByNumber(7)).Returns(testAccount);
HomeController controller = new HomeController(fakeBank);
double expectedResult = testAccount.Balance;
// Act
ViewResult result = controller.Withdraw(7, -300.1) as ViewResult;
Account account = result.Model as Account;
string actualResult = result.ViewBag.ErrorMessage;
// Assert
Assert.IsTrue(actualResult.StartsWith("Cannot withdraw an amount less than or equal 0."));
Assert.AreEqual(expectedResult, account.Balance); //No change done to the account
}
public void TransactionsGivenValidAccountNrReturnsAccount()
{
//Arrange
Account expectedResult = new Account(new Transaction[] {
new Transaction()
{
ID = 1, Amount = 100, BalanceAccountNumber = 987654
},
new Transaction()
{
ID = 2, Amount = -0.05, BalanceAccountNumber = 123456
}
})
{
AccountNumber = 7
};
IBank fakeBank = Mock.Create <IBank>();
Mock.Arrange(() => fakeBank.GetAccountByNumber(7)).Returns(expectedResult).MustBeCalled();
HomeController controller = new HomeController(fakeBank);
// Act
ViewResult result = controller.Transactions(7) as ViewResult;
Account actualResult = result.Model as Account;
// Assert
Assert.AreEqual(expectedResult, actualResult);
}
public static string GetBankName(string Account)
{
if (Account == null)
{
return("No data");
}
Account = NormalizeNumber(Account);
if (IsValidNumber(Account))
{
IBank bank = GetBank(Account);
if (bank == null)
{
return("Unknown bank account");
}
else
{
return(bank.BankName());
}
}
else
{
return("Invalid account number");
}
}
public async Task BOC_GetRateAsyncShoudReturn(decimal expectedExchangeRate,
DateTime requestedRateDate, DateTime expectedRateDate, string currency)
{
#region Arrange
IBankResult expected = new BankResult()
{
BankName = "Bank of Canada",
HomeCurrency = "CAD",
ExchangeRate = expectedExchangeRate,
RateDate = expectedRateDate
};
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.BOC);
#endregion
#region Act
IBankResult actual = await ibank.GetRateAsync(currency, requestedRateDate);
#endregion
#region Assert
//Assert.Equal(expected, actual);
Assert.Equal(expected.RateDate, actual.RateDate);
Assert.Equal(expected.ExchangeRate, actual.ExchangeRate);
Assert.Equal(expected.BankName, actual.BankName);
Assert.Equal(expected.HomeCurrency, actual.HomeCurrency);
#endregion
}
public void AskCredit_AmountExceeded()
{
IClientManager clientManager = new ClientManager();
FinanceManager financeManager = new FinanceManager(clientManager, new EmailSenderMock());
ShoppingClient.Clients.Clear();
clientManager.RegisterUser("Marko", "Sinisic", "*****@*****.**", "markos123", "Novi Sad", new DateTime(1990, 5, 25), new List <IAccount>());
IClient client = ShoppingClient.Clients[0];
financeManager.CreateAccount("f231rf34f34f3f4", new Bank(), 10000, 0, false);
IAccount account = FinantialDB.Accounts.Values.ToList()[0];
financeManager.CreateBank("Raiffeisen", "Cara Lazara 55", new List <ICredit>(), "din", new List <IAccount>()
{
account
}, 1000, 10000, 100);
IBank bank = FinantialDB.Banks.Values.ToList()[0];
financeManager.CreateCredit("kredit", 0.05, FinantialDB.Currency["EUR"], bank, 10);
ICredit credit = FinantialDB.Credits.Values.ToList()[0];
bank.ListOfCredits.Add(credit);
Assert.Throws <Exception>(() => financeManager.AskCredit(client.ID, credit.ID, 123, 50000), "Credit amount exceeds bank's maximum credit amount.");
}
public void PlatiCommandExecute()
{
NalogPrenos nalog = new NalogPrenos(
-1,
"test",
SelektovanaFaktura.NazivKupca,
"Svrha placanja",
SelektovanaFaktura.NazivDobavljaca,
DateTime.Now,
DateTime.Now,
racun.BrojRacun,
97,
"poziv",
SelektovanaFaktura.UplataNaRacun,
97,
4464,
SelektovanaFaktura.UkupnoRobeIUsluga,
"RSD",
false
);
Banka banka = DAO.GetBanka(racun.BrojRacun);
ChannelFactory <IBank> factory = new ChannelFactory <IBank>(new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:9000/" + banka.Naziv));
IBank proxy = factory.CreateChannel();
try
{
proxy.SendNalogPrenos(nalog);
}
catch (Exception e)
{ }
}
private static async Task RateBOMX(string Currency, DateTime date)
{
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.BOMX, Resources.bmxSecret);
IBankResult result = await ibank.GetRateAsync(Currency, date);
PrintReSult(Currency, result);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="employeeRepository"></param>
public CommonController(ICommon commonRepository, ILookupDetails lookupDetailsRepository, ICommon CommonRepository, IBank companyRepository)
{
_empRepository = commonRepository;
_lookUpRepository = lookupDetailsRepository;
_CommonRepository = CommonRepository;
_companyRepository = companyRepository;
}
private void ShowInstanceMenu(IBank sendingBank)
{
bool showMenu = true;
while (showMenu)
{
PrintBankOperations(sendingBank);
bool converted = Int32.TryParse(Console.ReadLine(), out int input);
if (converted)
{
switch (input)
{
case 0:
showMenu = false;
break;
case 1:
TransactionResult(SendingMoney(sendingBank).Status);
break;
case 2:
Console.WriteLine(sendingBank.GetBalance());
break;
}
}
}
}
public void MakePayment(Product product, PaymentType type)
{
ConcretePaymentFactory factory = new ConcretePaymentFactory();
IBank bank = factory.PaymentBank(type, product);
bank.MakePayment(product);
}
private Builder()
{
_targetCurrency = default;
_roundingStrategy = default;
_distributionUnit = default;
_bank = DefaultBank.Empty;
}
/// <summary>
/// 1 First search for bytewise duplicate patch, if found -> don't paste.
/// 2 Than and if 'Equally Named Patches' is selected, search for an equally named patch and reference to that.
/// 3 Otherwise, if 'Like-Named Pathces' is selected, remove the ignore characters and find a like-named patch and
/// reference to that.
/// For all searches above, if a patch is found on the same location (a), prefer that, otherwise find the first occurence (b).
/// </summary>
/// <param name="clipBoardPatch"></param>
/// <param name="bank"></param>
/// <returns>True if a duplicate is found.</returns>
private bool CheckForDuplicate(IClipBoardPatch clipBoardPatch, IBank bank)
{
Debug.Assert(!(clipBoardPatch is IClipBoardSetListSlot));
// If the source patch is present in the source PCG file, check if it is present in the target PCG.
if (clipBoardPatch.Data.Length != 0)
{
IPatch sameLocationPatch;
if (SearchByteWiseEqualPatchSameLocation(clipBoardPatch, bank, out sameLocationPatch))
{
return(true);
}
if (SearchByteWiseEqualPatchFirstOccurence(clipBoardPatch, bank))
{
return(true);
}
if (SearchIdenticalNamePatch(clipBoardPatch, bank, sameLocationPatch))
{
return(true);
}
if (SearchLikeNamedPatch(clipBoardPatch, bank, sameLocationPatch))
{
return(true);
}
}
return(false);
}
/// <summary>
/// 3b. Search for a like named patch if Like Named Patches is selected, on same location.
/// </summary>
/// <param name="clipBoardPatch"></param>
/// <param name="bank"></param>
/// <param name="sameLocationPatch"></param>
/// <returns></returns>
private bool SearchLikeNamedPatch(IClipBoardPatch clipBoardPatch, IBank bank, IPatch sameLocationPatch)
{
if (Settings.Default.CopyPaste_PatchDuplicationName == (int)CopyPaste.PatchDuplication.LikeNamedNames)
{
if (sameLocationPatch != null)
{
if (sameLocationPatch.IsNameLike(clipBoardPatch.OriginalLocation.Name))
{
clipBoardPatch.PasteDestination = sameLocationPatch;
PcgClipBoard.ProtectedPatches.Add(sameLocationPatch);
return(true);
}
}
// 2b. Search for an identical name patch, on first occurence.
foreach (var patch in bank.Patches.Where(
patch => patch.IsNameLike(clipBoardPatch.OriginalLocation.Name)))
{
clipBoardPatch.PasteDestination = patch;
PcgClipBoard.ProtectedPatches.Add(patch);
return(true);
}
}
return(false);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
IINGExchangeRate iNGExchangeRate2020 = new INGExchangeRate2020();
IINGExchangeRate iNGExchangeRate2021 = new INGExchangeRate2021();
IBTExchangeRate bTExchangeRate2020 = new BTExchangeRate2020();
IBTExchangeRate bTExchangeRate2021 = new BTExchangeRate2021();
IABExchangeRate aBExchangeRate2020 = new ABExchangeRate2020();
IABExchangeRate aBExchangeRate2021 = new ABExchangeRate2021();
IBCRExchangeRate bCRExchangeRate2020 = new BCRExchangeRate2020();
IBCRExchangeRate bCRExchangeRate2021 = new BCRExchangeRate2021();
Dictionary <Type, object> dependecyInjectionContainer = new Dictionary <Type, object>();
dependecyInjectionContainer.Add(typeof(IINGExchangeRate), iNGExchangeRate2020);
dependecyInjectionContainer.Add(typeof(IBTExchangeRate), bTExchangeRate2020);
dependecyInjectionContainer.Add(typeof(IABExchangeRate), aBExchangeRate2020);
dependecyInjectionContainer.Add(typeof(IBCRExchangeRate), bCRExchangeRate2020);
ConstructorInfo constructorInfo = typeof(ING).GetConstructors().FirstOrDefault();
List <object> ingParams = new List <object>();
foreach (ParameterInfo parameterInfo in constructorInfo.GetParameters())
{
Console.WriteLine(parameterInfo.ParameterType.ToString());
ingParams.Add(dependecyInjectionContainer[parameterInfo.ParameterType]);
}
//var parameters = new object[1];
//parameters[0] = ingParams[0];
//ING ingInstance = Activator.CreateInstance(typeof(ING), parameters) as ING;
//ING ingInstance = Activator.CreateInstance(typeof(ING), new object[] { ingParams.ToArray() }) as ING;
var ingCtorParams = ingParams.ToArray();
ING ingInstance = Activator.CreateInstance(typeof(ING), ingCtorParams) as ING;
//ING ingInstance = Activator.CreateInstance(typeof(ING), ingParams) as ING;
//IBank ing = new ING(dependecyInjectionContainer[typeof(IINGExchangeRate)] as IINGExchangeRate);
IBank ing = Activator.CreateInstance(typeof(ING), ingCtorParams) as ING;
IBank bt = new BT(dependecyInjectionContainer[typeof(IBTExchangeRate)] as IBTExchangeRate);
IBank ab = new AB(dependecyInjectionContainer[typeof(IABExchangeRate)] as IABExchangeRate);
IBank bcr = new BCR(dependecyInjectionContainer[typeof(IBCRExchangeRate)] as IBCRExchangeRate);
Console.WriteLine($"ING converts 100 EUR into {ing.ExchangeInRON(100)}");
Console.WriteLine($"BT converts 100 EUR into {bt.ExchangeInRON(100)}");
Console.WriteLine($"AB converts 100 EUR into {ab.ExchangeInRON(100)}");
Console.WriteLine($"BCR converts 100 EUR into {bcr.ExchangeInRON(100)}");
Console.ReadKey();
}
protected override void RegisterDependencies(IServiceCollection collection)
{
collection.AddSingleton <IPaymentTransactionQuery, InMemoryPaymentTransactionQuery>();
collection.AddTransient(IoC =>
{
ObjectCache objectCache = Substitute.For <ObjectCache>();
objectCache
.Get(ValidTransactionId, Arg.Any <string>())
.Returns(new PaymentTransaction(new Card("4916690086480301", 12, 2022), 19.99m, DateTime.Now, true));
objectCache
.Get(InvalidTransactionId, Arg.Any <string>())
.Returns(null);
return(objectCache);
});
collection.AddTransient <IPaymentValidator, PaymentValidator>();
collection.AddTransient <IPaymentService, PaymentService>();
collection.AddTransient <IBank>(_ =>
{
IBank bank = Substitute.For <IBank>();
bank.CreatePayment(Arg.Any <Payment>()).Returns(Task.FromResult(new ProcessedPayment()
{
success = true
}));
return(bank);
});
}
static public bool setUp(IBank bank, bool withClean, String server)
{
String databaseName = bank.getName().Replace(" ", String.Empty);
try
{
String connectionString = String.Format(connectionTemplate, server, databaseName);
using (SqlConnection sqlConnection = new SqlConnection(connectionString))
{
sqlConnection.Open();
validateConnection(sqlConnection);
validateDatabase(sqlConnection, bank.getTableList());
if (withClean)
{
clearDatabase(sqlConnection, bank.getTableList());
}
savedConfigurations.Add(bank.getName(), connectionString);
}
}
catch (Exception e)
{
Console.WriteLine("Error in database connection: Closing program");
Console.ReadKey();
System.Environment.Exit(1);
}
return(true);
}
public void AskCredit_Success()
{
IClientManager clientManager = new ClientManager();
FinanceManager financeManager = new FinanceManager(clientManager, new EmailSenderMock());
ShoppingClient.Clients.Clear();
clientManager.RegisterUser("Marko", "Sinisic", "*****@*****.**", "markos123", "Novi Sad", new DateTime(1990, 5, 25), new List <IAccount>());
IClient client = ShoppingClient.Clients[0];
financeManager.CreateAccount("f231rf34f34f3f4", new Bank(), 10000, 0, true);
IAccount account = FinantialDB.Accounts.Values.ToList()[0];
client.ListOfAccounts.Add(account);
financeManager.CreateBank("Raiffeisen", "Cara Lazara 55", new List <ICredit>(), "din", new List <IAccount>()
{
account
}, 1000, 100000, 100);
IBank bank = FinantialDB.Banks.Values.ToList()[0];
financeManager.CreateCredit("kredit", 0.05, FinantialDB.Currency["EUR"], bank, 10);
ICredit credit = FinantialDB.Credits.Values.ToList()[0];
bank.ListOfCredits.Add(credit);
financeManager.AskCredit(client.ID, credit.ID, 20, 50000);
Assert.IsTrue(account.CreditPayment > 0);
}
protected override void DoValidate(IBank bank)
{
if (!Payload.Contains("Aroyan"))
{
m_ValidationExceptions.Add(new ParcelValidationException("Aroyan must be present"));
}
}
private static async Task RateRBA(string Currency, DateTime date)
{
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.RBA);
IBankResult result = await ibank.GetRateAsync(Currency, date);
PrintReSult(Currency, result);
}
/// <summary>
/// Returns true if timbre should be copied.
/// </summary>
/// <param name="timbre"></param>
/// <param name="usedProgramBank"></param>
/// <param name="usedProgram"></param>
/// <returns></returns>
private bool ShouldTimbreBeCopied(ITimbre timbre, IBank usedProgramBank, IProgram usedProgram)
{
// Only copy programs which are audible.
var copy = !timbre.GetParam(ParameterNames.TimbreParameterName.Status).ToString().Equals("Off");
// Only copy programs which have a valid reference.
copy &= (usedProgram != null);
copy &= (usedProgramBank != null);
if (copy)
{
// Skip GM programs (those are always present on the synth.
copy &= (usedProgramBank.Type != BankType.EType.Gm);
}
if (copy)
{
// Copy only filled programs.
copy &= !usedProgram.IsEmptyOrInit;
// Copy only programs which are loaded in the file, or otherwise from the master file if configured
// to be used and also set.
copy &= (usedProgramBank.IsLoaded ||
(Settings.Default.CopyPaste_CopyPatchesFromMasterFile && usedProgram.IsFromMasterFile));
}
return(copy);
}
public void Register(IBank bank)
{
if (!Banks.ContainsValue(bank))
{
Banks[bank.BankId] = bank;
}
bank.BankNetwork = this;
}
public BuyResourceCommand(IPlayer player, IBank bank, MaterialType buy, MaterialType offer)
{
if (player == null)
throw new ArgumentNullException(nameof(player));
if (bank == null)
throw new ArgumentNullException(nameof(bank));
if (buy == offer)
throw new ArgumentException("Buy and Offer material cant be same type");
Player = player;
this.bank = bank;
this.buy = buy;
this.offer = offer;
}
public CounterAccount(string number, string accountName, IBank bank, string bankName, Address bankAddress,
IManagementCompany managementCompany, bool isPublic, Address beneficiaryAddress, bool ByPassValidation)
{
this.Number = number;
this.AccountName = accountName;
this.Bank = bank;
this.BankName = bankName;
this.BankAddress = bankAddress;
this.ManagementCompany = managementCompany;
this.IsPublic = isPublic;
this.BeneficiaryAddress = beneficiaryAddress;
if (!ByPassValidation && !IsValid)
throw new ApplicationException("This Counter Account is not valid.");
}
public Game(ISet<IPlayer> players, ITurnProvider provider, IBank bank)
{
if (players == null)
throw new ArgumentNullException(nameof(players));
if (provider == null)
throw new ArgumentNullException(nameof(provider));
if (bank == null)
throw new ArgumentNullException(nameof(bank));
if (players.Count < 2 || players.Count > 4)
throw new ArgumentException("Number of players should be between 2 and 4");
this.players = players;
this.provider = provider;
this.bank = bank;
}
public ConsolePlayer(string name, IConsole instance, IBank bank)
: this(name, new Hand(), instance, bank)
{
}
private static Mock<BettingPlayer> CreateMockPlayer(IHand hand = null, IBank bank = null)
{
return new Mock<BettingPlayer>("TEST", hand ?? new Hand(), bank ?? new Bank(1)) { CallBase = true };
}
public ProxyBank(Client client)
{
this.client = client;
BankOfWayne = new Bank();
}
private ConsolePlayer(string name, IHand hand, IConsole console, IBank bank)
: base(name, hand, bank)
{
_console = console;
RegisterPlayerListeners(console);
}
protected BettingPlayer(string name, IHand hand, IBank bank)
: base(name, hand)
{
Bank = bank;
}
public CounterAccount(string number, string accountName, IBank bank, string bankName, Address bankAddress,
IManagementCompany managementCompany, bool isPublic, Address beneficiaryAddress)
: this(number, accountName, bank, bankName, bankAddress, managementCompany, isPublic, beneficiaryAddress, false)
{
}
/// <summary> /// Override to perform parcel/payload validation after modification. Add validation exceptions into m_ValidationExceptions field. /// Use bank for cross-checks (i.e. may run queries to check consistency) /// </summary> protected abstract void DoValidate(IBank bank);
public Money Reduce(IBank bank, string to)
{
var rate = bank.GetRate(Currency, to);
return new Money(amount / rate, to);
}
/// <summary>
/// Performs validation of the data. Does not throw but populates validation exceptions if data is not valid.
/// Bank context may be used to run sub-queries during consistency/crosschecks
/// May call this method on parcels in either Creating or Modifying states
/// </summary>
public void Validate(IBank bank)
{
if (m_State!= ParcelState.Creating && m_State!=ParcelState.Modifying)
throw new DistributedDataAccessException(StringConsts.DISTRIBUTED_DATA_PARCEL_INVALID_OPERATION_ERROR.Args("Validate", GetType().FullName, m_State) );
m_ValidationExceptions = new List<Exception>();
DoValidate(bank);
}
/// <summary>
/// Override to seal the parcel instance, i.e. generate some calculated fields.
/// The version information is already generated by the time this method is called
/// </summary>
protected virtual void DoSeal(IBank bank)
{
}
/// <summary>
/// Seal parcel after modification
/// May call this method on parcels in either Creating or Modifying states.
/// Bank is used to create the ReplicationVersionInfo which is depends on store/bank implementation.
/// Parcels can replicate only within stores/technologies that have sealed them
/// </summary>
public void Seal(IBank bank)
{
if (bank==null)
throw new DistributedDataAccessException(StringConsts.ARGUMENT_ERROR+"Parcel.Seal(bank==null)");
if (m_State!= ParcelState.Creating && m_State!=ParcelState.Modifying)
throw new DistributedDataAccessException(StringConsts.DISTRIBUTED_DATA_PARCEL_INVALID_OPERATION_ERROR.Args("Seal", GetType().FullName, m_State) );
Validate(bank);
if (ValidationExceptions.Any())
throw ParcelSealValidationException.ForErrors(GetType().FullName, ValidationExceptions);
m_ReplicationVersionInfo = bank.GenerateReplicationVersionInfo(this);
DoSeal(bank);
m_State = ParcelState.Sealed;
m_NewlySealed = true;
}
public static void AddAccount(IBank localBank, IInputOutput io)
{
throw new NotImplementedException();
}
public static void Balance(IBank localBank, IInputOutput io)
{
throw new NotImplementedException();
}
public static void Withdrawal(IBank localBank, IInputOutput io, ITransactionFactory transactionFactory)
{
throw new NotImplementedException();
}
public BankAccount(string accountId, ILogging logging, IBank bank)
{
m_logging = logging;
m_bank = bank;
AccountId = accountId;
}
public void CantConstructWithNullParameter(IPlayer player, IBank bank)
{
Assert.Throws<ArgumentNullException>(() => new BuyResourceCommand(player, bank, MaterialType.Grain, MaterialType.Wool));
}
public Money Reduce(IBank bank, string to)
{
return new Money(Augend.Reduce(bank, to).amount + Addend.Reduce(bank, to).amount, to);
}
