public listing_cards_on_customer()
{
var customerService = new StripeCustomerService(Cache.ApiKey);
var bankAccountService = new BankAccountService(Cache.ApiKey);
var cardService = new StripeCardService(Cache.ApiKey);
var CustomerCreateOptions = new StripeCustomerCreateOptions
{
Email = "*****@*****.**",
SourceToken = "tok_visa",
};
var Customer = customerService.Create(CustomerCreateOptions);
var BankAccountCreateOptions = new BankAccountCreateOptions
{
SourceBankAccount = new SourceBankAccount()
{
RoutingNumber = "110000000",
AccountNumber = "000123456789",
Country = "US",
Currency = "usd",
AccountHolderName = "Jenny Rosen",
AccountHolderType = BankAccountHolderType.Individual,
}
};
var BankAccount = bankAccountService.Create(Customer.Id, BankAccountCreateOptions);
ListCards = cardService.List(Customer.Id);
}
public void Add_Should_Add_BankAccount()
{
var dbName = DataBaseHelper.Instance.NewDataBase();
var user = DataBaseHelper.Instance.UseNewUser(dbName);
var bankAccountType = DataBaseHelper.Instance.UseNewBankAccountType(dbName);
var bankAccountService = new BankAccountService();
var bankAccountWording = "test bank account";
var initialBalance = 120.50m;
using (var context = DataBaseHelper.Instance.CreateContext(dbName))
{
bankAccountService.Create(context, user.UserName, new CreateBankAccountDto()
{
BankAccountTypeId = bankAccountType.Id,
Wording = bankAccountWording,
InitialBalance = initialBalance,
OperationsTypes = new List <string>()
{
"operation type est 1",
"operation type est 2",
"operation type est 3"
}
});
}
using (var context = DataBaseHelper.Instance.CreateContext(dbName))
{
var bankAccountFromDb = context.BankAccounts.SingleOrDefault(ba => ba.Wording.Equals(bankAccountWording));
Assert.NotNull(bankAccountFromDb);
Assert.Equal(initialBalance, bankAccountFromDb.Balance);
Assert.Equal(initialBalance, bankAccountFromDb.OpeningBalance);
Assert.Equal(initialBalance, bankAccountFromDb.ActualBalance);
Assert.Equal(bankAccountType.Id, bankAccountFromDb.BankAccountTypeId);
var userBankAccountFromDb = context.UserBankAccounts.SingleOrDefault(uba => uba.BankAccountId.Equals(bankAccountFromDb.Id));
Assert.NotNull(userBankAccountFromDb);
Assert.Equal(user.Id, userBankAccountFromDb.UserId);
Assert.True(userBankAccountFromDb.IsOwner);
Assert.False(userBankAccountFromDb.IsReadOnly);
var operationsTypes = context.OperationTypes.Select(ot => ot.BankAccountId.Equals(bankAccountFromDb.Id));
Assert.NotEmpty(operationsTypes);
Assert.Equal(3, operationsTypes.Count());
}
}
public void BankAccountService_Create_Without_InitialCredit()
{
// Arrange
_dbContext.Customers.Add(new Customer
{
Name = Guid.NewGuid().ToString(),
Surname = Guid.NewGuid().ToString(),
DateCreated = DateTime.UtcNow
});
_dbContext.SaveChanges();
var bankAccountService = new BankAccountService(new BankAccountRepository(_dbContext), new TransactionRepository(_dbContext));
// Act
var result = bankAccountService.Create(1, 0).GetAwaiter().GetResult();
// Assert
Assert.True(result);
}
public async void Create_NoErrors()
{
var mock = new ServiceMockFacade <IBankAccountRepository>();
var model = new ApiBankAccountServerRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <BankAccount>())).Returns(Task.FromResult(new BankAccount()));
var service = new BankAccountService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.BankAccountModelValidatorMock.Object,
mock.DALMapperMockFactory.DALBankAccountMapperMock);
CreateResponse <ApiBankAccountServerResponseModel> response = await service.Create(model);
response.Should().NotBeNull();
response.Success.Should().BeTrue();
mock.ModelValidatorMockFactory.BankAccountModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiBankAccountServerRequestModel>()));
mock.RepositoryMock.Verify(x => x.Create(It.IsAny <BankAccount>()));
mock.MediatorMock.Verify(x => x.Publish(It.IsAny <BankAccountCreatedNotification>(), It.IsAny <CancellationToken>()));
}
public void Add_With_Unknow_User_Should_Throw_DaGet_Unauthorized_Exception()
{
var dbName = DataBaseHelper.Instance.NewDataBase();
var bankAccountType = DataBaseHelper.Instance.UseNewBankAccountType(dbName);
var bankAccountService = new BankAccountService();
using (var context = DataBaseHelper.Instance.CreateContext(dbName))
{
Assert.Throws <DaGetUnauthorizedException>(() => bankAccountService.Create(context, Guid.NewGuid().ToString(), new CreateBankAccountDto()
{
BankAccountTypeId = bankAccountType.Id,
Wording = Guid.NewGuid().ToString(),
InitialBalance = 0m,
OperationsTypes = new List <string>()
{
Guid.NewGuid().ToString(),
Guid.NewGuid().ToString(),
Guid.NewGuid().ToString()
}
}));
}
}
public async void Create_Errors()
{
var mock = new ServiceMockFacade <IBankAccountRepository>();
var model = new ApiBankAccountServerRequestModel();
var validatorMock = new Mock <IApiBankAccountServerRequestModelValidator>();
validatorMock.Setup(x => x.ValidateCreateAsync(It.IsAny <ApiBankAccountServerRequestModel>())).Returns(Task.FromResult(new FluentValidation.Results.ValidationResult(new List <ValidationFailure>()
{
new ValidationFailure("text", "test")
})));
var service = new BankAccountService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
validatorMock.Object,
mock.DALMapperMockFactory.DALBankAccountMapperMock);
CreateResponse <ApiBankAccountServerResponseModel> response = await service.Create(model);
response.Should().NotBeNull();
response.Success.Should().BeFalse();
validatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiBankAccountServerRequestModel>()));
mock.MediatorMock.Verify(x => x.Publish(It.IsAny <BankAccountCreatedNotification>(), It.IsAny <CancellationToken>()), Times.Never());
}
public ActionResult RegisterBankAccount([FromBody] dynamic body)
{
try
{
string account = body.account ?? body.Account ?? body.account_name ?? body.accountName ?? body.AccountName;
string currency = body.currency;
int? userId = ((string)(body.user_id ?? body.userId ?? body.user)).ParseToInt();
string email = body.user_email ?? body.userEmail ?? body.email ?? body.user;
var id = userId.HasValue
? BankAccountService.Create(account, currency, userId.Value)
: BankAccountService.Create(account, currency, email);
return(Ok(new { account = id }));
}
catch (Exception ex) when(ex is ArgumentException || ex is BusinessException)
{
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
Logger.LogError("Error while registering new bank account: " + ex.Message, ex);
return(StatusCode(StatusCodes.Status500InternalServerError, ex));
}
}
public AccountPaymentMethod CreateBankAccountPaymentMethod(string accountHolderName, string accountHolderType, string routingNumber, string accountNumber, byte usedFor)
{
try
{
var tokenOptions = new TokenCreateOptions
{
BankAccount = new BankAccountOptions
{
Country = "US",
Currency = "usd",
AccountHolderName = accountHolderName,
AccountHolderType = accountHolderType,
RoutingNumber = routingNumber,
AccountNumber = accountNumber
}
};
var tokenService = new TokenService();
Token token = tokenService.Create(tokenOptions);
var stripeCustomer = GetStripeCustomer();
var bankAccountOptions = new BankAccountCreateOptions
{
Source = token.Id,
};
var bankAccountService = new BankAccountService();
BankAccount bankAccount = bankAccountService.Create(stripeCustomer.Id, bankAccountOptions);
using (FlyJetsDbContext dbContext = new FlyJetsDbContext(_config))
{
var paymentMehtod = new AccountPaymentMethod()
{
Id = Guid.NewGuid(),
AccountId = _accountId,
PaymentMethod = (byte)PaymentMethods.BankTransfer,
TokenId = token.Id,
BankName = token.BankAccount.BankName,
RoutingNumber = token.BankAccount.RoutingNumber,
HolderName = token.BankAccount.AccountHolderName,
AccountLast4 = token.BankAccount.Last4,
UsedFor = usedFor,
ReferencePaymentMethodId = bankAccount.Id,
CreatedOn = DateTime.UtcNow
};
dbContext.AccountPaymentMethods.Add(paymentMehtod);
dbContext.SaveChanges();
return(paymentMehtod);
}
}
catch (StripeException e)
{
switch (e.StripeError.ErrorType)
{
case "card_error":
break;
case "api_connection_error":
break;
case "api_error":
break;
case "authentication_error":
break;
case "invalid_request_error":
break;
case "rate_limit_error":
break;
case "validation_error":
break;
default:
break;
}
return(null);
}
}
public async Task <int> PaymentAch(string bankToken, int amount,
string account_number, string rounting_number)
{
try
{
// Create an ACH charge
StripeConfiguration.SetApiKey(ep.GetStripeSecretKey());
CustomerService customerService = new CustomerService();
var customerOptions = new CustomerCreateOptions
{
};
Customer achCustomer = customerService.Create(customerOptions);
// Create Bank Account
var bankAccountOptions = new BankAccountCreateOptions
{
SourceToken = bankToken
};
var bankService = new BankAccountService();
BankAccount bankAccount = bankService.Create(achCustomer.Id, bankAccountOptions);
// Verify BankAccount
List <long> Amounts = new List <long>();
Amounts.Add(32);
Amounts.Add(45);
var verifyOptions = new BankAccountVerifyOptions
{
Amounts = Amounts
};
bankAccount = bankService.Verify(achCustomer.Id, bankAccount.Id, verifyOptions);
var chargeOptions = new ChargeCreateOptions
{
Amount = amount,
Currency = "usd",
Description = "Charge for [email protected]",
CustomerId = achCustomer.Id
};
var chargeService = new ChargeService();
Charge charge = chargeService.Create(chargeOptions);
// Payout from Stripe to Bank Account
string bankAccountStr = account_number; // "000123456789";
string bankRoutingStr = rounting_number; // "110000000";
// Get self account
var accountOptions = new AccountCreateOptions
{
Email = "*****@*****.**",
Type = AccountType.Custom,
Country = "US",
ExternalBankAccount = new AccountBankAccountOptions()
{
Country = "US",
Currency = "usd",
AccountHolderName = "John Brown",//account_name
AccountHolderType = "individual",
RoutingNumber = bankRoutingStr,
AccountNumber = bankAccountStr
},
PayoutSchedule = new AccountPayoutScheduleOptions()
{
Interval = "daily"
},
TosAcceptance = new AccountTosAcceptanceOptions()
{
Date = DateTime.Now.AddDays(-10),
Ip = "202.47.115.80",
UserAgent = "Chrome"
},
LegalEntity = new AccountLegalEntityOptions()
{
Dob = new AccountDobOptions()
{
Day = 1,
Month = 4,
Year = 1991
},
FirstName = "John",
LastName = "Brown",
Type = "individual"
}
};
var accountService = new AccountService();
Account account = await accountService.CreateAsync(accountOptions);
StripeConfiguration.SetApiKey(ep.GetStripeSecretKey());
var service = new BalanceService();
Balance balance = await service.GetAsync();
var transOptions = new TransferCreateOptions
{
Amount = amount,
Currency = "usd",
Destination = account.Id
};
var transferService = new TransferService();
Transfer Transfer = transferService.Create(transOptions);
var payoutOptions = new PayoutCreateOptions
{
Amount = amount,
Currency = "usd",
Destination = account.ExternalAccounts.First().Id,
SourceType = "card",
StatementDescriptor = "PAYOUT",
//Method = "instant"
};
var requestOptions = new RequestOptions();
requestOptions.ApiKey = ep.GetStripeSecretKey();
requestOptions.StripeConnectAccountId = account.Id;
var payoutService = new PayoutService();
var payout = await payoutService.CreateAsync(payoutOptions, requestOptions);
return(1);
}
catch (Exception)
{
return(0);
}
}
private void CreateBankAccountException()
{
var bankAccountService = new BankAccountService(new BankAccountRepository(_dbContext), new TransactionRepository(_dbContext));
bankAccountService.Create(1, 0).GetAwaiter().GetResult();
}
public async Task <IActionResult> Create(BankAccountViewModel model)
{
var bankAccount = _bankAccountService.Create(model.Map());
return(new JsonResult(bankAccount));
}
