public void Store(int personId, string personEmail, string personName, string personPhone,
string personCity, string personState, int bankInformationId,
string bankInformationPersonName, string bankInformationCpf,
string bankInformationBankName, string bankInformationAgency,
string bankInformationAccountType, string bankInformationAccountNumber)
{
var bankInformation = _bankInformationRepository.GetById(bankInformationId);
var candidate = _candidateRepository.GetById(personId);
if (candidate == null)
{
bankInformation = new BankInformation(bankInformationPersonName, bankInformationCpf,
bankInformationBankName, bankInformationAgency,
bankInformationAccountType, bankInformationAccountNumber);
_bankInformationRepository.Save(bankInformation);
candidate = new Candidate(personEmail, personName, personPhone, personCity, personState, bankInformation);
_candidateRepository.Save(candidate);
}
else
{
bankInformation.Update(bankInformationPersonName, bankInformationCpf,
bankInformationBankName, bankInformationAgency,
bankInformationAccountType, bankInformationAccountNumber);
candidate.Update(personEmail, personName, personPhone, personCity, personState, bankInformation);
}
}
public async Task <BankInformation> GetAccountInfoById(string accountId)
{
HttpClient client = new HttpClient();
string requestId = Guid.NewGuid().ToString();
string consentId = await GetConsent();
string contentType = "application/json";
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType));
client.DefaultRequestHeaders.Add("X-Request-ID", requestId);
client.DefaultRequestHeaders.Add("Consent-ID", consentId);
var response = await client.GetAsync(new Uri($"https://developers.medbank.lt/psd2/v1/accounts/{accountId}"));
string content = await response.Content.ReadAsStringAsync();
MedBankAccountInfoResponse result = JsonConvert.DeserializeObject <MedBankAccountInfoResponse>(content);
BankInformation info = new BankInformation();
info.AccountBalance = Convert.ToDecimal(result.balances[0].balanceAmount.amount);
info.AccountName = result.name;
info.AccountNumber = accountId;
info.Currency = result.currency;
info.AccountType = "Privatkonto";
info.TotalIncome = info.AccountBalance - 1;
info.TotalExpenses = 1M;
return(info);
}
public BankInformation GetBankBysandBoxID(string sandbankIdentification)
{
BankInformation bank = new BankInformation();
var banks = GetSEBBanks();
bank = banks.FirstOrDefault(x => x.SandboxIdentification == sandbankIdentification);
return(bank);
}
/// <summary>
/// This action returns WithdrawFunds view with required
/// data passed as model
/// </summary>
/// <param name="accountNumber">accountNumber</param>
/// <returns></returns>
public ActionResult WithdrawFunds(string accountNumber)
{
try
{
if (SessionManagement.UserInfo != null)
{
LoginInformation loginInfo = SessionManagement.UserInfo;
AccountNumberRuleInfo ruleInfo = SessionManagement.AccountRuleInfo;
ViewData["Country"] = new SelectList(countryBO.GetCountries(), "PK_CountryID", "CountryName");
ViewData["ReceivingBankInfo"] = new SelectList(receivingBankInfoBO.GetReceivingBankInfo((int)SessionManagement.OrganizationID), "PK_RecievingBankID", "RecievingBankName");
var model = new TransfersModel();
model.BankInformation = new List <BankInformation>();
model.LandingAccInformation = new List <LandingAccInformation>();
model.AccountNumber = accountNumber;
//Get all bank accounts
var userBankInfos = bankBO.GetAllBankInfosForUser(loginInfo.LogAccountType, loginInfo.UserID);
foreach (var bank in userBankInfos)
{
var bankInfo = new BankInformation();
bankInfo.BankID = bank.PK_BankAccountInformationID;
bankInfo.BankName = bank.BankName;
bankInfo.BankAccNumber = bank.AccountNumber;
model.BankInformation.Add(bankInfo);
}
//Get all landing accounts
var landingAccs = clientAccBo.GetAllLandingAccountForUser(loginInfo.LogAccountType, loginInfo.UserID);
foreach (var lAcc in landingAccs)
{
var lAccInfo = new LandingAccInformation();
lAccInfo.LCurrencyName = lCurrValueBO.GetCurrencySymbolFromCurrencyAccountCode(lAcc.LandingAccount.Split('-')[ruleInfo.CurrencyPosition - 1]);
lAccInfo.LAccNumber = lAcc.LandingAccount;
lAccInfo.LAccBalance = Utility.FormatCurrencyValue((decimal)lAcc.CurrentBalance, "");
model.LandingAccInformation.Add(lAccInfo);
}
return(View("WithdrawFunds", model));
}
else
{
return(RedirectToAction("Login", "Account", new { Area = "" }));
}
}
catch (Exception ex)
{
CurrentDeskLog.Error(ex.Message, ex);
return(View("ErrorMessage"));
}
}
//public Information Information { get; set; }
// public Skill Skill { get; set; }
// public BankInformation BankInformation { get; set; }
public void Update(string email, string name, string phone,
string city, string state, BankInformation bankInformation)
{
Email = email;
Name = name;
Phone = phone;
City = city;
State = state;
BankInformation = bankInformation;
}
//UPDATE BankInformation
public void Update(BankInformation BankInformation)
{
try
{
Context.BankInformation.Attach(BankInformation);
Context.Entry(BankInformation).State = EntityState.Modified;
Context.SaveChanges();
}
catch (Exception ex)
{
throw new RepositoryException(ex.Message, ex);
}
}
private BankInformation PrepareBankInformation()
{
BankInformation BankInf = new BankInformation();
BankInf.Name = "Emanuel Meira";
BankInf.Bank = "bank inter";
BankInf.Agency = "0154";
BankInf.CPF = "12345678901";
BankInf.Account = "21544444";
BankInf.Chain = true;
BankInf.Savings = false;
return BankInf;
}
public void InvoiceDataProvider_CreateOrUpdateTest()
{
var localInvoice = new Invoice();
var mockedBankInfo = new BankInformation(1);
var mockedCustomer = new Customer(2);
var mockedContractor = new Contractor(3);
provider.Invoking(p => p.CreateOrUpdate(localInvoice)).Should().Throw <ArgumentNullException>();
localInvoice.BankInformation = new BankInformation();
provider.Invoking(p => p.CreateOrUpdate(localInvoice)).Should().Throw <ArgumentNullException>();
localInvoice.Customer = new Customer();
provider.Invoking(p => p.CreateOrUpdate(localInvoice)).Should().Throw <ArgumentNullException>();
localInvoice.Contractor = new Contractor();
provider.Invoking(p => p.CreateOrUpdate(localInvoice)).Should().Throw <ArgumentNullException>();
localInvoice.Customer.Address = new Address();
provider.Invoking(p => p.CreateOrUpdate(localInvoice)).Should().Throw <ArgumentNullException>();
localInvoice.Contractor.Address = new Address();
bankInformationProviderMock.Setup(m => m.CreateOrUpdate(It.IsAny <BankInformation>()))
.Returns((string.Empty, true));
bankInformationProviderMock.Setup(m => m.GetByEverythingExceptId(It.IsAny <BankInformation>()))
.Returns(new List <BankInformation> {
mockedBankInfo
});
customerProviderMock.Setup(m => m.CreateOrUpdate(It.IsAny <Customer>())).Returns((string.Empty, true));
customerProviderMock.Setup(m => m.GetByEverythingExceptId(It.IsAny <Customer>())).Returns(new List <Customer> {
mockedCustomer
});
contractorProviderMock.Setup(m => m.CreateOrUpdate(It.IsAny <Contractor>())).Returns((string.Empty, true));
contractorProviderMock.Setup(m => m.GetByEverythingExceptId(It.IsAny <Contractor>()))
.Returns(new List <Contractor> {
mockedContractor
});
provider.CreateOrUpdate(localInvoice);
localInvoice.BankInformation.Should().BeEquivalentTo(mockedBankInfo);
localInvoice.Customer.Should().BeEquivalentTo(mockedCustomer);
localInvoice.Contractor.Should().BeEquivalentTo(mockedContractor);
}
public void GetSimpleAccountNumberTest()
{
var testConfigs = new List <(string accountNumber, string expectedResult)>
{
(null, string.Empty),
(string.Empty, string.Empty),
(SIMPLE_ACCOUNT_NUMBER, string.Empty),
(accountNumber, SIMPLE_ACCOUNT_NUMBER)
};
foreach (var config in testConfigs)
{
var accNumber = config.accountNumber;
var expected = config.expectedResult;
var information = new BankInformation {
AccountNumber = accNumber
};
var actual = information.GetSimpleAccountNumber();
Assert.AreEqual(expected, actual);
}
}
public void TestMethod1()
{
var testOfBanks = new BankInformation();
//Assert.AreEqual(testOfBanks.NameOfBank("00102000000000000000000000000000"), "PKO BP");
}
public void AddBankInformation(BankInformation bank)
{
Db.BankInformation.Add(bank);
}
public void UpdateBankInformation(BankInformation bank)
{
Db.BankInformation.Update(bank);
}
public void TestMethod1()
{
var testOfBanks = new BankInformation();
//Assert.AreEqual(testOfBanks.NameOfBank("00102000000000000000000000000000"), "PKO BP");
}
public Candidate(string email, string name, string phone, string city, string state,
BankInformation bankInformation)
: base(email, name, phone, city, state)
{
BankInformation = bankInformation;
}
public void Save(BankInformation BankInformation)
{
throw new NotImplementedException();
}
