public async Task <IActionResult> CreateBank([FromBody] Bank bank)
{
if (await _bankRepository.Create(bank))
{
return(Ok());
}
return(BadRequest());
}
public void Create(BankViewModel account)
{
try
{
_repository.Create(MapToBankAccount(account));
}
catch (Exception e)
{
_log.Error("Error creating account: ", e);
throw;
}
}
public bool Create([FromBody] BankDTO bank)
{
QuestionBank newBank = new QuestionBank {
Id = Guid.NewGuid(),
OwnerId = user.Id,
Name = bank.Name,
Description = bank.Description,
ModifiedDate = DateTime.Now
};
return(repository.Create(newBank));
}
public void CreateBank(BankDetails bankDetails)
{
Validate(bankDetails);
var bank = Mapper.Map <Bank>(bankDetails);
_bankRepository.Create(bank);
var bankBranch = Mapper.Map <BankBranch>(bankDetails.FavoriteBranch);
bankBranch.BankId = bank.Id;
_bankBranchRepository.Create(bankBranch);
}
public void CreateBank()
{
//Tässä olioon alustetaan arvot
Bank newBank = new Bank();
Console.Write("Syötä pankin nimi: ");
newBank.Name = Console.ReadLine();
Console.Write("Syötä pankin Bic: ");
newBank.Bic = Console.ReadLine();
// Tästä alkaa tietokantaan kysely
string returnedValue = bankRepository.Create(newBank);
Console.WriteLine(returnedValue);
}
public ICommandResults Handle(CreateBankCommand command)
{
command.Validate();
if (command.Invalid)
{
return(new CommandResults(false, "Ops, não foi possível cadastrar seu registro!", command.Notifications));
}
var bk = new Bank(command.Name);
AddNotifications(bk.Notifications);
if (Invalid)
{
return(new CommandResults(false, "Ops, não foi possível cadastrar seu registro!", command));
}
_bankRepository.Create(bk);
_bankRepository.Save();
return(new CommandResults(true, "Banco registrado com sucesso!", bk));
}
public async Task <ActionResult <BankDto> > Post([FromBody] BankForCreationDto bankForCreationDto)
{
if (await this._customerRepo.GetSingle(bankForCreationDto.CustomerId) == null)
{
return(BadRequest());
}
var bank = new Bank
{
AccountNumber = bankForCreationDto.AccountNumber,
AccountHolderName = bankForCreationDto.AccountHolderName,
Sortcode = bankForCreationDto.Sortcode,
CustomerId = bankForCreationDto.CustomerId
};
var bankForRep = await _bankRepo.Create(bank);
var bankDto = _mapper.Map <BankDto>(bank);
return(Ok(bankDto));
}
public async Task <BankDto> CreateBank(BankDto bankDto)
{
Bank bank = new Bank();
IEnumerable <Bank> checkBank = new List <Bank>();
try
{
checkBank = await this.bankRepository.Find(x => x.Name.ToLower().Trim() == bankDto.BankName.ToLower().Trim());
if (checkBank == null || checkBank.Any())
{
bank = this.mapper.Map <Bank>(bankDto);
bank = await bankRepository.Create(bank);
await bankRepository.Save();
cache.Remove(string.Format("{0}", CacheEnum.BANKS.ToString()));
}
} catch (Exception er) { logger.LogError(string.Format("{0}===================={1}====================\n", DateTime.Now.ToString(), er.ToString())); }
return(this.mapper.Map <BankDto>(bank));
}
public Bank CreateBank(Bank bank)
{
return(_bankRepository.Create(bank));
}
public void SaveAllContragents(IEnumerable <Contragent> contragents)
{
Dictionary <string, Bank> dicBanks = new Dictionary <string, Bank>();
IDbTransaction trans = _connectionFactory.GetConnection.BeginTransaction();
try
{
foreach (Contragent contragent in contragents)
{
string contrInn = contragent.INN;
Contragent contrByInn = _contragentRepository.GetByInn(contrInn);
if (contrByInn == null)
{
_contragentRepository.Create(contragent);
}
else
{
contragent.Id = contrByInn.Id;
if (!contrByInn.Equals(contragent))
{
_contragentRepository.Update(contragent);
}
}
if ((contragent.Accounts != null) && (contragent.Accounts.Count > 0))
{
foreach (Account account in contragent.Accounts)
{
string bankBic = account.Bank.Bic;
Bank bankByBic = null;
Boolean just_now_added = false;
if (!dicBanks.ContainsKey(bankBic))
{
bankByBic = _bankRepository.GetByBic(bankBic);
if (bankByBic == null)
{
bankByBic = account.Bank;
_bankRepository.Create(bankByBic);
}
dicBanks.Add(bankBic, bankByBic);
just_now_added = true;
}
else
{
bankByBic = dicBanks[bankBic];
}
account.Bank.Id = bankByBic.Id;
if (!bankByBic.Equals(account.Bank))
{
_bankRepository.Update(account.Bank);
if (!just_now_added)
{
dicBanks[bankBic] = account.Bank;
}
}
account.ContragentId = contragent.Id;
account.BankId = account.Bank.Id;
Account accountFromDB = _accountRepository.Get(account.Number, contragent.Id, account.Bank.Id);
if (accountFromDB == null)
{
_accountRepository.Create(account);
}
}
}
}
trans.Commit();
}
catch (Exception e)
{
trans.Rollback();
throw new Exception(String.Format("Исключение: {0}", e.Message));
}
}
// POST: api/Banks
public IHttpActionResult Post([FromBody] Bank bank)
{
_bankRepository.Create(bank);
return(Created(Request.RequestUri + bank.Id.ToString(), bank));
}
public Bank Create(Bank newBank)
{
var createBank = _bankRepository.Create(newBank);
return(createBank);
}
