klhztrader/KLHZ.Trader.Core/Exchange/Utils/TraderUtils.cs

using KLHZ.Trader.Core.Common;
using KLHZ.Trader.Core.Contracts.Declisions.Dtos.Enums;
using KLHZ.Trader.Core.Contracts.Messaging.Dtos.Interfaces;
using KLHZ.Trader.Core.DataLayer.Entities.Prices;
using KLHZ.Trader.Core.Exchange.Interfaces;
using KLHZ.Trader.Core.Exchange.Models.AssetsAccounting;

namespace KLHZ.Trader.Core.Exchange.Utils
{
    internal static class TraderUtils
    {
        internal static Dictionary<TradingEvent, decimal> MergeResultsMult(IDictionary<TradingEvent, decimal> result, IDictionary<TradingEvent, decimal> data)
        {
            var res = new Dictionary<TradingEvent, decimal>();
            foreach (var k in result.Keys)
            {
                var valRes = result[k];
                var valData = data[k];
                res[k] = valRes * valData;
            }
            return res;
        }

        internal static Dictionary<TradingEvent, decimal> MergeResultsMax(IDictionary<TradingEvent, decimal> result, IDictionary<TradingEvent, decimal> data)
        {
            var res = new Dictionary<TradingEvent, decimal>();
            foreach (var k in result.Keys)
            {
                var valRes = result[k];
                var valData = result[k];
                res[k] = System.Math.Max(valRes, valData);
            }
            return res;
        }

        internal static Dictionary<TradingEvent, decimal> GetInitDict(decimal initValue)
        {
            var values = Enum.GetValues<TradingEvent>();
            return values.ToDictionary(v => v, v => initValue);
        }

        internal static bool IsOperationAllowed(IManagedAccount account, decimal boutPrice, decimal count,
    decimal accountCashPartFutures, decimal accountCashPart)
        {
            if (!BotModeSwitcher.CanPurchase()) return false;

            var balance = account.Balance;
            var total = account.Total;

            var futures = account.Assets.Values.FirstOrDefault(v => v.Type == AssetType.Futures);
            if (futures != null)
            {
                if ((balance - boutPrice * count) / total < accountCashPartFutures) return false;
            }
            else
            {
                if ((balance - boutPrice * count) / total < accountCashPart) return false;
            }

            return true;
        }

        internal static ITradeDataItem FilterHighFreqValues(ITradeDataItem message, Dictionary<string, List<ITradeDataItem>> pricesCache1)
        {
            if (!pricesCache1.TryGetValue(message.Figi, out var list))
            {
                list = new List<ITradeDataItem>();
                pricesCache1[message.Figi] = list;
            }
            list.Add(message);

            if ((list.Last().Time - list.First().Time).TotalSeconds < 0.5)
            {
                list.Add(message);
                return message;
            }
            else
            {
                message = new PriceChange()
                {
                    Figi = message.Figi,
                    Ticker = message.Ticker,
                    Count = list.Sum(l => l.Count),
                    Direction = message.Direction,
                    IsHistoricalData = message.IsHistoricalData,
                    Time = message.Time,
                    Price = list.Sum(l => l.Price) / list.Count
                };
                list.Clear();
                return message;
            }
        }

    }
}