Example #1
0
 /// <summary>
 /// Создаёт экземпляр BalancesControllerProxy
 /// </summary>
 /// <param name="iLogger">Логгер</param>
 /// <returns></returns>
 public static IBalanceControllerProxy Create(IBalanceDtoManager balanceService,
                                              IBalanceStorageDtoManager balanceStorageService,
                                              ITransactionDtoManager transactionService,
                                              ILogger iLogger)
 {
     return(new BalancesControllerProxy(balanceService,
                                        balanceStorageService,
                                        transactionService,
                                        iLogger));
 }
Example #2
0
 /// <summary>
 /// Конструктор
 /// </summary>
 /// <param name="iLogger">Логгер</param>
 private BalancesControllerProxy(IBalanceDtoManager balanceService,
                                 IBalanceStorageDtoManager balanceStorageService,
                                 ITransactionDtoManager transactionService,
                                 ILogger iLogger)
 {
     _balanceService        = balanceService;
     _balanceStorageService = balanceStorageService;
     _transactionService    = transactionService;
     _iLogger = iLogger;
 }
Example #3
0
 /// <summary>
 /// ctor
 /// </summary>
 /// <param name="BalanceService">Менеджер балансов</param>
 /// <param name="ilogger">Логгер</param>
 public BalancesController(IBalanceDtoManager balanceService,
                           IBalanceStorageDtoManager balanceStorageService,
                           ITransactionDtoManager transactionService,
                           ILogger <BalancesController> ilogger)
 {
     _logger = ilogger;
     _BalancesControllerProxy = BalancesControllerProxy.Create(balanceService,
                                                               balanceStorageService,
                                                               transactionService,
                                                               _logger);
 }
Example #4
0
        /// <summary>
        /// Создание новой транзакции
        /// </summary>
        /// <param name="transaction">Данные транзакции</param>
        /// <param name="balanceService">Менеджер балансов</param>
        /// <returns>int</returns>
        public async Task <(bool, string, int)> CreateTransaction(TransactionAddDto transaction, IBalanceDtoManager balanceService)
        {
            try
            {
                //получить баланс отправителя
                var balanceSender = await balanceService.GetByUserIdAsync(transaction.UserId);

                if (!balanceSender.Item1)
                {
                    return(false, balanceSender.Item2, 400);
                }
                //проверить соотношение баланса отправителя и размер транзакции
                if (balanceSender.Item3.Value < transaction.Value)
                {
                    return(false, "Баланс отправителя меньше размера транзакции", 400);
                }
                if (transaction.Value <= 0)
                {
                    return(false, "Размер транзакции невозможен для исполнения (ноль или отрицательный)", 400);
                }
                //получить баланс получателя
                var balanceRecepient = await balanceService.GetByUserIdAsync(transaction.RecepientId);

                if (!balanceRecepient.Item1)
                {
                    return(false, balanceRecepient.Item2, 500);
                }
                //сформировать новую транзакцию на основе входящих данных
                var newT = new TransactionDto()
                {
                    ExecutionDate   = DateTime.Now,
                    Value           = transaction.Value,
                    BalanceStorages = new List <BalanceStorageDto>()
                };
                //сформировать список истории балансов для новой транзакции
                //1. Баланс отправителя до транзакции
                newT.BalanceStorages.Add(new BalanceStorageDto()
                {
                    UserId   = transaction.UserId,
                    IsSender = true,
                    IsBefore = true,
                    Value    = balanceSender.Item3.Value
                });
                //2. Баланс отправителя после транзакции
                newT.BalanceStorages.Add(new BalanceStorageDto()
                {
                    UserId   = transaction.UserId,
                    IsSender = true,
                    IsBefore = false,
                    Value    = balanceSender.Item3.Value - transaction.Value
                });
                //3. Баланс получателя до транзакции
                newT.BalanceStorages.Add(new BalanceStorageDto()
                {
                    UserId   = transaction.RecepientId,
                    IsSender = false,
                    IsBefore = true,
                    Value    = balanceRecepient.Item3.Value
                });
                //4. Баланс получателя после транзакции
                newT.BalanceStorages.Add(new BalanceStorageDto()
                {
                    UserId   = transaction.RecepientId,
                    IsSender = false,
                    IsBefore = false,
                    Value    = balanceRecepient.Item3.Value + transaction.Value
                });
                // добавить транзакцию
                var rezult = await AddAsync(newT);

                if (!rezult.Item1)
                {
                    return(false, rezult.Item2, 500);
                }
                // установить текущий баланс отправителю
                balanceSender.Item3.Value = balanceSender.Item3.Value - transaction.Value;
                var updatedEntity      = Mapper.Map <BalanceDto>(balanceSender.Item3);
                var rezultUpdateSender = await balanceService.UpdateAsync(updatedEntity);

                if (!rezultUpdateSender.Item1)
                {
                    return(false, rezultUpdateSender.Item2, 500);
                }
                // установить текущий баланс получателю
                balanceRecepient.Item3.Value = balanceRecepient.Item3.Value + transaction.Value;
                var rezultUpdateRecepient = await balanceService.UpdateAsync(balanceRecepient.Item3);

                if (!rezultUpdateRecepient.Item1)
                {
                    return(false, rezultUpdateRecepient.Item2, 500);
                }
                // сохранить изменения
                var rezultSave = await SaveChangesAsync();

                return(true, string.Empty, 200);
            }
            catch (Exception e)
            {
                return(false, e.Message, 500);
            }
        }