Ejemplo n.º 1
0
        public async Task <BackendResponse <AccountDepositWithdrawResponse> > AccountDeposit([FromBody] AccountDepositWithdrawRequest request)
        {
            var account = _accountsCacheService.Get(request.ClientId, request.AccountId);

            var changeTransferLimit = _marginSettings.IsLive &&
                                      request.PaymentType == PaymentType.Transfer &&
                                      !IsCrypto(account.BaseAssetId);

            try
            {
                var transactionId = await _accountManager.UpdateBalanceAsync(account, Math.Abs(request.Amount),
                                                                             AccountHistoryType.Deposit, "Account deposit", request.TransactionId, changeTransferLimit);

                _operationsLogService.AddLog($"account deposit {request.PaymentType}", request.ClientId, request.AccountId, request.ToJson(), true.ToJson());

                return(BackendResponse <AccountDepositWithdrawResponse> .Ok(
                           new AccountDepositWithdrawResponse { TransactionId = transactionId }));
            }
            catch (Exception e)
            {
                await _log.WriteErrorAsync(nameof(AccountsBalanceController), "AccountDeposit", request?.ToJson(), e);

                return(BackendResponse <AccountDepositWithdrawResponse> .Error(e.Message));
            }
        }
Ejemplo n.º 2
0
        public async Task <OpenOrderBackendResponse> PlaceOrder([FromBody] OpenOrderBackendRequest request)
        {
            var code = await _identityGenerator.GenerateIdAsync(nameof(Order));

            var order = new Order
            {
                Id                = Guid.NewGuid().ToString("N"),
                Code              = code,
                CreateDate        = DateTime.UtcNow,
                ClientId          = request.ClientId,
                AccountId         = request.Order.AccountId,
                Instrument        = request.Order.Instrument,
                Volume            = request.Order.Volume,
                ExpectedOpenPrice = request.Order.ExpectedOpenPrice,
                TakeProfit        = request.Order.TakeProfit,
                StopLoss          = request.Order.StopLoss
            };

            var placedOrder = await _tradingEngine.PlaceOrderAsync(order);

            var result = BackendContractFactory.CreateOpenOrderBackendResponse(placedOrder);

            _consoleWriter.WriteLine($"action order.place for clientId = {request.ClientId}");
            _operationsLogService.AddLog("action order.place", request.ClientId, request.Order.AccountId, request.ToJson(), result.ToJson());

            return(result);
        }
Ejemplo n.º 3
0
        public void NotifyOrderChanged(Order order)
        {
            _rabbitMqNotifyService.OrderChanged(order);
            var queueName = QueueHelper.BuildQueueName(_marginSettings.RabbitMqQueues.OrderChanged.ExchangeName, _marginSettings.Env);

            _consoleWriter.WriteLine($"send order changed to queue {queueName}");
            _operationsLogService.AddLog($"queue {queueName}", order.ClientId, order.AccountId, null, order.ToJson());
        }
Ejemplo n.º 4
0
        void IEventConsumer <StopOutEventArgs> .ConsumeEvent(object sender, StopOutEventArgs ea)
        {
            var account   = ea.Account;
            var orders    = ea.Orders;
            var eventTime = _dateService.Now();
            var accountMarginEventMessage = AccountMarginEventMessageConverter.Create(account, true, eventTime);
            var accuracy = _assetsCache.GetAssetAccuracy(account.BaseAssetId);
            var totalPnl = Math.Round(orders.Sum(x => x.GetTotalFpl()), accuracy);

            _threadSwitcher.SwitchThread(async() =>
            {
                _operationsLogService.AddLog("stopout", account.ClientId, account.Id, "", ea.ToJson());

                var marginEventTask = _rabbitMqNotifyService.AccountMarginEvent(accountMarginEventMessage);

                _notifyService.NotifyAccountStopout(account.ClientId, account.Id, orders.Length, totalPnl);

                var notificationTask = SendMarginEventNotification(account.ClientId,
                                                                   string.Format(MtMessages.Notifications_StopOutNotification, orders.Length, totalPnl,
                                                                                 account.BaseAssetId));

                var clientEmail = await _clientAccountService.GetEmail(account.ClientId);

                var emailTask = !string.IsNullOrEmpty(clientEmail)
                    ? _emailService.SendStopOutEmailAsync(clientEmail, account.BaseAssetId, account.Id)
                    : Task.CompletedTask;

                await Task.WhenAll(marginEventTask, notificationTask, emailTask);
            });
        }
