Пример #1
0
        public object Get(ReferenceDataRequest request)
        {
            var cacheKey = string.Format("{0}{1}", CacheKey, request.CompanyKey);
            var result   = _cacheClient.Get <ReferenceData>(cacheKey);

            if (result == null)
            {
                result = GetReferenceData(request.CompanyKey);
                _cacheClient.Add(cacheKey, result);
            }

            if (!request.WithoutFiltering)
            {
                result.VehiclesList  = FilterReferenceData(result.VehiclesList, _serverSettings.ServerData.IBS.ExcludedVehicleTypeId);
                result.CompaniesList = FilterReferenceData(result.CompaniesList, _serverSettings.ServerData.IBS.ExcludedProviderId);
            }

            var paymentSettings = _serverSettings.GetPaymentSettings(request.CompanyKey);

            var isChargeAccountPaymentEnabled = paymentSettings.IsChargeAccountPaymentEnabled;
            var isPayPalEnabled           = paymentSettings.PayPalClientSettings.IsEnabled;
            var isPaymentOutOfAppDisabled = paymentSettings.IsPaymentOutOfAppDisabled;

            IEnumerable <ListItem> filteredPaymentList = result.PaymentsList;

            if (!isChargeAccountPaymentEnabled)
            {
                filteredPaymentList = filteredPaymentList.Where(x => x.Id != ChargeTypes.Account.Id);
            }
            if (!isPayPalEnabled)
            {
                filteredPaymentList = filteredPaymentList.Where(x => x.Id != ChargeTypes.PayPal.Id);
            }
            if (isPaymentOutOfAppDisabled != OutOfAppPaymentDisabled.None)
            {
                filteredPaymentList = filteredPaymentList.Where(x => x.Id != ChargeTypes.PaymentInCar.Id);
            }

            result.PaymentsList = filteredPaymentList.ToList();

            return(result);
        }
Пример #2
0
        public static object ReferenceDataFromFieldName(string fieldName, string security, bool isOption, ReferenceDataRequest.RequestReference rreq)
        {
            string upper = fieldName.ToUpper();
            object result;

            if (upper == "CHAIN_TICKERS")
            {
                if (isOption)
                {
                    result = null;
                }
                else
                {
                    uint numPoints = 1;
                    string dtExp = null;
                    var optionality = ReferenceDataRequest.ElementReferenceArrayChainTickers.OptionalityEnum.call;

                    if (rreq.HasElement("overrides"))
                    {
                        var overrides = rreq["overrides"];
                        for (int i = 0; i < overrides.NumValues; i++)
                        {
                            var element = overrides.GetValueAsElement(i);

                            var fieldId = element["fieldId"].GetValueAsString();
                            var value = element["value"].GetValueAsString();

                            switch (fieldId.ToUpper())
                            {
                                case "CHAIN_POINTS_OVRD":
                                    numPoints = uint.Parse(value);
                                    break;
                                case "CHAIN_EXP_DT_OVRD":
                                    dtExp = value;
                                    break;
                                case "CHAIN_PUT_CALL_TYPE_OVRD":
                                    if (value.ToUpper() == "P")
                                        optionality = ReferenceDataRequest.ElementReferenceArrayChainTickers.OptionalityEnum.put;
                                    break;
                            }
                        }
                    }

                    ReferenceDataRequest.ElementReferenceArrayChainTickers chain = new ReferenceDataRequest.ElementReferenceArrayChainTickers(security, numPoints, dtExp, optionality);
                    result = chain;
                }
            }
            else if (upper.Contains("TICKER"))
            {
                result = security.Substring(0, security.IndexOf(' '));
            }
            else if (upper.Contains("OPT_EXPIRE_DT"))
            {
                if (security.EndsWith("COMDTY") || security.EndsWith("INDEX"))
                {
                    result = DateTime.Today.AddMonths(3);
                }
                else if (isOption)
                {
                    string strDate = security.Substring(security.LastIndexOf(' ') - 15, 6);
                    result = DateTime.ParseExact(strDate, "yyMMdd", null);
                }
                else
                    result = null;
            }
            else if (upper.Contains("TRADEABLE_DT"))
            {
                result = DateTime.Today.AddMonths(3);
            }
            else
            {
                result = RandomDataGenerator.RandomDouble();
            }

            return result;
        }
