public async void AddTransfer(InnerTransfer transfer)
{
if (transfer.AccountSender != null && !transfer.AccountSender.Locked)
{
await context.AddAsync(transfer);
if (transfer.TransferState.IsEqual(TransferStatesEnum.Confirmed))
{
List <Transaction> transactions = transactionService.CreateTransactions(transfer);
transactionService.AddTransactions(transactions);
}
context.SaveChanges();
}
if (transfer.AccountSender == null)
{
await context.AddAsync(transfer);
if (transfer.TransferState.IsEqual(TransferStatesEnum.Confirmed))
{
List <Transaction> transactions = transactionService.CreateTransactions(transfer);
transactionService.AddTransactions(transactions);
}
context.SaveChanges();
}
}
public async Task <IActionResult> AddMoneyUserAccount(AddMoneyViewModel model)
{
Account sender = null;
Account receiver = accountService.FindAccountById(model.Account.Id).Result;
string comment = "Пополнение";
decimal amount = 0;
if (!accountService.AmountTryParse(model.Amount, out amount))
{
ModelState.AddModelError("Amount", localizer["AmountFormatValidation"]);
}
else if (amount <= 0)
{
ModelState.AddModelError("Amount", localizer["AmountNotNull"]);
}
if (ModelState.IsValid)
{
InnerTransfer transfer = await
transferService.CreateInnerTransfer(sender, receiver, amount, comment, null, null, null);
transferService.AddTransfer(transfer);
if (receiver.UserInfoId != null)
{
return(RedirectToAction("UserAccounts", "Account", new { userId = receiver.UserInfo.User.Id }));
}
else if (receiver.CompanyId != null)
{
return(RedirectToAction("Index", "Account", new { companyId = receiver.CompanyId }));
}
}
model.Account = receiver;
return(View(model));
}
public async Task <IActionResult> Reject(int transferId)
{
User user = userService.FindUserByName(HttpContext.User.Identity.Name);
EmployeeInfo employee = await employeeService.GetEmployeeInfoByUserId(user.Id);
InnerTransfer transfer = await transferService.FindTransferById(transferId);
if (transfer == null)
{
return(Json(new { message = "Такого платежа не существует!!!", state = false }));
}
Account account = await accountService.FindAccountById(transfer.AccountSenderId.Value);
if (!transferService.GetEmployeeRightOfConfirm(employee, account))
{
return(Json(new { message = "Не удалось подтвердить платеж. Ошибка доступа.", state = false }));
}
if (!transfer.TransferState.IsEqual(TransferStatesEnum.NotConfirmed))
{
return(Json(new { message = "Платеж уже подтвержден.", state = true }));
}
await transferService.CancelTransfer(transferId);
return(Json(new { message = "Платеж отменен", state = true }));
}
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 async Task <InnerTransfer> FindTransferById(int transferId)
{
InnerTransfer transfer = await context.InnerTransfers.Include(t => t.TransferState)
.Include(t => t.AccountSender).Include(t => t.AccountReceiver).FirstOrDefaultAsync(t => t.Id == transferId);
return(transfer);
}
public List <Transaction> CreateTransactions(InnerTransfer transfer)
{
List <Transaction> transactions = new List <Transaction>();
if (transfer.AmountReceive == null)
{
if (transfer.AccountReceiverId != null)
{
Transaction transaction = new Transaction
{
AccountId = (int)transfer.AccountReceiverId,
Amount = transfer.Amount,
TransactionTypeId = FindTransactionTypeByName(TransactionTypesEnum.Debit).Id,
DateOfTransaction = DateTime.Now
};
transactions.Add(transaction);
}
if (transfer.AccountSenderId != null)
{
Transaction transaction = new Transaction
{
AccountId = (int)transfer.AccountSenderId,
Amount = transfer.Amount,
TransactionTypeId = FindTransactionTypeByName(TransactionTypesEnum.Credit).Id,
DateOfTransaction = DateTime.Now
};
transactions.Add(transaction);
}
}
else
{
Transaction transactionReceive = new Transaction
{
AccountId = (int)transfer.AccountReceiverId,
Amount = (decimal)transfer.AmountReceive,
TransactionTypeId = FindTransactionTypeByName(TransactionTypesEnum.Debit).Id,
DateOfTransaction = DateTime.Now
};
transactions.Add(transactionReceive);
Transaction transactionSend = new Transaction
{
AccountId = (int)transfer.AccountSenderId,
Amount = (decimal)transfer.Amount,
TransactionTypeId = FindTransactionTypeByName(TransactionTypesEnum.Credit).Id,
DateOfTransaction = DateTime.Now
};
transactions.Add(transactionSend);
}
return(transactions);
}
public async Task CancelTransfer(int transferId)
{
InnerTransfer transfer = context.InnerTransfers.FirstOrDefault(t => t.Id == transferId);
if (transfer != null)
{
transfer.TransferState = await FindTransferStateByName(TransferStatesEnum.Canceled); // context.TransferStates.FirstOrDefault(s => s.IsEqual(TransferStatesEnum.Canceled)).Id;
transfer.TransferDate = DateTime.Now;
context.InnerTransfers.Update(transfer);
context.SaveChanges();
}
}
public void CheckCreatedTransactionsDebitOnly()
{
InnerTransfer transfer = new InnerTransfer
{
AccountReceiverId = 1,
Amount = 300,
Comment = "No Comments"
};
List <Transaction> transactions = transactionService.CreateTransactions(transfer);
transactionService.AddTransactions(transactions: transactions);
Assert.NotNull(context.Transactions.FirstOrDefault(t => t == transactions[0]));
}
public void CheckCreatedTransactionsCreditOnly()
{
ITransactionService service = new TransactionService(context);
InnerTransfer transfer = new InnerTransfer
{
AccountSenderId = 2,
Amount = 500,
Comment = "No Comments"
};
List <Transaction> transactions = service.CreateTransactions(transfer);
service.AddTransactions(transactions: transactions);
Assert.NotNull(context.Transactions.FirstOrDefault(t => t == transactions[0]));
}
public void CreateTransactionsDebitOnlyPropertiesValid()
{
InnerTransfer transfer = new InnerTransfer
{
AccountReceiverId = 1,
Amount = 100,
Comment = "No Comments"
};
List <Transaction> transactions = transactionService.CreateTransactions(transfer);
Assert.True(transactions.Count == 1);
Assert.Equal(transactions[0].AccountId, transfer.AccountReceiverId);
Assert.Equal(1, transactions[0].TransactionTypeId);
}
public async Task ConfirmTransfer(InnerTransfer transfer)
{
TransferState state = await FindTransferStateByName(TransferStatesEnum.NotConfirmed);
if (transfer.TransferStateId == state.Id)
{
List <Transaction> transactions = transactionService.CreateTransactions(transfer);
transactionService.AddTransactions(transactions);
transfer.TransferState = await FindTransferStateByName(TransferStatesEnum.Confirmed);
transfer.TransferDate = DateTime.Now;
context.InnerTransfers.Update(transfer);
context.SaveChanges();
}
}
public async Task <InnerTransfer> CreateInnerTransfer(Account sender, Account receiver, decimal amount, string comment,
decimal?amountReceive, int?exchangeRateId, int?exchangeRateIdSecond)
{
TransferState state = await FindTransferStateByName(TransferStatesEnum.Confirmed);
if (sender != null)
{
if (sender.UserInfoId == null)
{
state = await FindTransferStateByName(TransferStatesEnum.NotConfirmed);
}
if (!await accountService.IsBalanceEnough(sender.Id, amount))
{
state = await FindTransferStateByName(TransferStatesEnum.BalanceNotEnough);
}
if (sender.Locked)
{
state = await FindTransferStateByName(TransferStatesEnum.AccountIsLocked);
}
}
InnerTransfer transfer = new InnerTransfer
{
AccountSender = sender,
AccountReceiver = receiver,
Amount = amount,
Comment = comment,
TransferState = state,
TransferDate = DateTime.Now,
AmountReceive = amountReceive,
ExchangeRateId = exchangeRateId,
ExchangeRateIdSecond = exchangeRateIdSecond
};
return(transfer);
}
public Template SaveTemplate(InnerTransfer transfer, User user)
{
UserInfo userInfo = context.UserInfo.FirstOrDefault(u => u.UserId == user.Id);
EmployeeInfo employee =
context.EmployeeInfos.Include(c => c.Company).FirstOrDefault(e => e.UserId == user.Id);
TypeOfTransfer type =
context.TypeOfTransfers.FirstOrDefault(n => n.IsEqual(TypeOfTransfersEnum.InnerTransfer));
Template template = new Template
{
AccountSenderId = transfer.AccountSenderId,
AccountReceiverId = transfer.AccountReceiverId,
Amount = transfer.Amount,
Comment = transfer.Comment,
Type = type
};
AddUserIdTemplate(template, userInfo, employee);
context.Templates.Add(template);
context.SaveChanges();
return(template);
}
public void CreateTransactionsPropertiesValid()
{
Account accountReceiver = new Account {
Id = 1
};
Account accountSender = new Account {
Id = 2
};
InnerTransfer transfer = new InnerTransfer
{
AccountReceiverId = accountReceiver.Id,
AccountSenderId = accountSender.Id,
Amount = 100,
Comment = "No Comments"
};
List <Transaction> transactions = transactionService.CreateTransactions(transfer);
Assert.True(2 == transactions.Count);
Assert.Equal(transactions[0].AccountId, transfer.AccountReceiverId);
Assert.Equal(transactions[1].AccountId, transfer.AccountSenderId);
Assert.Equal(context.TransactionTypes.FirstOrDefault(t => t.IsEqual(TransactionTypesEnum.Debit)).Id, transactions[0].TransactionTypeId);
Assert.Equal(context.TransactionTypes.FirstOrDefault(t => t.IsEqual(TransactionTypesEnum.Credit)).Id, transactions[1].TransactionTypeId);
}
public async Task <IActionResult> InnerTransfer(InnerTransferViewModel model)
{
decimal amount = 0;
User user = userService.FindUserByName(HttpContext.User.Identity.Name);
Account sender = accountService.FindAccountById((int)model.AccountSenderId).Result;
await validationService.ValidateInnerTransfer(model, user, sender, ModelState);
string comment = "Внутрибанковский платеж - " + model.Comment;
model.Comment = comment;
if (ModelState.IsValid)
{
amount = decimal.Parse(model.Amount);
Account receiver = accountService.FindAccountByNumber(model.ReceiverAccountNumber).Result;
//decimal amountReceive;
//accountService.AmountTryParse(model.AmountReceive, out amountReceive);
InnerTransfer transfer = await
transferService.CreateInnerTransfer(sender, receiver, amount, model.Comment, null, null, null);
transferService.AddTransfer(transfer);
if (model.SaveInTempalte)
{
Template template = _templateServiceService.SaveTemplate(transfer, user);
return(RedirectToAction("TemplateSave", "Template", new { tempalteId = template.Id }));
}
return(RedirectToAction("Transfer", "Transfer"));
}
model = transferService.GetMethodInnerTransfer(user, model);
Template templates = _templateServiceService.FindTemplateById(model.TemplateId);
if (templates != null)
{
model.Template = templates;
}
return(View(model));
}
public async Task <IActionResult> UpdateTransferViewModel(int transferId)
{
InnerTransfer transfer = await transferService.FindTransferById(transferId);
string state = string.Empty;
if (transfer.TransferState.IsEqual(TransferStatesEnum.NotConfirmed))
{
state = "Не подтвержден";
}
if (transfer.TransferState.IsEqual(TransferStatesEnum.Confirmed))
{
state = "Завершен";
}
if (transfer.TransferState.IsEqual(TransferStatesEnum.Canceled))
{
state = "Отменен";
}
User user = userService.FindUserByName(HttpContext.User.Identity.Name);
EmployeeInfo employee = await employeeService.GetEmployeeInfoByUserId(user.Id);
bool actions = transferService.GetEmployeeRightOfConfirm(employee, transfer.AccountSender) &&
transfer.TransferState.IsEqual(TransferStatesEnum.NotConfirmed);
string date = transfer.TransferDate.ToString();
return(Json(new
{
senderAccount = transfer.AccountSender.Number,
receiverAccount = transfer.AccountReceiver.Number,
аmount = transfer.Amount,
comment = transfer.Comment,
date = date,
state = state,
actions = actions
}));
}
public InnerTransfer FindInnerTransferById(int innerTransferId)
{
InnerTransfer transfer = context.InnerTransfers.FirstOrDefault(t => t.Id == innerTransferId);
return(transfer);
}
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));
}
public async Task <IActionResult> ConvertUserCurrency(CurrencyConversionViewModel model)
{
User user = userService.FindUserByName(User.Identity.Name);
Account sender = accountService.FindAccountById(model.AccountSenderId).Result;
decimal amountSend = 0;
accountService.AmountTryParse(model.AmountSend, out amountSend);
await validationService.ValidateConvertUserCurrency(model, sender, ModelState, user);
if (ModelState.IsValid)
{
Account receiver = accountService.FindAccountById(model.AccountReceiverId).Result;
decimal amountReceive = 0;
accountService.AmountTryParse(model.AmountReceive, out amountReceive);
List <ExchangeRate> exchangeRateList = exchangeRateService.GetLastExchangeRatesByDate().ToList();
ExchangeRate exchangeRate = exchangeRateList.FirstOrDefault(r => r.CurrencyId == receiver.CurrencyId);
ExchangeRate exchangeRateSecond =
exchangeRateList.FirstOrDefault(r => r.CurrencyId == sender.CurrencyId);
if (exchangeRate == null)
{
exchangeRate = exchangeRateList.FirstOrDefault(u => u.CurrencyId == sender.CurrencyId);
}
if (exchangeRateSecond == null)
{
exchangeRateSecond = exchangeRateList.FirstOrDefault(u => u.CurrencyId == receiver.CurrencyId);
}
int exchangeRateId = exchangeRate.Id;
int exchangeRateIdSecond = exchangeRateSecond.Id;
InnerTransfer transfer = await
transferService.CreateInnerTransfer(sender, receiver, amountSend, "конвертация", amountReceive,
exchangeRateId, exchangeRateIdSecond);
transferService.AddTransfer(transfer);
ViewBag.successMessage = localizer["ConversionWasSuccessful"];
ConvertConversionToDocViewModel docModel = new ConvertConversionToDocViewModel()
{
Date = DateTime.Now.ToString(),
AccountFromNumber = sender.Number,
CurrencyFromName = sender.Currency.Name,
AmountSend = amountSend.ToString(),
AccountToNumber = receiver.Number,
CurrencyToName = receiver.Currency.Name,
AmountReceive = amountReceive.ToString(),
CurrencyFromRate = exchangeRate.RateForSale.ToString(),
CurrencyToRate = exchangeRateSecond.RateForPurchaise.ToString()
};
_docmodel = docModel;
PdfPTable table = createPdFandLoad.TableForConvertion(docModel);
string name = createPdFandLoad.CreatePDF(table);
ViewBag.FileName = name;
}
string userName = String.Empty;
int userId = 0;
UserInfo userInfo = userService.FindUserByIdInUserInfo(user.Id, ref userName, ref userId);
EmployeeInfo employeeInfo = userService.FindUserByIdInCompany(user.Id, ref userName, ref userId);
if (userInfo != null)
{
model.UserAccounts = selectListService.GetUserAccounts(userInfo.Id);
}
if (employeeInfo != null)
{
model.UserAccounts = selectListService.GetEmployeeAccounts(employeeInfo.Id);
}
return(View(model));
}