Ejemplo n.º 5
0
        void IEventConsumer <MarginCallEventArgs> .ConsumeEvent(object sender, MarginCallEventArgs ea)
        {
            var account   = ea.Account;
            var eventTime = _dateService.Now();
            var accountMarginEventMessage = AccountMarginEventMessageConverter.Create(account, false, eventTime);

            _threadSwitcher.SwitchThread(async() =>
            {
                if (LastNotifications.TryGetValue(account.Id, out var lastNotification) &&
                    lastNotification.AddMinutes(NotificationsTimeout) > eventTime)
                {
                    return;
                }

                var marginEventTask = _rabbitMqNotifyService.AccountMarginEvent(accountMarginEventMessage);

                _operationsLogService.AddLog("margin call", account.ClientId, account.Id, "", ea.ToJson());

                var marginUsageLevel = account.GetMarginUsageLevel();
                var marginUsedPerc   = marginUsageLevel == 0 ? 0 : 1 / marginUsageLevel;

                var notificationTask = SendMarginEventNotification(account.ClientId, string.Format(
                                                                       MtMessages.Notifications_MarginCall, marginUsedPerc,
                                                                       account.BaseAssetId));

                var emailTask = _emailService.SendMarginCallEmailAsync(account);

                await Task.WhenAll(marginEventTask, notificationTask, emailTask);

                LastNotifications.AddOrUpdate(account.Id, eventTime, (s, time) => eventTime);
            });
        }
Ejemplo n.º 6
0
        public async Task ProcessAccountChanged(AccountChangedMessage accountChangedMessage)
        {
            if (accountChangedMessage.EventType != AccountEventTypeEnum.Updated)
            {
                return;
            }

            var account   = accountChangedMessage.Account;
            var queueName = QueueHelper.BuildQueueName(_settings.MarginTradingFront.RabbitMqQueues.AccountChanged.ExchangeName, _settings.MarginTradingFront.Env);

            _consoleWriter.WriteLine($"Get account change from {queueName} queue for clientId = {account.ClientId}");
            var notificationId = await _clientNotificationService.GetNotificationId(account.ClientId);

            var userTopic = _realm.Services.GetSubject <NotifyResponse <MarginTradingAccountClientContract> >($"user.{notificationId}");

            var notifyResponse = new NotifyResponse <MarginTradingAccountClientContract>
            {
                Entity = account.ToClientContract(),
                Type   = NotifyEntityType.Account
            };

            userTopic.OnNext(notifyResponse);

            _operationsLog.AddLog($"topic user.{notificationId} (account changed)", account.ClientId, account.Id, null, notifyResponse.ToJson());
            _consoleWriter.WriteLine($"topic user.{notificationId} (account changed) for clientId = {account.ClientId}");

            var userUpdateTopic         = _realm.Services.GetSubject <NotifyResponse>($"user.updates.{notificationId}");
            var userUpdateTopicResponse = new NotifyResponse {
                Account = notifyResponse.Entity, Order = null
            };

            userUpdateTopic.OnNext(userUpdateTopicResponse);

            _operationsLog.AddLog($"topic user.updates.{notificationId} (account changed)", account.ClientId,
                                  account.Id, null, userUpdateTopicResponse.ToJson());
            _consoleWriter.WriteLine($"topic user.updates.{notificationId} (account changed) for clientId = {account.ClientId}");
        }