public void GetAccountsByCustomerSomeAccountsFound()
{
IAccountRepository accountRepository = new AccountRepository(NhibernateHelper.SessionFactory);
Repository repository = new Repository(NhibernateHelper.SessionFactory);
Customer thirdParty1 = new Customer { Code = "tjdsklfs", Email = "*****@*****.**", LastName = "roux", FirstName = "Olivier", Password = "******", PasswordSalt = "sss" };
Customer thirdParty2 = new Customer { Code = "topsecret", Email = "*****@*****.**", LastName = "roux2", FirstName = "Olivier", Password = "******", PasswordSalt = "sss" };
Account account1 = new Account { Balance = 201, BalanceDate = DateTime.Now, Number = "dsf1", Iban="12354"};
Account account2 = new Account { Balance = 202, BalanceDate = DateTime.Now, Number = "dsf2", Iban="12435"};
Role role = new Role{Id=1};
thirdParty1.RelatedAccounts.Add(account1, role);
thirdParty1.RelatedAccounts.Add(account2, role);
using (NhibernateHelper.SessionFactory.GetCurrentSession().BeginTransaction())
{
repository.Save(thirdParty1);
repository.Save(thirdParty2);
repository.Save(account1);
repository.Save(account2);
repository.Flush();
IList<Account> accounts = accountRepository.GetAccountsByCustomer(thirdParty1.Id);
Assert.AreEqual(2, accounts.Count);
}
}
public static Account Create(
int value_i,
decimal value_d,
DateTime? value_null,
string value_s,
IList<Operation> value_iList,
int value_i1,
bool value_b,
string value_s1,
string value_s2,
IList<TagDepenses> value_iList1_,
string value_s3,
DateTime? value_null1
)
{
//return DataHelper.GetAccounts().FirstOrDefault(x => x.Id == value_i);
//PexAssume.IsNotNullOrEmpty<Operation>(value_iList);
Account account = new Account();
account.Id = value_i;
account.Balance = value_d;
account.BalanceDate = value_null;
account.Number = value_s;
account.Operations = DataHelper.GetOperations();
account.NbOfDaysOverdraft = value_i1;
account.AuthorizeOverdraft = value_b;
account.Iban = value_s1;
account.Currency = value_s2;
account.TagDepenses = value_iList1_;
((BankingProduct)account).Name = value_s3;
((BankingProduct)account).CreationDate = value_null1;
return account;
}
public void Balance_CustomerOK()
{
//arrange
Account account = new Account();
Account account2 = new Account();
Customer customer = new Customer();
customer.RelatedAccounts.Add(account, new Role());
customer.RelatedAccounts.Add(account2, new Role());
IRepository repository = MockRepository.GenerateMock<IRepository>();
ICustomerRepository customerRepository = MockRepository.GenerateMock<ICustomerRepository>();
IAccountRepository accountRepository = MockRepository.GenerateMock<IAccountRepository>();
IDtoCreator<Customer, CustomerDto> custCreator = new CustomerDtoCreator();
IAccountServices accountServices = MockRepository.GenerateMock<IAccountServices>(); //(repository, accountRepository,customerRepository);
accountServices.Expect(x => x.Balance(account2)).Return(-10);
accountServices.Expect(x => x.Balance(account)).Return(-20);
//act
CustomerServices services = new CustomerServices(customerRepository, repository, accountServices, custCreator);
decimal balance = services.CustomerBalance(customer);
//assert
Assert.AreEqual(balance, -30);
accountServices.VerifyAllExpectations();
}
public void CreateAccount(String accountName, int customerID, int roleID)
{
Customer customer = _repository.Get<Customer>(customerID);
if (customer == null)
{
throw new AccountServicesException("No customer found for the ID: " + customerID);
}
Role role = _repository.Get<Role>(roleID);
if (role == null)
{
throw new AccountServicesException("No role found for the ID: " + roleID);
}
Account account = new Account();
account.Name = accountName;
customer.RelatedAccounts.Add(account, role);
account.RelatedCustomers.Add(customer, role);
using (TransactionScope scope = new TransactionScope())
{
_repository.Save<Account>(account);
_repository.SaveOrUpdate<Customer>(customer);
scope.Complete();
}
}
public Decimal Balance(Account account)
{
if (account.Operations != null)
{
return account.Operations.Sum(x => x.SignedAmount);
}
return 0;
}
public Permission GetCustomerRights(Account account, Customer customer)
{
if (customer.RelatedAccounts.ContainsKey(account))
{
Role role = customer.RelatedAccounts[account];
return role.Permission;
}
return 0;
}
public Permission GetAdvisorRights(Account account, Advisor advisor)
{
foreach (Customer customer in account.RelatedCustomers.Keys)
{
if(advisor.Customers.Contains(customer)){
return advisor.Role.Permission;
}
}
return 0;
}
public List<TagDepenses> AggregateAccountTags(Account account)
{
//excluding null tags - this should never happen
//while when new transactions is created, the tag is set to a new empty tag.
var grouped = account.Operations.Where(x => x.SignedAmount < 0 && x.Tag!=null).GroupBy(x => x.Tag);
var dict = grouped.ToDictionary(x => x.Key, y => y.Sum(x => x.SignedAmount));
List<TagDepenses> depenses = dict.Select(x => new TagDepenses() { Tag = x.Key, Depenses = Math.Abs(x.Value) }).ToList();
return depenses;
}
public decimal Balance(Account account)
{
SIRepository repository = new SIRepository();
SIAccountRepository accountRepository = new SIAccountRepository();
SICustomerRepository customerRepository = new SICustomerRepository();
IDtoCreator<Account, AccountDto> accountCreator = new AccountDtoCreator();
//act
var accountServices = new AccountServices(repository, accountRepository, customerRepository, accountCreator);
var result = accountServices.Balance(account);
return result;
}
public void CategorizePayments(Account account)
{
//TODO:get the owner of the account,get his personal tags
//get his personal rules
//classify his spendings
TextClassifier classifier = new TextClassifier();
var operations = account.Operations;
foreach (var operation in operations)
{
var tag = classifier.Categorize(operation.OppositeDescription);
operation.Tag = tag;
_repository.SaveOrUpdate(operation);
}
}
public void makeTransfer_DebitAccountNotFound()
{
//arrange
IOperationRepository operationRepository = MockRepository.GenerateStub<IOperationRepository>();
IRepository repository = MockRepository.GenerateStub<IRepository>();
IDtoCreator<Operation, OperationDto> operationCreator = MockRepository.GenerateStub<IDtoCreator<Operation, OperationDto>>();
Account creditAccount = new Account() { Id = 1 };
Account debitAccount = new Account() { Id = 2 };
repository.Expect(x=>x.Get<Account>(creditAccount.Id)).Return(creditAccount);
//act
OperationServices services = new OperationServices(operationRepository, repository,operationCreator );
services.MakeTransfer(debitAccount.Id, creditAccount.Id, 0, null);
}
public void Balance_AccountOK()
{
//arrange
Account account = new Account();
account.Operations = new List<Operation>();
account.Operations.Add(new Operation { Account = account, Amount = 10, Direction = Direction.Credit });
account.Operations.Add(new Operation { Account = account, Amount = 20, Direction = Direction.Debit });
account.Operations.Add(new Operation { Account = account, Amount = 0, Direction = Direction.Credit });
IRepository repository = MockRepository.GenerateStub<IRepository>();
ICustomerRepository customerRepository = MockRepository.GenerateStub<ICustomerRepository>();
IAccountRepository accountRepository = MockRepository.GenerateStub<IAccountRepository>();
IDtoCreator<Account, AccountDto> accountCreator = new AccountDtoCreator();
//act
AccountServices services = new AccountServices(repository, accountRepository, customerRepository, accountCreator);
decimal balance = services.Balance(account);
//assert
Assert.AreEqual(balance, -10);
}
public void GetAccountByCustomerNoAccountFound()
{
IAccountRepository accountRepository = new AccountRepository(NhibernateHelper.SessionFactory);
Repository repository = new Repository(NhibernateHelper.SessionFactory);
Customer thirdParty1 = new Customer { Code = "tjdsklfs", Email = "*****@*****.**", LastName = "Roux", FirstName = "Olivier", Password = "******", PasswordSalt = "sss" };
Customer thirdParty2 = new Customer { Code = "topsecret", Email = "*****@*****.**", LastName = "Roux2", FirstName = "Olivier", Password = "******", PasswordSalt = "sss" };
Account account1 = new Account { Balance = 201, BalanceDate = DateTime.Now, Number = "dsf1", Iban="12349340943"};
using (NhibernateHelper.SessionFactory.GetCurrentSession().BeginTransaction())
{
repository.Save(thirdParty1);
repository.Save(thirdParty2);
repository.Save(account1);
repository.Flush();
IList<Account> accounts = accountRepository.GetAccountsByCustomer(thirdParty2.Id);
Assert.AreEqual(0, accounts.Count);
}
}
public string Transfer(
Account debitAccount,
Account creditAccount,
decimal amount,
string motif
)
{
MGuid.NewGuid = () => new Guid("64d80a10-4f21-4acb-9d3d-0332e68c4394");
PexAssume.IsNotNull(debitAccount);
PexAssume.IsNotNull(creditAccount);
PexAssume.IsTrue(creditAccount != debitAccount);
var repository = new SIRepository();
var operationRepository = new SIOperationRepository();
var operationCreator = new OperationDtoCreator();
//act
var operationServices = new OperationServices(operationRepository, repository, operationCreator);
operationServices.Transfer(debitAccount, creditAccount, amount, motif);
string result = operationServices.Transfer(debitAccount, creditAccount, amount, motif);
PexAssert.IsNotNullOrEmpty(result);
return result;
}
public String Transfer(Account debitAccount, Account creditAccount, decimal amount, string motif)
{
if (!debitAccount.AuthorizeOverdraft && debitAccount.Balance < amount)
{
throw new OperationServicesException(StringResources.ErrorNotEnoughtMoney);
}
String transactionCode = Guid.NewGuid().ToString();
Operation debitOperation = new Operation() {
Account = debitAccount, Direction = Direction.Debit, Amount = amount, Motif = motif, Date=DateTime.Now,
TransactionCode=transactionCode, Currency = debitAccount.Currency};
Operation creditOperation = new Operation() {
Account = creditAccount, Direction = Direction.Credit, Amount = amount, Motif = motif, Date=DateTime.Now,TransactionCode=transactionCode, Currency = creditAccount.Currency};
debitAccount.Operations.Add(debitOperation);
//for the debit payment, the account number is set as the description of the payment
//as well as the motif of the payment
debitOperation.Description = String.Format("TRANSFER {0} {1}", creditAccount.Iban, motif);
creditOperation.Description = String.Format("RECEIVED PAYMENT {0} {1}", debitAccount.Iban, motif);
creditAccount.Operations.Add(creditOperation);
debitAccount.Balance -= amount;
creditAccount.Balance += amount;
using (TransactionScope scope = new TransactionScope())
{
_repository.Save(debitOperation);
_repository.Save(creditOperation);
_repository.Save(debitAccount);
_repository.Save(creditAccount);
scope.Complete();
}
return transactionCode;
}
public Permission GetUserRights(Account account, UserIdentity user)
{
if (user.Type == "Advisor")
{
Advisor advisor = _repository.Get<Advisor>(user.Id);
if (advisor != null)
{
return GetAdvisorRights(account, advisor);
}
return Permission.No;
}
else if (user.Type == "Customer")
{
Customer customer = _repository.Get<Customer>(user.Id);
if (customer != null)
{
return GetCustomerRights(account, customer);
}
return Permission.No;
}
else
{
throw new UserServicesException("Not expected type of user");
}
}
public String TransferToExternal(Account debitAccount, String creditAccountIban, decimal amount, String motif)
{
String transactionCode = Guid.NewGuid().ToString();
Operation debitOperation = new Operation() {
Account = debitAccount,
Direction = Direction.Debit,
Amount = amount,
Motif = motif,
Date = DateTime.Now,
TransactionCode = transactionCode,
OppositeIban = creditAccountIban,
Currency = debitAccount.Currency,
Description = String.Format("TRANSFER {0} {1}",creditAccountIban,motif)
};
debitAccount.Operations.Add(debitOperation);
//update of the balance - also of the evolution of the balance
debitAccount.Balance -= amount;
using (TransactionScope scope = new TransactionScope())
{
_repository.Save(debitOperation);
_repository.Save(debitAccount);
scope.Complete();
}
return transactionCode;
//Here in real scenario I would send the transaction to CBS
}
public decimal Balance(Account account)
{
Contract.Requires<AccountServicesException>(account != null);
return default(decimal);
}
//adds first 80 transactions with the date originated from the CSV file (to have some historic information)
//adds next 40 transactions and chooses random date from last 20 days - to have some actual information
private static void SelectForAccount(IRepository repository, Account account, Random rnd, IOrderedEnumerable<Operation> randomTransactions)
{
randomTransactions.Take(80).ForEach(x => { x.Account = account; repository.Save(x); });
randomTransactions.Skip(80).Take(40).ForEach(x =>
{
x.Account = account;
x.Date = DateTime.Now.Subtract(new TimeSpan(rnd.Next(20), 0, 0, 0));
repository.Save(x);
});
}
/// <summary>
/// Computes balance evolution of account - completely from beginning, if there was an evolution, erases the content
/// </summary>
/// <param name="account"></param>
public void ComputeBalancePoints(Account account)
{
if (account.Operations.Count > 0)
{
account.BalancePoints = new List<BalancePoint>();
CreateBalancePointsForOperations(account.Operations, 0, account);
}
}
public void UpdateBalancePoints(Account account)
{
if (account.BalancePoints.Count > 0)
{
var last = account.BalancePoints.OrderBy(x => x.Date).Last();
//have to compare the dates! not datetimes
var newOperations = account.Operations.Where(x => x.Date.Date.CompareTo(last.Date) > 0);
var previousDate = last.Balance;
CreateBalancePointsForOperations(newOperations, previousDate,account);
}
account.Balance = account.BalancePoints.Last().Balance;
}
public String Transfer(Account debitAccount, Account creditAccount, decimal amount, string motif)
{
Contract.Requires<OperationServicesException>(amount != null);
Contract.Requires<ArgumentNullException>(debitAccount != null);
Contract.Requires<ArgumentNullException>(creditAccount != null);
Contract.Requires<OperationServicesException>(debitAccount != creditAccount);
Contract.Requires<OperationServicesException>(amount > 0);
return default(String);
}
public void GetClientAccounts_ClientNotNull()
{
//arange
IRepository repository = MockRepository.GenerateStub<IRepository>();
IAccountRepository accountRepository = MockRepository.GenerateMock<IAccountRepository>();
ICustomerRepository thirdPartyRepository = MockRepository.GenerateStub<ICustomerRepository>();
IDtoCreator<Account, AccountDto> accountCreator = new AccountDtoCreator();
Customer customer = new Customer { Id = 3 };
IList<Account> accounts = new List<Account>();
Account account = new Account() { Id = 1 };
accounts.Add(account);
accountRepository.Expect(x => x.GetAccountsByCustomer(customer.Id)).Return(accounts);
//act
AccountServices services = new AccountServices(repository, accountRepository, thirdPartyRepository,accountCreator);
IList<AccountDto> retrievedAccounts = services.GetCustomerAccounts(customer.Id);
//assert
Assert.AreEqual(1, retrievedAccounts.Count);
Assert.AreEqual(account.Id, retrievedAccounts[0].Id);
accountRepository.VerifyAllExpectations();
}
public void makeTransfer_NotEnoughMoneyDebitAccount()
{
IOperationRepository operationRepository = MockRepository.GenerateStub<IOperationRepository>();
IRepository repository = MockRepository.GenerateMock<IRepository>();
IDtoCreator<Operation, OperationDto> operationCreator = MockRepository.GenerateStub<IDtoCreator<Operation, OperationDto>>();
Account debitAccount = new Account() { Id = 1, Balance = 100 };
Account creditAccount = new Account() { Id = 2, Balance = 300 };
repository.Expect(x=>x.Get<Account>(debitAccount.Id)).Return(debitAccount);
repository.Expect(x=>x.Get<Account>(creditAccount.Id)).Return(creditAccount);
OperationServices services = new OperationServices(operationRepository, repository, operationCreator);
services.MakeTransfer(debitAccount.Id, creditAccount.Id, 200, "");
repository.VerifyAllExpectations();
}
public void GetIndividualCustomerByCode_Found()
{
ICustomerRepository customerRepository = new CustomerRepository(NhibernateHelper.SessionFactory);
Repository repository = new Repository(NhibernateHelper.SessionFactory);
Customer customer = new Customer { Code = "tjdsklfs", Email = "*****@*****.**", FirstName = "Sim", LastName = "Lehericey", Password = "******", PasswordSalt = "sss" };
Account account1 = new Account { Balance = 201, BalanceDate = DateTime.Now, Number = "dsf1", Iban="1234"};
Customer retrievedCustomer;
using (NhibernateHelper.SessionFactory.GetCurrentSession().BeginTransaction())
{
repository.Save(customer);
repository.Save(account1);
repository.Flush();
retrievedCustomer = customerRepository.GetCustomerByCode(customer.Code);
Assert.IsNotNull(retrievedCustomer);
}
}
/// <summary>
/// Helping method, iterates through operations and sums the values to compute the account evolution
/// </summary>
/// <param name="operations"></param>
/// <param name="lastBalance"></param>
/// <param name="account"></param>
private void CreateBalancePointsForOperations(IEnumerable<Operation> operations, Decimal lastBalance,Account account)
{
var parDate = operations
.OrderBy(x => x.Date.Date)
.GroupBy(x => x.Date.Date)
.ToDictionary(x => x.Key, x => x.Sum(y => y.SignedAmount));
using (TransactionScope scope = new TransactionScope())
{
foreach (var item in parDate)
{
BalancePoint point = new BalancePoint { Date = item.Key, Balance = lastBalance + item.Value, Account = account }; // item.Value.Sum(x => x.SignedAmount) };
lastBalance = point.Balance;
_repository.Save(point);
account.BalancePoints.Add(point);
}
account.Balance = lastBalance;
scope.Complete();
}
}
public string TransferToExternal(Account debitAccount, String creditAccountIban, decimal amount, string motif)
{
Contract.Requires<OperationServicesException>(amount > 0);
Contract.Requires<OperationServicesException>(debitAccount != null);
Contract.Requires<OperationServicesException>(!string.IsNullOrEmpty(creditAccountIban));
return default(String);
}
private List<TagDepenses> AggregateAccountTags(Account account)
{
var grouped = account.Operations.Where(x => x.SignedAmount < 0).GroupBy(x => x.Tag);
var dict = grouped.ToDictionary(x => x.Key, y => y.Sum(x => x.SignedAmount));
List<TagDepenses> depenses = dict.Select(x => new TagDepenses() { Tag = x.Key, Depenses = x.Value }).ToList();
return depenses;
}
/// <summary>
/// Method which computes the Balance points of an account
/// //TODO: Modify this to work only over certain time period
/// </summary>
/// <param name="account"></param>
/// <returns></returns>
private Dictionary<DateTime, BalancePoint> ComputeBalancePoints(Account account)
{
Dictionary<DateTime, BalancePoint> result = new Dictionary<DateTime, BalancePoint>();
if (account.Operations.Count > 0)
{
var parDate = account.Operations
.OrderBy(x => x.Date.Date)
.GroupBy(x => x.Date.Date)
.ToDictionary(x => x.Key, x => x.ToList());
decimal previousDate = 0;
for (DateTime date = parDate.Keys.First(); date.CompareTo(DateTime.Now) <= 0; date = date.AddDays(1))
{
BalancePoint point = null;
if (parDate.ContainsKey(date))
{
List<Operation> operationsToAdd = parDate[date];
point = new BalancePoint() { Date = date.Date, Balance = previousDate + operationsToAdd.Sum(x => x.SignedAmount) };
}
else
{
point = new BalancePoint() { Date = date, Balance = previousDate };
}
result.Add(date.Date, point);
previousDate = result[date].Balance;
_repository.SaveOrUpdate(point);
}
}
return result;
}
public void makeTransfer_Ok()
{
//arrange
IOperationRepository operationRepository = MockRepository.GenerateStub<IOperationRepository>();
IRepository repository = MockRepository.GenerateMock<IRepository>();
IDtoCreator<Operation, OperationDto> operationCreator = MockRepository.GenerateStub<IDtoCreator<Operation, OperationDto>>();
Account debitAccount = new Account() { Id = 1, Balance = 200 };
Account creditAccount = new Account() { Id = 2, Balance = 300 };
repository.Expect(x => x.Get<Account>(debitAccount.Id)).Return(debitAccount);
repository.Expect(x => x.Get<Account>(creditAccount.Id)).Return(creditAccount);
repository.Expect(x => x.Save(debitAccount));
repository.Expect(x => x.Save(creditAccount));
repository.Expect(x => x.Save(new Operation())).IgnoreArguments();
repository.Expect(x => x.Save(new Operation())).IgnoreArguments();
//act
OperationServices services = new OperationServices(operationRepository, repository, operationCreator);
services.MakeTransfer(debitAccount.Id, creditAccount.Id, 200, "transfer test");
//assert
Assert.AreEqual(0, debitAccount.Balance);
Assert.AreEqual(500, creditAccount.Balance);
Assert.AreEqual(1, debitAccount.Operations.Count);
Operation debitOperation = debitAccount.Operations[0];
Assert.AreEqual(debitAccount.Id, debitOperation.Account.Id);
Assert.AreEqual(200, debitOperation.Amount);
Assert.AreEqual(Direction.Debit, debitOperation.Direction);
Assert.AreEqual("transfer test", debitOperation.Motif);
Operation creditOperation = creditAccount.Operations[0];
Assert.AreEqual(creditAccount.Id, creditOperation.Account.Id);
Assert.AreEqual(200, creditOperation.Amount);
Assert.AreEqual(Direction.Credit, creditOperation.Direction);
Assert.AreEqual("transfer test", creditOperation.Motif);
repository.VerifyAllExpectations();
}
