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);
}
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 static void SynchronizeAtBankLevelInterlocked()
{
var tasks = new List <Task>();
var number = new Random();
var bank = new BankFactory().Build(BankType.InterlockedBank);
tasks.Add(Task.Factory.StartNew(() =>
{
for (int j = 0; j < 1000; j++)
{
bank.Deposit(1);
Console.WriteLine($"Task: {Task.CurrentId} is depositing 1 buck.");
}
}));
tasks.Add(Task.Factory.StartNew(() =>
{
for (int j = 0; j < 1000; j++)
{
bank.Withdraw(1);
Console.WriteLine($"Task: {Task.CurrentId} is withdrawing 1 buck.");
}
}));
Task.WaitAll(tasks.ToArray());
Console.WriteLine($"Final balance: {bank.Balance}");
}
public async Task RBA_GetRateAsyncShoudReturn()
{
DateTime date = new DateTime(2018, 1, 17);
#region Arrange
IBankResult expected = new BankResult()
{
BankName = "Reserve Bank of Australia",
HomeCurrency = "AUD",
ExchangeRate = 1.2571M,
RateDate = date
};
#endregion
#region Act
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.RBA);
IBankResult actual = await ibank.GetRateAsync("USD", date);
#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 IActionResult Edit(int id,
[Bind("AccountNumber,AccountType,EmailAddress")] Account account)
{
if (id != account.AccountNumber)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
BankFactory.EditAccount(account);
}
catch (DbUpdateConcurrencyException)
{
if (BankFactory.AccountExists(account.AccountNumber))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(account));
}
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
}
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);
}
private static async Task RateBOE(string Currency, DateTime date)
{
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.BOE);
IBankResult result = await ibank.GetRateAsync(Currency, date);
result.ExchangeRate = Decimal.Round((1 / result.ExchangeRate), 4);
PrintReSult(Currency, result);
}
private static void SynchronizeAtTaskLevelSpinLock()
{
var tasks = new List <Task>();
var number = new Random();
var bank = new BankFactory().Build(BankType.Unsafe); // <== !
var spinLock = new SpinLock();
tasks.Add(Task.Factory.StartNew(() =>
{
for (int j = 0; j < 1000; j++)
{
bool lockTaken = false;
try
{
spinLock.Enter(ref lockTaken);
bank.Deposit(1);
}
finally
{
if (lockTaken)
{
spinLock.Exit();
}
}
Thread.Sleep(number.Next(100));
Console.WriteLine($"Task: {Task.CurrentId} is depositing 1 buck.");
}
}));
tasks.Add(Task.Factory.StartNew(() =>
{
for (int j = 0; j < 1000; j++)
{
bool lockTaken = false;
try
{
spinLock.Enter(ref lockTaken);
bank.Withdraw(1);
}
finally
{
if (lockTaken)
{
spinLock.Exit();
}
}
Thread.Sleep(number.Next(100));
Console.WriteLine($"Task: {Task.CurrentId} is withdrawing 1 buck.");
}
}));
Task.WaitAll(tasks.ToArray());
Console.WriteLine($"Final balance: {bank.Balance}");
}
public IActionResult Create
([Bind("AccountType,EmailAddress")] Account account)
{
if (ModelState.IsValid)
{
BankFactory.CreateAccount(account.EmailAddress, account.AccountType);
return(RedirectToAction(nameof(Index)));
}
return(View(account));
}
public async Task AddBankWithoutNameShouldGiveError()
{
var repo = await GetRepository <Bank>();
var bank = new BankFactory().WithName().Build();
Func <Task> add = async() => {
await repo.AddAsync(bank, default);
};
add.Should().Throw <ValidationException>();
}
public void CreatingBankWithSameNameGetsSameBank()
{
_bank.CreateAccount(1);
_bank.CreateAccount(2);
var accounts = _bank.GetAccounts();
Assert.AreEqual(2, accounts.Count);
var bankDuplicate = BankFactory.GetBank("DNB");
accounts = bankDuplicate.GetAccounts();
Assert.AreEqual(2, accounts.Count);
}
private IPaymentGatewayService GetGatewayService(Card card)
{
IPaymentGatewayService PaymentGatewayService = null;
string cardbranc = card.CardBrand;
CardTypeEnum cardType = (CardTypeEnum)card.CardType;
if (cardType == CardTypeEnum.Credit)
{
PaymentGatewayService = BankFactory.GetPaymentGateway(BankFactory.BANCO_X);
}
return(PaymentGatewayService);
}
DV_10132020_EN_INTERFACES.BankResult IForeignExchangeApi.GetEcbRate(string currency, DateTime date)
{
var ECB = BankFactory.GetBank(BankFactory.SupportedBanks.ECB);
IBankResult EcbResult = ECB.GetRateAsync(currency, date).Result;
DV_10132020_EN_INTERFACES.BankResult result = new DV_10132020_EN_INTERFACES.BankResult();
result.BankName = EcbResult.BankName;
result.ExchangeRate = EcbResult.ExchangeRate;
result.RateDate = EcbResult.RateDate;
result.HomeCurrency = EcbResult.HomeCurrency;
return(result);
}
public DV_10132020_EN_INTERFACES.BankResult GetBOCRate(string currency, DateTime date)
{
var BOC = BankFactory.GetBank(BankFactory.SupportedBanks.BOC);
IBankResult BocResult = BOC.GetRateAsync(currency, date).Result;
DV_10132020_EN_INTERFACES.BankResult result = new DV_10132020_EN_INTERFACES.BankResult();
result.BankName = BocResult.BankName;
result.ExchangeRate = BocResult.ExchangeRate;
result.RateDate = BocResult.RateDate;
result.HomeCurrency = BocResult.HomeCurrency;
return(result);
}
// GET: Accounts/Edit/5
public IActionResult Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var account = BankFactory.GetAccountDetails(id.Value);
if (account == null)
{
return(NotFound());
}
return(View(account));
}
public BankResult Validate(PrevalidateExpenseReportLineDataContract request)
{
//Call: [APP]/0/rest/PrevalidateExpenseReportLine/Validate
userConnection = UserConnection ?? SystemUserConnection;
IBank Bank = BankFactory.GetBank(BankFactory.SupportedBanks.BOC);
BankResult result = new BankResult();
string shortCurrency = FindValueById <string>("Currency", request.CurrencyId, "ShortName");
System.Threading.Tasks.Task.Run(async() =>
{
IBankResult response = await Bank.GetRateAsync(shortCurrency, request.TransactionDate);
result = (BankResult)response;
}).Wait();
return(result);
}
public async Task GetBankShouldIncludeAccountsByDefault()
{
var repo = await GetRepository <Bank>();
var bank = new BankFactory().WithName("Test Bank").Build();
var addedBank = await repo.AddAsync(bank, default);
var acc = new AccountFactory().WithDefaultValues().Build();
addedBank.AddAccount(acc);
await repo.UpdateAsync(bank, default);
var rBank = await repo.GetByIdAsync(addedBank.Id, default);
rBank.Accounts.Should().NotBeEmpty();
}
static void Main(string[] args)
{
string testDataFolderPath = @"C:\ProjectsRepos\CsvProcessor\CsvProcessorClient\TestData\";
// initialise writer classes
CsvHelper <Account> csvAccount = new CsvHelper <Account>(testDataFolderPath + AccountFactory.FileName);
CsvHelper <Bank> csvBank = new CsvHelper <Bank>(testDataFolderPath + BankFactory.FileName);
CsvHelper <Transaction> csvTransaction = new CsvHelper <Transaction>(testDataFolderPath + TransactionFactory.FileName);
// test the save functionality
csvAccount.WriteToFile(AccountFactory.GetAccounts());
csvBank.WriteToFile(BankFactory.GetBanks());
csvTransaction.WriteToFile(TransactionFactory.GetTransactions());
// test the read functionality
List <Account> csvReadAccounts = csvAccount.ReadFromFile().ToList();
Console.WriteLine("Accounts");
foreach (Account acc in csvReadAccounts)
{
Console.WriteLine(acc.ConvertToCsv());
}
List <Bank> csvReadBank = csvBank.ReadFromFile().ToList();
Console.WriteLine("Banks");
foreach (Bank bank in csvReadBank)
{
Console.WriteLine(bank.ConvertToCsv());
}
List <Transaction> csvReadTransaction = csvTransaction.ReadFromFile().ToList();
Console.WriteLine("Transactions");
foreach (Transaction tran in csvReadTransaction)
{
Console.WriteLine(tran.ConvertToCsv());
}
Console.ReadLine();
}
public override void OnSaved(object sender, EntityAfterEventArgs e)
{
base.OnSaved(sender, e);
Entity entity = (Entity)sender;
userConnection = entity.UserConnection;
string[] ObservableColumns = { "AmountHC", "AmountFC", "Currency" };
bool isChangeInteresting = false;
foreach (EntityColumnValue mc in e.ModifiedColumnValues)
{
if (Array.IndexOf(ObservableColumns, mc.Column.Name) > -1)
{
isChangeInteresting = true;
}
}
if (!isChangeInteresting)
{
return;
}
Guid currencyId = entity.GetTypedColumnValue <Guid>("CurrencyId");
string currencyName = GetCurrencyName(currencyId);
IBank bank = BankFactory.GetBank(BankFactory.SupportedBanks.BOC);
IBankResult bankResult = Task.Run(() => bank.GetRateAsync(currencyName, DateTime.Today)).Result;
decimal rate = bankResult.ExchangeRate;
decimal amountFC = entity.GetTypedColumnValue <decimal>("AmountFC");
decimal amountHC = rate * amountFC;
entity.SetColumnValue("AmountHC", amountHC);
entity.Save();
Guid expenseReportId = entity.GetTypedColumnValue <Guid>("ExpenseReportId");
UpdateExpenseReport(entity.UserConnection, expenseReportId);
MsgChannelUtilities.PostMessage(userConnection, GetType().Name, "UpdatedExpenseReportLine");
}
public async void AddAccountUsingBankShouldNotTrow()
{
var bank = new BankFactory().WithName("Test Name Bank").Build();
var repoBank = await GetRepository <Bank>();
bank = await repoBank.AddAsync(bank, default);
var acc = new AccountFactory().WithName("Check account").WithNumber("910-5").Build();
bank.AddAccount(acc);
Func <Task> update = async() => {
await repoBank.UpdateAsync(bank, default);
};
update.Should().NotThrow();
acc.Bank.Should().Be(bank);
acc.BankId.Should().Be(bank.Id);
acc.Bank.Name.Should().Be(bank.Name);
}
public void BOC_ShoudThrowDate()
{
#region Arrange
DateTime date = new DateTime(2017, 1, 2);
string expectedMessage = @"Date must be greater than 03-Jan-2017 (Parameter 'date')";
#endregion
#region Act
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.BOC);
#endregion
#region Assert
var exception = Record.ExceptionAsync(
async() => await ibank.GetRateAsync("USD", date));
exception.Wait();
Assert.IsType <ArgumentOutOfRangeException>(exception.Result);
Assert.Equal("date", ((ArgumentException)exception.Result).ParamName);
Assert.Equal(exception.Result.Message, expectedMessage);
#endregion
}
public async Task CBR_ShoudThrowDate()
{
#region Arrange
DateTime date = new DateTime(1992, 6, 1);
string expectedMessage = @"Date must be greater than 03-Jan-2017 (Parameter 'date')";
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.BOC);
#endregion
#region Act
var exception = Record.ExceptionAsync(
async() => await ibank.GetRateAsync("USD", date));
exception.Wait();
#endregion
#region Assert
Assert.Equal(expectedMessage, exception.Result.Message);
Assert.IsType <ArgumentOutOfRangeException>(exception.Result);
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(
async() => await ibank.GetRateAsync("USD", date));
#endregion
}
public async Task CBR_ShoudThrowCurrency()
{
#region Arrange
DateTime date = new DateTime(2020, 1, 8);
string expectedMessage = $"Central bank of the Russian Federation does not support XXX";
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.CBR);
#endregion
#region Act
var exception = Record.ExceptionAsync(
async() => await ibank.GetRateAsync("XXX", date));
exception.Wait();
#endregion
#region Assert
Assert.Equal(expectedMessage, exception.Result.Message);
Assert.IsType <NotImplementedException>(exception.Result);
await Assert.ThrowsAsync <NotImplementedException>(
async() => await ibank.GetRateAsync("XXX", date));
#endregion
}
public async Task RBA_ShoudThrowDate()
{
#region Arrange
DateTime date = new DateTime(2017, 1, 8);
string expectedMessage = @"Date must be greater than 01-Jan-2018";
#endregion
#region Act
IBank ibank = BankFactory.GetBank(BankFactory.SupportedBanks.RBA);
#endregion
#region Assert
var exception = Record.ExceptionAsync(
async() => await ibank.GetRateAsync("KRW", date));
exception.Wait();
Assert.Equal(exception.Result.Message, expectedMessage);
Assert.IsType <NotImplementedException>(exception.Result);
await Assert.ThrowsAsync <NotImplementedException>(
async() => await ibank.GetRateAsync("KRW", date));
#endregion
}
public void Initialize()
{
_bazaar = new Bazaar();
_bank = BankFactory.GetBank("DnB");
}
public void SetUp()
{
_bank = BankFactory.GetBank("DNB");
}
public void Setup()
{
factory = new BankFactory();
}
public IActionResult DeleteConfirmed(int id)
{
BankFactory.DeleteAccount(id);
return(RedirectToAction(nameof(Index)));
}
// GET: Accounts
public IActionResult Index()
{
return(View(BankFactory.GetAllAccounts(HttpContext.User.Identity.Name)));
}
