public void CustomerData()
{
var dataFixture = new DataFixture();
dataFixture.Fixture().ConfigureAwait(false).GetAwaiter().GetResult();
// Initialize the list of objects and save them into database table.
string filePath = "\\Data\\customers.json";
var customersDTO = IOHelpers.ReadFromFile <Customer, CustomerDTO>(filePath, true);
var repositoryCustomer = new RepositoryCustomer();
var customers = IOHelpers.EntitiesList <Customer, CustomerDTO>(customersDTO, repositoryCustomer.BusinessToDomainObjectPropertyMap());
var customersNew = new List <Customer>();
using (var dbContext = new BankAccountContext())
{
var repository = new RepositoryBaseEF <Customer>(dbContext);
customersNew = repository.Get();
}
dataFixture.Dispose().ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(customersNew);
var count = customers.Count;
Assert.Equal(customers[count - 1].BirthDate, customersNew[count - 1].BirthDate);
}
public bool ammountcheck(int acc_id, decimal amount, int type)
{
BankAccountContext DbContext1 = new BankAccountContext();
BankAccount tempbankaccount = DbContext1.BankAccounts.Find(acc_id);
if (type == 0)
{
if (tempbankaccount.balance > amount)
{
tempbankaccount.balance -= amount;
DbContext1.Entry(tempbankaccount).State = EntityState.Modified;
DbContext1.SaveChanges();
return(true);
}
else
{
return(false);
}
}
else
{
tempbankaccount.balance += amount;
DbContext1.Entry(tempbankaccount).State = EntityState.Modified;
DbContext1.SaveChanges();
return(true);
}
}
/// <summary>
/// Read the list of objects from a file.
/// </summary>
public static List <T2> ReadFromFile <T1, T2>(string filePath, bool inputData = false)
where T1 : EntityBase
where T2 : EntityBase
{
using (var dbContext = new BankAccountContext())
{
var repository = new RepositoryBaseEF <T1>(dbContext);
string json = string.Empty;
if (repository.Get().Count <= 0 || inputData)
{
// Get the current WORKING directory (i.e. \bin\Debug)
string workingDirectory = Directory.GetCurrentDirectory();
// Get the current PROJECT directory
string projectDirectory = Directory.GetParent(workingDirectory).Parent.Parent.FullName;
filePath = projectDirectory + filePath;
json = File.ReadAllText(filePath);
}
return(json == string.Empty ? new List <T2>() : Newtonsoft.Json.JsonConvert.DeserializeObject <List <T2> >(json));
}
}
public void AccountData()
{
var dataFixture = new DataFixture();
dataFixture.Fixture().ConfigureAwait(false).GetAwaiter().GetResult();
// Initialize the list of objects and save them into database table.
var filePath = "\\Data\\accounts.json";
var accountsDTO = IOHelpers.ReadFromFile <Account, AccountDTO>(filePath, true);
var repositoryAccount = new RepositoryAccount();
var accounts = IOHelpers.EntitiesList <Account, AccountDTO>(accountsDTO, repositoryAccount.BusinessToDomainObjectPropertyMap());
var accountsNew = new List <Account>();
using (var dbContext = new BankAccountContext())
{
var repository = new RepositoryBaseEF <Account>(dbContext);
accountsNew = repository.Get();
}
dataFixture.Dispose().ConfigureAwait(false).GetAwaiter().GetResult();
Assert.NotNull(accountsNew);
var count = accounts.Count;
Assert.Equal(accounts[count - 1].AccountNo, accountsNew[count - 1].AccountNo);
}
public void Play_UseCase_TransferFunds()
{
var accountContext = new BankAccountContext(
_accountsRegistry, checkingAccount.Id, savingsAccount.Id);
accountContext.TransferFunds(70);
checkingAccount.Balance.Should().Be(30);
savingsAccount.Balance.Should().Be(70);
}
public static void SeedDatabase(BankAccountContext context)
{
context.Database.Migrate();
context.BankAccounts.AddRange(
new Model.BankAccount {
Balance = 150, CustomerRef = "Ref 1", BankAccountId = new Guid(), Transaction = new List <Model.Transaction> {
new Model.Transaction(300, 100, "ref1", DateTime.Now)
{
Date = DateTime.Now, Reference = "ref1", Deposit = 300, Withdrawal = 100
}
}
},
new Model.BankAccount {
Balance = 150, CustomerRef = "Ref 2", BankAccountId = new Guid(), Transaction = new List <Model.Transaction> {
new Model.Transaction(300, 100, "ref2", DateTime.Now)
{
Date = DateTime.Now, Reference = "ref2", Deposit = 300, Withdrawal = 100
}
}
},
new Model.BankAccount {
Balance = 150, CustomerRef = "Ref 3", BankAccountId = new Guid(), Transaction = new List <Model.Transaction> {
new Model.Transaction(300, 100, "ref3", DateTime.Now)
{
Date = DateTime.Now, Reference = "ref3", Deposit = 300, Withdrawal = 100
}
}
},
new Model.BankAccount {
Balance = 150, CustomerRef = "Ref 4", BankAccountId = new Guid(), Transaction = new List <Model.Transaction> {
new Model.Transaction(300, 100, "ref4", DateTime.Now)
{
Date = DateTime.Now, Reference = "ref4", Deposit = 300, Withdrawal = 100
}
}
},
new Model.BankAccount {
Balance = 150, CustomerRef = "Ref 5", BankAccountId = new Guid(), Transaction = new List <Model.Transaction> {
new Model.Transaction(300, 100, "ref5", DateTime.Now)
{
Date = DateTime.Now, Reference = "ref5", Deposit = 300, Withdrawal = 100
}
}
},
new Model.BankAccount {
Balance = 150, CustomerRef = "Ref 6", BankAccountId = new Guid(), Transaction = new List <Model.Transaction> {
new Model.Transaction(300, 100, "ref6", DateTime.Now)
{
Date = DateTime.Now, Reference = "ref6", Deposit = 300, Withdrawal = 100
}
}
}
);
context.SaveChanges();
}
public BankAccountRepository()
{
try
{
var context = new BankAccountContext();
context.Database.Migrate(); // apply all migrations
}
catch (Exception ex)
{
}
}
/// <summary>
/// Update the list of phones with the customer Ids.
/// </summary>
/// <param name="phones">The phones to be inserted.</param>
/// <param name="phonesDTO">The phonesDTO to be inserted.</param>
/// <param name="customersDTO">The customersDTO to be inserted.</param>
public void UpdateCustomerIds(List <CustomerDTO> customersDTO, List <PhoneNumber> phones, List <PhoneNumberDTO> phonesDTO)
{
if (phones == null)
{
throw new ArgumentNullException("The phones can not be null.");
}
if (phonesDTO == null)
{
throw new ArgumentNullException("The phonesDTO can not be null.");
}
if (customersDTO == null)
{
throw new ArgumentNullException("The customersDTO can not be null.");
}
try
{
var customers = new List <Customer>();
using (var dbContext = new BankAccountContext())
{
var repositoryCustomer = new Repositories.RepositoryBaseEF <Customer>(dbContext);
customers = repositoryCustomer.Get();
if (customers.Count <= 0)
{
throw new ArgumentNullException("The customers can not be null.");
}
}
for (int j = 0; j < phonesDTO.Count; j++)
{
for (int i = 0; i < customers.Count; i++)
{
if (phonesDTO[j].CustomerNo.Equals(customersDTO[i].CustomerNo))
{
phones[j].CustomerId = customers[i].Id;
break;
}
}
}
}
catch (ArgumentNullException ex)
{
Console.WriteLine(ex.Message);
}
}
private static void Main(string[] args)
{
using (var context = new BankAccountContext())
{
IAccountService accountService = new BankAccountService(context);
accountService.OpenAccount(new User("123", "123"), AccountType.Platinum, out int id);
Console.WriteLine(accountService.Info(id));
accountService.Deposite(id, 1000);
Console.WriteLine(accountService.Info(id));
accountService.Withdraw(id, 10);
Console.WriteLine(accountService.Info(id));
accountService.CloseAccount(id);
Console.WriteLine(accountService.Info(id));
}
}
/// <summary>
/// Validate customer of an account.
/// </summary>
public static async Task <bool> CustomerValidation(int accountId, int customerId, string accountNo)
{
using (var dbContext = new BankAccountContext())
{
var repositoryCustomer = new RepositoryBaseEF <Customer>(dbContext);
var customer = await repositoryCustomer.FindById(customerId).ConfigureAwait(false);
var repositoryAccount = new RepositoryBaseEF <Account>(dbContext);
if (repositoryAccount.Get().Any(a => a.Id == accountId))
{
return(true);
}
var message = string.Format("Customer ID: {0}, You do not allow to withdraw money from Account No.: {1}", customer.CustomerNo, accountNo);
Console.WriteLine(message);
return(false);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
IHostingEnvironment env,
BankAccountContext dbContext)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
dbContext.Database.EnsureCreated();
}
else
{
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseMvc();
}
/// <summary>
/// Delete all data from the database tables.
/// </summary>
public static async Task DeleteData(CancellationToken cancellationToken = default)
{
try
{
using (var dbContext = new BankAccountContext())
{
var repositoryAccount = new Repositories.RepositoryBaseEF <Account>(dbContext);
var accounts = repositoryAccount.Get();
repositoryAccount.DeleteEntities(accounts);
await repositoryAccount.SaveAsync().ConfigureAwait(false);
var repositoryCustomer = new Repositories.RepositoryBaseEF <Customer>(dbContext);
var customers = repositoryCustomer.Get();
repositoryCustomer.DeleteEntities(customers);
await repositoryCustomer.SaveAsync().ConfigureAwait(false);
var repositoryCustomerAccount = new Repositories.RepositoryBaseEF <CustomerAccount>(dbContext);
var customerAccounts = repositoryCustomerAccount.Get();
repositoryCustomerAccount.DeleteEntities(customerAccounts);
await repositoryCustomerAccount.SaveAsync().ConfigureAwait(false);
var repositoryPhone = new Repositories.RepositoryBaseEF <PhoneNumber>(dbContext);
var phones = repositoryPhone.Get();
repositoryPhone.DeleteEntities(phones);
await repositoryPhone.SaveAsync().ConfigureAwait(false);
var repositoryTransaction = new Repositories.RepositoryBaseEF <Transaction>(dbContext);
var transactions = repositoryTransaction.Get();
repositoryTransaction.DeleteEntities(transactions);
await repositoryTransaction.SaveAsync().ConfigureAwait(false);
}
}
catch (DbException ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Initialize the list of objects and save them into database table and do the transactions process.
/// </summary>
public static async Task SaveDataAsync(CancellationToken cancellationToken = default)
{
try
{
// Initialize the list of objects and save them into database table.
string filePath = "\\Data\\customers.json";
var customersDTO = IOHelpers.ReadFromFile <Customer, CustomerDTO>(filePath);
var repositoryCustomer = new RepositoryCustomer();
var customers = IOHelpers.EntitiesList <Customer, CustomerDTO>(customersDTO, repositoryCustomer.BusinessToDomainObjectPropertyMap());
using (var dbContext = new BankAccountContext())
{
var repository = new RepositoryBaseEF <Customer>(dbContext);
await repository.CreateEntities(customers).ConfigureAwait(false);
await repository.SaveAsync().ConfigureAwait(false);
}
filePath = "\\Data\\accounts.json";
var accountsDTO = IOHelpers.ReadFromFile <Account, AccountDTO>(filePath);
var repositoryAccount = new RepositoryAccount();
var accounts = IOHelpers.EntitiesList <Account, AccountDTO>(accountsDTO, repositoryAccount.BusinessToDomainObjectPropertyMap());
using (var dbContext = new BankAccountContext())
{
var repository = new RepositoryBaseEF <Account>(dbContext);
await repository.CreateEntities(accounts).ConfigureAwait(false);
await repository.SaveAsync().ConfigureAwait(false);
}
if (accountsDTO.Count > 0)
{
await repositoryCustomer.CreateCustomerAccounts(accountsDTO);
}
filePath = "\\Data\\phones.json";
var phonesDTO = IOHelpers.ReadFromFile <PhoneNumber, PhoneNumberDTO>(filePath);
var repositoryPhone = new RepositoryPhone();
var phones = IOHelpers.EntitiesList <PhoneNumber, PhoneNumberDTO>(phonesDTO, repositoryPhone.BusinessToDomainObjectPropertyMap());
if (phonesDTO.Count > 0 && customersDTO.Count > 0)
{
repositoryPhone.UpdateCustomerIds(customersDTO, phones, phonesDTO);
}
using (var dbContext = new BankAccountContext())
{
var repository = new RepositoryBaseEF <PhoneNumber>(dbContext);
await repository.CreateEntities(phones).ConfigureAwait(false);
await repository.SaveAsync().ConfigureAwait(false);
}
}
catch (DbException ex)
{
Console.WriteLine(ex.Message);
}
catch (FileNotFoundException ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Update the list of transactions with the customer and account Ids.
/// </summary>
/// <param name="transactions">The transactions to be inserted.</param>
/// <param name="transactionDTOs">The transactionDTOs to be inserted.</param>
public async Task UpdateIds(List <Transaction> transactions, List <TransactionDTO> transactionDTOs)
{
if (transactions == null)
{
throw new ArgumentNullException("The transactions can not be null.");
}
if (transactionDTOs == null)
{
throw new ArgumentNullException("The transactionDTOs can not be null.");
}
try
{
var customers = new List <Customer>();
var accounts = new List <Account>();
var customerAccounts = new List <CustomerAccount>();
using (var dbContext = new BankAccountContext())
{
var repositoryCustomer = new Repositories.RepositoryBaseEF <Customer>(dbContext);
var repositoryAccount = new Repositories.RepositoryBaseEF <Account>(dbContext);
var repositoryCustomerAccount = new Repositories.RepositoryBaseEF <CustomerAccount>(dbContext);
customers = await Task.FromResult(repositoryCustomer.Get());
accounts = repositoryAccount.Get();
customerAccounts = repositoryCustomerAccount.Get();
}
if (accounts.Count <= 0)
{
throw new ArgumentNullException("The accounts can not be null.");
}
if (customers.Count <= 0)
{
throw new ArgumentNullException("The customers can not be null.");
}
if (customerAccounts.Count <= 0)
{
throw new ArgumentNullException("The customerAccounts can not be null.");
}
for (int j = 0; j < transactionDTOs.Count; j++)
{
for (int i = 0; i < customers.Count; i++)
{
if (transactionDTOs[j].CustomerNo.Equals(customers[i].CustomerNo))
{
transactions[j].CustomerId = customers[i].Id;
transactions[j].AccountId = -1;
if (customers[i].CustomerAccounts != null)
{
for (int k = 0; k < accounts.Count; k++)
{
if (transactionDTOs[j].AccountNo.Equals(accounts[k].AccountNo))
{
transactions[j].AccountId = accounts[k].Id;
break;
}
}
break;
}
}
}
}
}
catch (ArgumentNullException ex)
{
Console.WriteLine(ex.Message);
}
}
public HomeController(BankAccountContext context)
{
_context = context;
}
public AccountRepository(BankAccountContext context)
{
_context = context;
}
/// <summary>
/// Read the list of transactions from file and do them.
/// </summary>
public static async Task TransactionProcessAsync(CancellationToken cancellationToken = default)
{
try
{
string filePath = "\\Data\\transactions.json";
var transactionsDTO = IOHelpers.ReadFromFile <Transaction, TransactionDTO>(filePath);
var repositoryTransaction = new RepositoryTransaction();
var transactions = IOHelpers.EntitiesList <Transaction, TransactionDTO>(transactionsDTO, repositoryTransaction.BusinessToDomainObjectPropertyMap());
await repositoryTransaction.UpdateIds(transactions, transactionsDTO);
using (var dbContext = new BankAccountContext())
{
var repositoryAccountContext = new RepositoryBaseEF <Account>(dbContext);
for (int i = 0; i < transactions.Count; i++)
{
var transactionDone = false;
var account = await repositoryAccountContext.FindById(transactions[i].AccountId);
repositoryTransaction = new RepositoryTransaction(account);
var message = string.Empty;
message = string.Format("Ouput {0}:", (i + 1).ToString());
repositoryTransaction.report(message);
var validation = true;
if (transactions[i].TransactionType == Models.Enums.TransactionTypes.WithdrawCash ||
transactions[i].TransactionType == Models.Enums.TransactionTypes.WithdrawTrnasfer)
{
validation = await Validators.Validations.CustomerValidation(transactions[i].AccountId, transactions[i].CustomerId, transactionsDTO[i].AccountNo);
}
var accountDestination = new Account();
if (validation)
{
switch (transactions[i].TransactionType)
{
case Models.Enums.TransactionTypes.DepositCash:
repositoryTransaction.DepositCash(transactions[i]);
message = string.Format("Account Number: {0} Balance: ${1} CAD", account.AccountNo, account.Balance.ToString());
repositoryTransaction.report(message);
transactionDone = true;
break;
case Models.Enums.TransactionTypes.WithdrawCash:
message = repositoryTransaction.WithdrawCash(transactions[i]);
if (message.Equals(string.Empty))
{
message = string.Format("Account Number: {0} Balance: ${1} CAD", account.AccountNo, account.Balance.ToString());
repositoryTransaction.report(message);
transactionDone = true;
}
else
{
repositoryTransaction.report(message);
transactionDone = false;
}
break;
case Models.Enums.TransactionTypes.WithdrawTrnasfer:
foreach (Account ac in repositoryAccountContext.Get())
{
if (ac.AccountNo.Equals(transactions[i].TransactionAccountNo))
{
accountDestination = ac;
break;
}
}
message = repositoryTransaction.WithdrawTrnasfer(transactions[i], accountDestination);
if (message.Equals(string.Empty))
{
message = string.Format("Account Number: {0} Balance: ${1} CAD Account Number: {2} Balance: ${3} CAD",
account.AccountNo, account.Balance, accountDestination.AccountNo, accountDestination.Balance);
repositoryTransaction.report(message);
transactionDone = true;
}
else
{
repositoryTransaction.report(message);
transactionDone = false;
}
break;
}
}
if (transactionDone)
{
var repositoryTransactionContext = new RepositoryBaseEF <Transaction>(dbContext);
await repositoryTransactionContext.Create(transactions[i]).ConfigureAwait(false);
await repositoryTransactionContext.SaveAsync().ConfigureAwait(false);
await repositoryAccountContext.Update(account).ConfigureAwait(false);
await repositoryAccountContext.SaveAsync().ConfigureAwait(false);
if (accountDestination != null && transactions[i].TransactionType == Models.Enums.TransactionTypes.WithdrawTrnasfer)
{
await repositoryAccountContext.Update(accountDestination).ConfigureAwait(false);
await repositoryAccountContext.SaveAsync().ConfigureAwait(false);
}
}
}
}
}
catch (DbException ex)
{
Console.WriteLine(ex.Message);
}
catch (FileNotFoundException ex)
{
Console.WriteLine(ex.Message);
}
}
public TransactionController(BankAccountContext context)
{
_context = context;
}
/// <summary>
/// Read the list of objects from a file.
/// </summary>
public static async Task <Dictionary <string, decimal> > Transaction(string filePath)
{
var transactionsDTO = IOHelpers.ReadFromFile <Transaction, TransactionDTO>(filePath, true);
var repositoryTransaction = new RepositoryTransaction();
var transactions = IOHelpers.EntitiesList <Transaction, TransactionDTO>(transactionsDTO, repositoryTransaction.BusinessToDomainObjectPropertyMap());
await repositoryTransaction.UpdateIds(transactions, transactionsDTO);
Dictionary <string, decimal> balances = new Dictionary <string, decimal>();
using (var dbContext = new BankAccountContext())
{
var repositoryAccountContext = new RepositoryBaseEF <Account>(dbContext);
for (int i = 0; i < transactions.Count; i++)
{
var transactionDone = false;
var account = await repositoryAccountContext.FindById(transactions[i].AccountId);
repositoryTransaction = new RepositoryTransaction(account);
var message = string.Empty;
message = string.Format("Ouput {0}:", (i + 1).ToString());
repositoryTransaction.report(message);
var validation = true;
if (transactions[i].TransactionType == TransactionTypes.WithdrawCash ||
transactions[i].TransactionType == TransactionTypes.WithdrawTrnasfer)
{
validation = await Validators.Validations.CustomerValidation(transactions[i].AccountId, transactions[i].CustomerId, transactionsDTO[i].AccountNo);
}
var accountDestination = new Account();
if (validation)
{
switch (transactions[i].TransactionType)
{
case TransactionTypes.DepositCash:
repositoryTransaction.DepositCash(transactions[i]);
message = string.Format("Account Number: {0} Balance: ${1} CAD", account.AccountNo, account.Balance.ToString());
repositoryTransaction.report(message);
transactionDone = true;
break;
case TransactionTypes.WithdrawCash:
message = repositoryTransaction.WithdrawCash(transactions[i]);
if (message.Equals(string.Empty))
{
message = string.Format("Account Number: {0} Balance: ${1} CAD", account.AccountNo, account.Balance.ToString());
repositoryTransaction.report(message);
transactionDone = true;
}
else
{
repositoryTransaction.report(message);
transactionDone = false;
}
break;
case TransactionTypes.WithdrawTrnasfer:
foreach (Account ac in repositoryAccountContext.Get())
{
if (ac.AccountNo.Equals(transactions[i].TransactionAccountNo))
{
accountDestination = ac;
break;
}
}
message = repositoryTransaction.WithdrawTrnasfer(transactions[i], accountDestination);
if (message.Equals(string.Empty))
{
message = string.Format("Account Number: {0} Balance: ${1} CAD Account Number: {2} Balance: ${3} CAD",
account.AccountNo, account.Balance, accountDestination.AccountNo, accountDestination.Balance);
repositoryTransaction.report(message);
transactionDone = true;
}
else
{
repositoryTransaction.report(message);
transactionDone = false;
}
break;
}
}
if (transactionDone)
{
var repositoryTransactionContext = new RepositoryBaseEF <Transaction>(dbContext);
await repositoryTransactionContext.Create(transactions[i]).ConfigureAwait(false);
await repositoryTransactionContext.SaveAsync().ConfigureAwait(false);
await repositoryAccountContext.Update(account).ConfigureAwait(false);
await repositoryAccountContext.SaveAsync().ConfigureAwait(false);
if (accountDestination != null && transactions[i].TransactionType == TransactionTypes.WithdrawTrnasfer)
{
await repositoryAccountContext.Update(accountDestination).ConfigureAwait(false);
await repositoryAccountContext.SaveAsync().ConfigureAwait(false);
}
}
if (account != null && account.AccountNo != null && account.AccountNo != string.Empty)
{
var key = account.AccountNo;
if (balances.ContainsKey(key))
{
balances[key] = account.Balance;
}
else
{
balances.Add(key, account.Balance);
}
}
if (accountDestination != null && accountDestination.AccountNo != null && accountDestination.AccountNo != string.Empty)
{
var key = accountDestination.AccountNo;
if (balances.ContainsKey(key))
{
balances[key] = accountDestination.Balance;
}
else
{
balances.Add(key, accountDestination.Balance);
}
}
}
}
return(balances);
}
public TransactionRepository(BankAccountContext context)
{
_context = context;
}
/// <summary>
/// Initializes a new instance of the <see cref="BankAccountService"/> class.
/// </summary>
public BankAccountService(BankAccountContext context)
{
this.bankAccounts = new DbStorage(context);
}
public UsersController(BankAccountContext connect)
{
_dbConnector = connect;
}
/// <summary>
/// Insert a list of customrAccounts in the database table.
/// </summary>
/// <param name="accountsDTO">The accountsDTO to be inserted.</param>
public async Task CreateCustomerAccounts(List <AccountDTO> accountsDTO)
{
if (accountsDTO == null)
{
throw new ArgumentNullException("The accountsDTO can not be null.");
}
var accounts = new List <Account>();
var customers = new List <Customer>();
using (var dbContext = new BankAccountContext())
{
var repositoryAccount = new Repositories.RepositoryBaseEF <Account>(dbContext);
var repositoryCustomer = new Repositories.RepositoryBaseEF <Customer>(dbContext);
accounts = repositoryAccount.Get();
if (accounts.Count <= 0)
{
throw new ArgumentNullException("The accounts can not be null.");
}
customers = repositoryCustomer.Get();
if (customers.Count <= 0)
{
throw new ArgumentNullException("The customers can not be null.");
}
}
try
{
using (var dbContext = new BankAccountContext())
{
var repository = new RepositoryBaseEF <CustomerAccount>(dbContext);
var customerAccounts = new List <CustomerAccount>();
for (int j = 0; j < accountsDTO.Count; j++)
{
for (int i = 0; i < customers.Count; i++)
{
if (accountsDTO[j].CustomerNo.Equals(customers[i].CustomerNo))
{
var customerAccount = new CustomerAccount();
customerAccount.CustomerId = customers[i].Id;
customerAccount.AccountId = accounts[j].Id;
customerAccount.CreatedDate = DateTime.Now.ToString();
customerAccount.CreatedBy = "Aziz Azimi";
customerAccounts.Add(customerAccount);
break;
}
}
}
try
{
await repository.CreateEntities(customerAccounts);
await repository.SaveAsync();
}
catch (DbException ex)
{
Console.WriteLine(ex.Message);
}
}
}
catch (ArgumentNullException ex)
{
Console.WriteLine(ex.Message);
}
}
public DbStorage(BankAccountContext context)
{
this.context = context;
}
public BankRepository(BankAccountContext dbContext)
{
_dbContext = dbContext;
}
public BankAccountRepository(BankAccountContext context) => _context = context;
public UsersController(BankAccountContext context)
{
_context = context;
}
public ActionsController(BankAccountContext context)
{
_context = context;
}
/// <summary>
/// Initializes a new instance of the <see cref="RepositoryBase{Task}"/> class.
/// </summary>
public RepositoryBaseEF(BankAccountContext context)
{
_context = context;
}
public BankStatementRepository(BankAccountContext context)
{
_context = context;
}
public BankAccountEFRepository(string connectionString)
{
_bankAccountStorage = new BankAccountContext(connectionString);
}
