public IActionResult InterTransferTemplate(int templateId)
{
Template template = _templateServiceService.FindTemplateById(templateId);
string amount = String.Format("{0:0.00}", template.Amount);
InterBankTransferViewModel model = new InterBankTransferViewModel
{
Banks = selectListService.GetBankList(),
BankId = template.BankId,
PaymentCode = selectListService.GetPayemntCodeList(),
PaymentCodeId = template.PaymentCodeId,
ReciverName = template.ReciverName,
Transfer = new InnerTransferViewModel
{
AccountSenderId = template.AccountSenderId,
ReceiverAccountNumber = template.AccountNumber,
Amount = amount,
Comment = template.Comment,
TemplateId = template.Id,
Template = template,
SaveInTempalte = false
}
};
if (template.UserInfo != null)
{
model.Transfer.UserAccounts = selectListService.GetUserAccounts(template.UserInfo.Id);
}
if (template.Company != null)
{
model.Transfer.UserAccounts = selectListService.GetCompanyAccounts(template.Company.Id);
}
return(View("InterTransfer", model));
}
private async Task CreateTransferFromTemplate(Template template)
{
//Нельзя использовать один экземпляр ApplicationContext в разных потоках
var transferService = serviceProvider.GetService <ITransferService>();
//var accountService = serviceProvider.GetService<IAccountService>();
//if( await accountService.IsBalanceEnough(template.AccountSender.Id, template.Amount))
if (template.Type.IsEqual(TypeOfTransfersEnum.InnerTransfer))
{
InnerTransfer transfer = await transferService.CreateInnerTransfer(template.AccountSender, template.AccountReceiver, template.Amount,
template.Comment, null, null, null);
transferService.AddTransfer(transfer);
}
else if (template.Type.IsEqual(TypeOfTransfersEnum.InterBankTransfer))
{
InnerTransfer transfer = await
transferService.CreateInnerTransfer(template.AccountSender, template.AccountReceiver, template.Amount, template.Comment, null, null, null);
transferService.AddTransfer(transfer);
InterBankTransferViewModel model = new InterBankTransferViewModel
{
Transfer = new InnerTransferViewModel
{
ReceiverAccountNumber = template.AccountNumber
},
ReciverName = template.ReciverName,
BankId = template.BankId,
PaymentCodeId = template.PaymentCodeId
};
transferService.CreateInterBankTransfer(model, transfer);
}
}
public IActionResult CreateTemplateInterBankTransfer()
{
User user = userService.FindUserByName(HttpContext.User.Identity.Name);
InterBankTransferViewModel model = new InterBankTransferViewModel {
Banks = selectListService.GetBankList(), PaymentCode = selectListService.GetPayemntCodeList(),
Transfer = new InnerTransferViewModel()
};
model.Transfer = transferService.GetMethodInnerTransfer(user, model.Transfer);
CreateTemplateInterBankTransferViewModel modelTemplate =
new CreateTemplateInterBankTransferViewModel
{
Transfer = model,
Template = new TemplateViewModel
{
PaymentScheduleViewModel = new PaymentScheduleViewModel
{
IntervalTypes = selectListService.GetIntervalTypes(),
DateStart = DateTime.Now.AddDays(1)
}
}
};
return(View(modelTemplate));
}
public IActionResult InterTransfer()
{
User user = userService.FindUserByName(HttpContext.User.Identity.Name);
InterBankTransferViewModel model = new InterBankTransferViewModel {
Banks = selectListService.GetBankList(), PaymentCode = selectListService.GetPayemntCodeList(), Transfer = new InnerTransferViewModel()
};
model.Transfer = transferService.GetMethodInnerTransfer(user, model.Transfer);
return(View(model));
}
public Template CreateTemplateInterTransfer(Template template, InterBankTransferViewModel model)
{
TypeOfTransfer type = context.TypeOfTransfers.FirstOrDefault(n => n.IsEqual(TypeOfTransfersEnum.InterBankTransfer));
template.BankId = model.BankId;
template.PaymentCodeId = model.PaymentCodeId;
template.AccountNumber = model.Transfer.ReceiverAccountNumber;
template.ReciverName = model.ReciverName;
template.Type = type;
context.Templates.Update(template);
context.SaveChanges();
return(template);
}
public InterBankTransfer CreateInterBankTransfer(InterBankTransferViewModel model, InnerTransfer innerTransfer)
{
if (!innerTransfer.AccountSender.Locked)
{
InterBankTransfer transfer = new InterBankTransfer
{
AccountNumber = model.Transfer.ReceiverAccountNumber,
ReciverName = model.ReciverName,
BankId = model.BankId,
PaymentCodeId = model.PaymentCodeId,
InnerTransferId = innerTransfer.Id
};
context.Add(transfer);
context.SaveChanges();
return(transfer);
}
return(null);
}
public async Task <IActionResult> InterTransfer(InterBankTransferViewModel model)
{
decimal amount = 0;
Account receiver = accountService.OurBankAccount();
Account sender = accountService.FindAccountById((int)model.Transfer.AccountSenderId).Result;
User user = userService.FindUserByName(HttpContext.User.Identity.Name);
EmployeeAccount Limit = new EmployeeAccount();
string comment = "Межбанковский платеж - " + model.Transfer.Comment;
model.Transfer.Comment = comment;
if (model.Transfer.AccountSenderId == null)
{
ModelState.AddModelError("Transfer.AccountSenderId", localizer["AccountSenderIdValidation"]);
}
else
{
Limit = accountService.FindEmployeeAccountByUserIdAndAccountId(user.Id, model.Transfer.AccountSenderId.Value);
if (sender.Locked)
{
ModelState.AddModelError("Transfer.AccountSenderId", "*Счет заблокирован");
}
else if (!await accountService.IsUserHaveRightsOnAccount(user, model.Transfer.AccountSenderId.Value))
{
ModelState.AddModelError("Transfer.AccountSenderId", "У вас нет прав на совершение данного перевода.");
}
else if (await accountService.IsAccountExist(receiver.Number) && await accountService.CompareAccountsCurrencies(receiver.Number, (int)model.Transfer.AccountSenderId))
{
ModelState.AddModelError("Transfer.AccountSenderId", localizer["*Межбанковский перевод провидиться в национальной валюте"]);
}
if (!accountService.AmountTryParse(model.Transfer.Amount, out amount))
{
ModelState.AddModelError("Transfer.Amount", localizer["AmountFormatValidation"]);
}
else if (amount <= 0)
{
ModelState.AddModelError("Transfer.Amount", localizer["AmountNotNull"]);
}
else if (!await accountService.IsBalanceEnough((int)model.Transfer.AccountSenderId, amount))
{
ModelState.AddModelError("Transfer.Amount", localizer["IsBalanceEnoughValidation"]);
}
else if (Limit.limit.LimitAmount < amount)
{
ModelState.AddModelError("Transfer.Amount", string.Format("{0} {1}", localizer["ExceededTheLimit"], Limit.limit.LimitAmount));
}
}
if (ModelState.IsValid)
{
InnerTransfer transfer = await
transferService.CreateInnerTransfer(sender, receiver, amount, model.Transfer.Comment, null, null, null);
transferService.AddTransfer(transfer);
InterBankTransfer interTransfer = transferService.CreateInterBankTransfer(model, transfer);
if (model.Transfer.SaveInTempalte)
{
Template template = _templateServiceService.SaveTemplateInterTransfer(interTransfer, user);
return(RedirectToAction("TemplateSave", "Template", new { tempalteId = template.Id }));
}
return(RedirectToAction("Transfer", "Transfer"));
}
Template templates = _templateServiceService.FindTemplateById(model.Transfer.TemplateId);
if (templates != null)
{
model.Transfer.Template = templates;
}
model.Banks = selectListService.GetBankList();
model.PaymentCode = selectListService.GetPayemntCodeList();
model.Transfer = transferService.GetMethodInnerTransfer(user, model.Transfer);
return(View(model));
}