Пример #3
0
        private static void OnInitialisationStatus(object sender, EventArgs <bool> eventArgs)
        {
            Console.WriteLine("OnInitialisationStatus: {0}", eventArgs);

            if (eventArgs.Args)
            {
                _bloomberg.ToObservable(new[] { new SubscriptionRequest("VOD LN Equity", new[] { "BID", "ASK" }) })
                .ObserveOn(TaskPoolScheduler.Default)
                .Subscribe(
                    response =>
                {
                    Console.WriteLine("Subscription Received.");
                    Console.WriteLine("{0} - [{1}]", response.Ticker, string.Join(",", response.Data.Select(x => string.Format("{0}: {1}", x.Key, x.Value))));
                },
                    error => Console.WriteLine("Subscription Error: {0}", error),
                    () => Console.WriteLine("Subscription Completed."));

                _bloomberg.ToObservable(ReferenceDataRequest.Create(new[] { "VOD LN Equity", "TSCO LN Equity" }, new[] { "PX_LAST" }))
                .Subscribe(
                    response =>
                {
                    Console.WriteLine("Reference Data Received.");
                    foreach (var item in response)
                    {
                        if (item.Value.IsLeft)
                        {
                            Console.WriteLine("Ticker={0}, Error={1}", item.Key, item.Value.Left);
                        }
                        else
                        {
                            Console.WriteLine("{0} - [{1}]", item.Key, string.Join(",", item.Value.Right.Select(x => string.Format("{0}: {1}", x.Key, x.Value))));
                        }
                    }
                },
                    error => Console.WriteLine("Reference Data Error: {0}", error),
                    () => Console.WriteLine("Reference Data Completed."));

                _bloomberg.ToObservable(new SecurityEntitlementsRequest(new[] { "VOD LN Equity", "IBM US Equity" }))
                .Subscribe(
                    response =>
                {
                    Console.WriteLine("Security Entitlements Received.");
                    foreach (var item in response)
                    {
                        Console.WriteLine("Ticker={0}, Entitlements=[{1}]", item.Key, string.Join(",", item.Value.EntitlementIds));
                    }
                },
                    error => Console.WriteLine("Security Entitlements Error={0}", error),
                    () => Console.WriteLine("Security Entitlements Completed."));

                _bloomberg.ToObservable(IntradayTickRequest.Create("VOD LN Equity", new[] { EventType.BID, EventType.ASK, EventType.TRADE }, new DateTime(2015, 10, 16, 9, 0, 0), new DateTime(2015, 10, 16, 9, 10, 0)))
                .Subscribe(response =>
                {
                    Console.WriteLine("Intraday Ticks Received.");
                    Console.WriteLine("Ticker: {0}", response.Ticker);
                    foreach (var intradayTick in response.IntraDayTicks)
                    {
                        Console.WriteLine("  {0:yyyy-MM-dd HH:mm:ss.fff} - {1}: {2}", intradayTick.Time, intradayTick.EventType, intradayTick.Value);
                    }
                },
                           error => Console.WriteLine("Intraday Tick Error: {0}", error),
                           () => Console.WriteLine("Intraday Tick Completed."));

                _bloomberg.ToObservable(IntradayBarRequest.Create("VOD LN Equity", new DateTime(2015, 10, 16, 9, 0, 0), new DateTime(2015, 10, 16, 12, 00, 0), EventType.BID, 60))
                .Subscribe(
                    intradayBarResponse =>
                {
                    Console.WriteLine("Intraday Bar Received.");
                    Console.WriteLine("{0}: [{1}]", intradayBarResponse.Ticker, string.Join(",", intradayBarResponse.IntradayBars.Select(intradayBar => string.Format("Open={0}, High={1}, Low={2}, Close={3}, Volume={4}, NumEvents={5}", intradayBar.Open, intradayBar.High, intradayBar.Low, intradayBar.Close, intradayBar.Volume, intradayBar.NumEvents))));
                },
                    error => Console.WriteLine("Intraday Bar Error: {0}", error),
                    () => Console.WriteLine("Intraday Bars complete"));

                _bloomberg.ToObservable(HistoricalDataRequest.Create(new[] { "VOD LN Equity", "TSCO LN Equity" }, new[] { "PX_LAST" }, DateTime.Today.AddMonths(-2), DateTime.Today, PeriodicitySelection.DAILY))
                .Subscribe(
                    response =>
                {
                    Console.WriteLine("Historical Data Received");
                    foreach (var item in response)
                    {
                        if (item.Value.IsLeft)
                        {
                            Console.WriteLine("Ticker={0}, SecurityError={1}", item.Key, item.Value.Left);
                        }
                        else
                        {
                            Console.WriteLine("Ticker={0}", item.Key);
                            foreach (var dateAndFields in item.Value.Right)
                            {
                                Console.WriteLine("  Date: {0}", dateAndFields.Key);
                                foreach (var nameAndValue in dateAndFields.Value)
                                {
                                    Console.WriteLine("    {0}: {1}", nameAndValue.Key, nameAndValue.Value);
                                }
                            }
                        }
                    }
                },
                    error => Console.WriteLine("Historical Data Error: {0}", error),
                    () => Console.WriteLine("Historical Data Completed."));

                _bloomberg.RequestToken().Done(token => Console.WriteLine("Token={0}", token));

                Console.WriteLine("It's asynchronous");
            }
        }
 public IObservable <ReferenceDataResponse> ToObservable(ReferenceDataRequest request)
 {
     return(_referenceDataManager.ToObservable(request));
 }