public async Task <IActionResult> Post([FromBody] CreateBankAccount command)
{
// TODO: Provide created uri
await DispatchAsync(command);
return(CreatedAtAction($"/bank/", new object()));
}
public async Task CreateBankAccount_LoggedInUserTryingToAddNewBankAccount_ShouldSucced_ReturnsOkHttpStatusCode()
{
//Arrange
var user1 = await _userRepository.GetAsync("*****@*****.**");
string token = await GetToken(user1);
var request = new CreateBankAccount
{
BankAccountName = "name",
InitialBalance = 25,
userId = user1.UserId,
Currency = "PLN",
HexColor = "#FFF"
};
var payload = GetPayload(request);
//Act
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var response = await _client.PostAsync("BankAccounts", payload);
//Assert
var bankacc = user1.BankAccounts.FirstOrDefault(x => x.AccountName == request.BankAccountName);
response.StatusCode.Should().Be(HttpStatusCode.OK);
bankacc.Should().NotBeNull();
bankacc.AccountName.Should().BeEquivalentTo(request.BankAccountName);
}
public async Task <OId <BankAccount, Guid> > Handle(CreateBankAccount request, CancellationToken cancellationToken)
{
var bankAccountId = OId.Of <BankAccount, Guid>(UniqueId.New());
var bankAccount = BankAccount.New(bankAccountId, request.AccountHolderId, request.Iban, request.AccountCurrency, request.EmployeeId, request.TimeStamp);
await bankAccountRepository.SaveAsync(bankAccount).ConfigureAwait(false);
return(bankAccountId);
}
// POST: api/BankAccounts
public async Task <HttpResponseMessage> Post([FromBody] CreateBankAccount command)
{
var customerExists = await CustomerExists(command.CustomerId);
if (customerExists)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Customer already exists"));
}
await mediator.Send(command);
return(Request.CreateResponse(HttpStatusCode.OK));
}
private static Task CreateAccountAsync(IMediator mediator)
{
System.Console.Clear();
System.Console.Write("IBAN: ");
var iban = Iban.Of(System.Console.ReadLine());
var createBankAccount = new CreateBankAccount(OId.Of <AccountHolder, Guid>(Guid.NewGuid()),
OId.Of <Employee, Guid>(EmployeeId),
Currency.Euro,
iban,
TimeStamp.Of(DateTimeOffset.Now.ToUnixTimeSeconds()));
return(mediator.Send(createBankAccount));
}
internal static BankAccountCreated ToEvent(this CreateBankAccount command, BankAccount bankAccount)
{
return(new BankAccountCreated
{
Id = bankAccount.Id,
ClearingNo = command.ClearingNo,
AccountNo = bankAccount.GetAccountNo(command.ClearingNo),
Address = command.Address,
Fullname = command.Fullname,
Phonenumber = command.Phonenumber,
CustomerId = command.CustomerId,
Timestamp = DateTime.Now,
Entity = bankAccount
});
}
public async Task CreateBankAccount_NotLoggedInUserTryingToCreateBankAccount_ShouldFail_ReturnsUnautorizedHttpErrorCode()
{
var user1 = await _userRepository.GetAsync("*****@*****.**");
var request = new CreateBankAccount
{
BankAccountName = "name",
InitialBalance = 20,
userId = user1.UserId
};
var payload = GetPayload(request);
var response = await _client.PostAsync("BankAccounts", payload);
response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
}
public async Task <BankAccount> CreateAccount(CreateBankAccountModel model, string customerId)
{
var user = await _userManager.FindByIdAsync(customerId);
var customer = await _repo.GetWithWhere <Customer>(o => o.UserId == user.Id);
var bankAccountType = await _repo.GetById <BankAccountType>(model.AccountType);
if (customer == null || bankAccountType == null)
{
throw new AppException("Unavailable user");
}
var bankAccountName = await CreateBankAccount.GenerateBankAccountNumber(bankAccountType.Code, customer);
var balance = model.InitialDeposit;
var initialDeposit = model.InitialDeposit;
var maintenanceFee = bankAccountType.MaintenanceFee;
var interestRate = bankAccountType.InitialInterestRate ?? 0;
DateTime?lastDeposit;
if (initialDeposit > 0)
{
lastDeposit = DateTime.Now;
}
else
{
lastDeposit = null;
}
var bankAccount = new BankAccount {
AccountNumber = bankAccountName,
Balance = balance,
MaintenanceFee = maintenanceFee,
InterestRate = interestRate,
InitialDeposit = initialDeposit,
LastDeposit = lastDeposit,
BankAccountStatus = BankAccountStatus.Active,
AccountType = bankAccountType,
Customer = customer
};
return(bankAccount);
}
public IActionResult CreateNewAccount(CreateBankAccount account)
{
PopulateCurrencies();
string userId = _userManager.GetUserId(User);
ApplicationUser user = _dbContext.Users.Include(u => u.Accounts).First(s => s.Id == userId);
if (user.Accounts.Exists(c => c.CurrencyId == account.CurrencyId))
{
ViewData["Message"] = "You already have account of this currency!";
return(View("Index"));
}
_dbContext.BankAccounts.Add(new BankAccount {
CurrencyId = account.CurrencyId, UserId = user.Id
});
_dbContext.SaveChanges();
ViewData["Message"] = "Account created!";
return(View("Index"));
}
public ActionResult CreateBankAccount(CreateBankAccount account)
{
if (ModelState.IsValid)
{
using (var db = new OurDbContext())
{
var usr = db.User.FirstOrDefault(u => u.UserName == User.Identity.Name);
var bankAccount = new BankAccount
{
UserId = usr.Id,
Key = Guid.NewGuid(),
FriendlyName = account.FriendlyName,
Balance = 0
};
db.UserAccounts.Add(bankAccount);
db.SaveChanges();
}
return(RedirectToAction("CreatedSuccessfully"));
}
return(View());
}
public void CreateNewBankAccount_Always_SavesNewBankAccount()
{
var bankAccountRepository = Substitute.For <IBankAccountRepository>();
var systemUnderTest = new CreateBankAccountHandler(bankAccountRepository);
var employeeId = OId.Of <Employee, Guid>(Guid.Parse("309dc64d-bde5-4ee5-9e21-33a517e2fe35"));
var accountHolderId = OId.Of <AccountHolder, Guid>(Guid.Parse("59ed2782-881b-49a9-8230-d0b3bb1c9072"));
var iban = Iban.Of("DE37200505501340426749");
const int unixTimestamp = 1;
var command = new CreateBankAccount(accountHolderId, employeeId, Currency.Euro, iban, TimeStamp.Of(unixTimestamp));
var expectedAccountId = Guid.Parse("5fd9c8fe-2a2c-4d76-9c57-2460dd516dbf");
UniqueId.OverrideNewGuid(expectedAccountId);
systemUnderTest.Handle(command, CancellationToken.None).GetAwaiter().GetResult();
var expectedEvents = new BankAccountEvent[] { new BankAccountCreated(expectedAccountId, accountHolderId.Value, iban.Value, Currency.Euro.Value, employeeId.Value, unixTimestamp) };
bankAccountRepository.Received()
.SaveAsync(Arg.Is <BankAccount>(it => it.IsCorrectBankAccount(aggregate =>
aggregate.Id.Value.Equals(expectedAccountId) &&
aggregate.Version == 1 &&
aggregate.GetUncommittedEvents().SequenceEqual(expectedEvents))));
UniqueId.ResetOverride();
}
public CommandResult Create([FromBody] CreateBankAccount command)
{
return(CommandProcessor.Execute(command));
}
