Esempio n. 1
0
        /// <summary>
        /// Processes the request async.
        /// </summary>
        public async override Task ProcessAsync()
        {
            try
            {
                RouterRequest routerReq = await Receive <RouterRequest>();

                Logging.Log($"Received router request from { ((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString() }. Data: { routerReq.ToString() }");

                RouterResponse routerRes = null;

                await Task.Run(() =>
                {
                    using (var routerProcessing = new Interop.RouterManaged(DataFeed.Full, routerReq))
                    {
                        routerProcessing.ObtainJourneys();
                        routerRes = routerProcessing.ShowJourneys();
                    }
                });

                Send(routerRes);

                Logging.Log($"Router response to { ((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString() } was successfully sent.");
            }
            catch (Exception ex)
            {
                Logging.Log($"Router request from { ((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString() } could not be processed. { Logging.LogException(ex) }");
            }
            Dispose();
        }
Esempio n. 2
0
        public JourneyResultsWindow(RouterResponse rResponse, string source, string target, DateTime dateTime, DockContent win = null) : this(win)
        {
            Results = rResponse;

            Text = $"{ Settings.Localization.Journeys } ({ rResponse.Journeys.Count }) - { source } - { target } - { dateTime.ToShortTimeString() } { dateTime.ToShortDateString() }";

            resultsWebBrowser.DocumentText = rResponse.TransformToHtml(Settings.JourneySimpleXslt.FullName, Settings.JourneySimpleCss.FullName, Settings.OnLoadActionsJavaScript.FullName);
        }
Esempio n. 3
0
        public JourneyResultsWindow(Journey journey, DockContent win = null) : this(win)
        {
            Results = new RouterResponse(new List <Journey> {
                journey
            });

            Text = $"{ Settings.Localization.Journey } - { DataFeedDesktop.Basic.Stops.FindByIndex(journey.JourneySegments[0].SourceStopID).Name } - { DataFeedDesktop.Basic.Stops.FindByIndex(journey.JourneySegments[journey.JourneySegments.Count - 1].TargetStopID).Name } - { journey.DepartureDateTime.ToShortTimeString() } { journey.DepartureDateTime.ToShortDateString() }";

            resultsWebBrowser.DocumentText = Results.Journeys[0].TransformToHtml(Settings.JourneyDetailXslt.FullName, Settings.JourneyDetailCss.FullName, Settings.OnLoadActionsJavaScript.FullName);
        }
Esempio n. 4
0
        public static async Task <RouterResponse> SendRouterRequestAsync(RouterRequest routerRequest, bool forceCache = false)
        {
            RouterResponse routerResponse = null;

            using (var routerProcessing = new RouterProcessing())
            {
                var cached = JourneyCached.Select(routerRequest.SourceStationID, routerRequest.TargetStationID);

                if (cached == null || (cached.ShouldBeUpdated || forceCache))
                {
                    try
                    {
                        if (!await CheckBasicDataValidity())
                        {
                            var results = cached?.FindResultsSatisfyingRequest(routerRequest);
                            return(results?.Journeys.Count == 0 ? null : results);
                        }

                        // Process the request immediately so the user does not have to wait until the caching is completed.

                        routerResponse = await routerProcessing.ProcessAsync(routerRequest, routerRequest.Count == -1?int.MaxValue : Settings.TimeoutDuration);

                        // Then update the cache.

#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                        if (cached != null && cached.ShouldBeUpdated && routerRequest.Count != -1 && CanBeCached)
                        {
                            Task.Run(async() => cached.UpdateCache(await routerProcessing.ProcessAsync(cached.ConstructNewRequest(), int.MaxValue)));
                        }
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                    }
                    catch (System.Net.WebException)
                    {
                        PlatformDependentSettings.ShowMessage(Settings.Localization.UnreachableHost);
                    }
                }

                else
                {
                    routerResponse = cached?.FindResultsSatisfyingRequest(routerRequest);
                    if (routerResponse?.Journeys.Count == 0)
                    {
                        routerResponse = await routerProcessing.ProcessAsync(routerRequest, Settings.TimeoutDuration);
                    }
                }
            }

            return(routerResponse);
        }
        public FindJourneyResultsPage(RouterResponse res, string source, string target)
        {
            InitializeComponent();

            Title = Settings.Localization.Journey + " " + source + " - " + target;

            Response = res;

            resultsWebView.Scripting = new JourneyScripting(resultsWebView, this);

            resultsWebView.Source = new HtmlWebViewSource
            {
                Html = Response.TransformToHtml(
                    PlatformDependentSettings.GetStream(Settings.JourneySimpleXslt),
                    PlatformDependentSettings.GetStream(Settings.JourneySimpleCss),
                    PlatformDependentSettings.GetStream(Settings.OnLoadActionsJavaScript)
                    )
            };
        }
        public FindJourneyResultsPage(Journey journey)
        {
            InitializeComponent();

            Title = Settings.Localization.Journey + " " +
                    DataFeedClient.Basic.Stops.FindByIndex(journey.JourneySegments.First().SourceStopID).ParentStation.Name + " - " +
                    DataFeedClient.Basic.Stops.FindByIndex(journey.JourneySegments.Last().TargetStopID).ParentStation.Name;

            Response = new RouterResponse(new List <Journey> {
                journey
            });

            resultsWebView.Scripting = new JourneyScripting(resultsWebView, this);

            resultsWebView.Source = new HtmlWebViewSource
            {
                Html = Response.Journeys[0].TransformToHtml(
                    PlatformDependentSettings.GetStream(Settings.JourneyDetailXslt),
                    PlatformDependentSettings.GetStream(Settings.JourneyDetailCss),
                    PlatformDependentSettings.GetStream(Settings.OnLoadActionsJavaScript)
                    )
            };
        }