public async Task <IActionResult> GetAccounts([FromBody] ProviderCreatingDto providerDto)
{
IEnumerable <BankAccountCreatingDto> result;
var providerDescriptor = new ProviderDoc
{
Name = providerDto.Name,
Type = providerDto.Type,
Credentials = providerDto.Credentials
};
try
{
var dataProvider = await _providerFactory.CreateDataProvider(providerDescriptor);
var accounts = (dataProvider as IBankAccountProvider)?.GetAccounts();
dataProvider.Dispose();
var provider = AutoMapper.Mapper.Map <ProviderDoc>(providerDto);
var newAccounts = FetchNewAccount(provider, accounts);
result = AutoMapper.Mapper.Map <IEnumerable <BankAccountCreatingDto> >(newAccounts);
}
catch (UnauthorizedAccessException ex)
{
return(new UnauthorizedActionResult(ex.Message));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] ProviderCreatingDto newProvider)
{
if (newProvider == null)
{
return(BadRequest());
}
ProviderDto result = await AddOrUpdateProvider(newProvider);
return(Ok(result));
}
private async Task <ProviderDoc> FetchOrCreateProvider(ProviderCreatingDto newProvider)
{
var np = AutoMapper.Mapper.Map <ProviderDoc>(newProvider);
var provider = await _providerRepository.Find(np);
if (provider == null)
{
await _providerRepository.AddProvider(np);
provider = np;
}
return(provider);
}
private async Task <IEnumerable <BankAccountDoc> > UpdateBankAccounts(ProviderCreatingDto newProvider, ProviderDoc provider, List <String> accountsIds)
{
var bankAccounts = await AddBankAccounts(newProvider, provider.Id);
accountsIds.AddRange(bankAccounts.Select(a => a.Id).ToList());
provider.Accounts = accountsIds;
await _providerRepository.UpdateProvider(provider.Id, provider);
var accounts = await _accountService.UpdateBankAccountsForProvider(provider);
foreach (var account in accounts)
{
await _bankAccountRepository.UpdateAccount(account.Id, account);
}
return(accounts);
}
private async Task <IEnumerable <CreditCard> > UpdateCreditCards(ProviderCreatingDto newProvider, ProviderDoc provider, List <String> accountsIds)
{
var creditCards = await AddCreditAccounts(newProvider, provider.Id);
accountsIds.AddRange(creditCards.Select(a => a.Id).ToList());
provider.Accounts = accountsIds;
await _providerRepository.UpdateProvider(provider.Id, provider);
var updatedCards = await _accountService.UpdateCreditCards(provider);
foreach (var updatedCard in updatedCards)
{
await _creditCardRepository.UpdateCard(updatedCard.Id,
AutoMapper.Mapper.Map <CreditCardDoc>(updatedCard));
}
return(updatedCards);
}
private IEnumerable <CreditCard> FilterNewAccount(ProviderCreatingDto providerDto, IEnumerable <CreditCard> cards)
{
IEnumerable <CreditCard> newAccounts;
var p = AutoMapper.Mapper.Map <ProviderDoc>(providerDto);
var provider = _providerRepository.Find(p);
if (provider != null)
{
newAccounts = (from card in cards
where !IsAccountExists(card)
select card).ToList();
}
else
{
newAccounts = cards;
}
return(newAccounts);
}
private async Task <IEnumerable <BankAccountDoc> > AddBankAccounts(ProviderCreatingDto newProvider, String providerId)
{
IEnumerable <BankAccountDoc> accounts = new List <BankAccountDoc>();
if (newProvider.BankAccounts.Any())
{
accounts = AutoMapper.Mapper.Map <IEnumerable <BankAccountDoc> >(newProvider.BankAccounts);
foreach (var bankAccount in accounts)
{
bankAccount.ProviderId = providerId;
bankAccount.ProviderName = newProvider.Name;
bankAccount.UserId = newProvider.UserId;
}
await _bankAccountRepository.AddAccounts(accounts);
}
return(accounts);
}
private async Task <IEnumerable <CreditCardDoc> > AddCreditAccounts(ProviderCreatingDto newProvider, String providerId)
{
IEnumerable <CreditCardDoc> accounts = new List <CreditCardDoc>();
if (newProvider.CreditCards.Any())
{
accounts = AutoMapper.Mapper.Map <IEnumerable <CreditCardDoc> >(newProvider.CreditCards);
foreach (var creditAccount in accounts)
{
creditAccount.ProviderId = providerId;
creditAccount.ProviderName = newProvider.Name;
creditAccount.UserId = newProvider.UserId;
}
await _creditCardRepository.AddCards(accounts);
}
return(accounts);
}
private async Task <ProviderDto> AddOrUpdateProvider(ProviderCreatingDto newProvider)
{
var provider = await FetchOrCreateProvider(newProvider);
var accountsIds = provider.Accounts?.ToList() ?? new List <String>();
var result = AutoMapper.Mapper.Map <ProviderDto>(provider);
if (provider.Type == InstitutionType.Bank)
{
var accounts = await UpdateBankAccounts(newProvider, provider, accountsIds);
result.BankAccounts = AutoMapper.Mapper.Map <IEnumerable <BankAccountDto> >(accounts);
}
else if (provider.Type == InstitutionType.Credit)
{
var creditAccounts = await UpdateCreditCards(newProvider, provider, accountsIds);
result.CreditCards = AutoMapper.Mapper.Map <IEnumerable <CreditCardDto> >(creditAccounts);
}
return(result);
}
