public async Task DoWork(CancellationToken cancellationToken)
        {
            while (!cancellationToken.IsCancellationRequested)
            {
                _logger.Log(LogLevel.Information, "Call method privat api service");

                var rate  = _context.ExchangeRate.ToList().Last();
                var value = Convert.ToDateTime($"{DateTime.Now:dd.MM.yyyy}");

                if (!rate.DateRate.Equals(value))
                {
                    var info = await _privatApiService.LoadInfo();

                    _logger.Log(LogLevel.Information, "Dtos" + info);

                    try
                    {
                        _logger.Log(LogLevel.Information, "Start saving");

                        foreach (var dto in info)
                        {
                            var firstOrDefault = _context.Currency.FirstOrDefault(currency => currency.ShortName.Equals(dto.ccy));

                            _logger.Log(LogLevel.Information, $"Currency {firstOrDefault}");

                            var exchangeRate = new ExchangeRate
                            {
                                RateBuy  = dto.buy,
                                RateSale = dto.sale,
                                DateRate = Convert.ToDateTime($"{DateTime.Now:dd.MM.yyyy}")
                            };

                            _logger.Log(LogLevel.Information, $"Rate {exchangeRate}");

                            if (firstOrDefault != null)
                            {
                                firstOrDefault.ExchangeRate.Add(exchangeRate);
                                await _context.SaveChangesAsync(cancellationToken);
                            }

                            _logger.Log(LogLevel.Information, "End saving");
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e);
                        Console.WriteLine("Error from service");
                        _logger.Log(LogLevel.Error, e.Message);
                        throw;
                    }
                }

                await Task.Delay(86_400_000, cancellationToken);
            }
        }
        public async Task DoWork(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                _logger.Log(logLevel: LogLevel.Information, message: $"Update credit starting! {DateTime.Now}");

                //все активные кредиты
                var credits = _context.Credit.Where(predicate: c => c.Status).ToList();

                foreach (var credit in credits)
                {
                    var currentCredit = await _context.Credit
                                        .FirstOrDefaultAsync(x => x.IdCredit == credit.IdCredit, stoppingToken);

                    //общее количество платежей, которые должны были уже быть выплачены на текущий момент
                    var allDaysPayment = (int)(DateTime.Now.Date - credit.DateCredit.Date.Date).TotalDays;
                    //количество уже выплаченных дней
                    var countDaysPayment = _context.Payment.Count(x => x.IdCredit == credit.IdCredit);
                    //количество необходимых выплат
                    var mustPayment = allDaysPayment - countDaysPayment;

                    //если выплата не требуется или депозит был взят сегодня
                    if (mustPayment == 0 || credit.DateCredit.Date == DateTime.Now.Date)
                    {
                        continue;
                    }

                    //находим счет для снятия средств
                    var currentBankAccount = await _context.BankAccount
                                             .FirstOrDefaultAsync(x => x.IdAccount == credit.IdAccount, stoppingToken);

                    //расчет выплаты
                    var percentAmount = await CalcPercentAmount(credit);

                    //на сколько платежей хватит средств
                    var opportunityPaymentCount =
                        Convert.ToInt32(Math.Floor(currentBankAccount.Amount / percentAmount));

                    //если нет возможности оплатить ни одного срока
                    if (opportunityPaymentCount == 0)
                    {
                        //увеличение процентов
                        currentCredit.PercentCredit *= 2 * mustPayment;

                        //сообщаем о нехватке средств
                        await _mediator.Send(
                            request : new BankAccountOperationCommand(idAccount: credit.IdAccount,
                                                                      type: "Недостаточно средств (снятие по кредиту)", amount: 0),
                            cancellationToken : stoppingToken);

                        continue;
                    }

                    if (opportunityPaymentCount > 0 && opportunityPaymentCount < mustPayment)
                    {
                        //увеличение процентов
                        currentCredit.PercentCredit *= 2;

                        //сохраняем число возможных платежей для произведения снятия
                        mustPayment = opportunityPaymentCount;

                        //сообщаем о нехватке средств на все выплаты
                        await _mediator.Send(
                            request : new BankAccountOperationCommand(idAccount: credit.IdAccount,
                                                                      type: "Недостаточно средств (снятие по кредиту)", amount: 0),
                            cancellationToken : stoppingToken);

                        await _context.SaveChangesAsync(stoppingToken);
                    }

                    //наши необходимые снятия со счета
                    var paymentsData = new List <Payment>();
                    for (int i = 0; i < mustPayment; i++)
                    {
                        paymentsData.Add(new Payment()
                        {
                            IdCredit      = credit.IdCredit,
                            AmountPayment = percentAmount,
                            DatePayment   = DateTime.Now
                        });
                    }

                    await _context.Payment.AddRangeAsync(paymentsData, stoppingToken);

                    await _context.SaveChangesAsync(stoppingToken);

                    for (int i = 0; i < mustPayment; i++)
                    {
                        //снимаем средства
                        currentBankAccount.Amount -= percentAmount;

                        //Фиксируем снятия в операциях
                        await _mediator.Send(new BankAccountOperationCommand(
                                                 credit.IdAccount,
                                                 "Снятие по кредиту",
                                                 percentAmount), stoppingToken);
                    }
                }

                await Task.Delay(millisecondsDelay : 86_400_000, cancellationToken : stoppingToken);
            }
        }
        /// <summary>
        ///   Добавление кредита
        /// </summary>
        /// <param name="credit"></param>
        /// <returns></returns>
        public async Task AddCredit(Credit credit)
        {
            await _context.Credit.AddAsync(credit);

            await _context.SaveChangesAsync();
        }
Exemple #4
0
        public async Task AddAsync(T entity)
        {
            await Context.Set <T>().AddAsync(entity);

            await Context.SaveChangesAsync();
        }
Exemple #5
0
        public async Task AddDeposit(Deposit deposit)
        {
            await _context.Deposit.AddAsync(deposit);

            await _context.SaveChangesAsync();
        }