public async Task <WLRoutingResponse> RequestTripAsync(TransitDirectionsRequest directionsRequest)
        {
            var query = HttpUtility.ParseQueryString(string.Empty);

            query["language"]         = "de";
            query["outputFormat"]     = "json";
            query["type_origin"]      = "coord";
            query["name_origin"]      = $"{directionsRequest.From.Lng.ToString(CultureInfo.InvariantCulture)}:{directionsRequest.From.Lat.ToString(CultureInfo.InvariantCulture)}:WGS84";
            query["type_destination"] = "coord";
            query["name_destination"] = $"{directionsRequest.To.Lng.ToString(CultureInfo.InvariantCulture)}:{directionsRequest.To.Lat.ToString(CultureInfo.InvariantCulture)}:WGS84";

            var timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById("W. Europe Standard Time");

            var viennaTime = directionsRequest.DateTime.ToOffset(timeZoneInfo.GetUtcOffset(directionsRequest.DateTime));

            query["itdTripDateTimeDepArr"] = directionsRequest.ArriveBy ? "arr" : "dep";
            query["itdDate"] = viennaTime.DateTime.ToString("yyyyMMdd", CultureInfo.InvariantCulture);
            query["itdTime"] = viennaTime.DateTime.ToString("HHmm");
            var res = await _client.GetAsync($"ogd_routing/XML_TRIP_REQUEST2?{query.ToString()}");

            if (res.StatusCode == System.Net.HttpStatusCode.NotFound)
            {
                return(null);
            }
            if (!res.IsSuccessStatusCode)
            {
                throw new Exception($"Request to WienerLinien returned : {res.StatusCode}");
            }
            var content = await res.Content.ReadAsStringAsync();

            return(JsonConvert.DeserializeObject <WLRoutingResponse>(content));
        }
Exemplo n.º 2
0
        public async Task <Models.Plan> GetDirectionsAsync(TransitDirectionsRequest request)
        {
            var res = await _openTripPlannerClient.Plan(new OpenTripPlannerRequest()
            {
                FromPlace = request.From,
                ToPlace   = request.To,
                ArriveBy  = request.ArriveBy,
                DateTime  = request.DateTime
            });

            return(res.ToPlan());
        }
        public async Task <Plan> GetDirectionsAsync(TransitDirectionsRequest r)
        {
            var request = new GoogleMapsApi.Entities.Directions.Request.DirectionsRequest()
            {
                Destination = FormatCoordinate(r.To),
                Origin      = FormatCoordinate(r.From),
                TravelMode  = GoogleMapsApi.Entities.Directions.Request.TravelMode.Transit,
                ApiKey      = options.GoogleMapsApiKey
            };

            if (r.ArriveBy)
            {
                request.ArrivalTime = r.DateTime.UtcDateTime;
            }
            else
            {
                request.DepartureTime = r.DateTime.UtcDateTime;
            }
            var res = await GoogleMapsApi.GoogleMaps.Directions.QueryAsync(request);

            if (!res.Routes.Any())
            {
                return(null);
            }
            var routes = res.Routes
                         .Where(v => v.Legs.Any() && v.Legs.First().Steps.Any(b => b.TravelMode == GoogleMapsApi.Entities.Directions.Request.TravelMode.Transit))
                         .Select(v => v.Legs.First()).Select(v => new Itinerary()
            {
                EndTime   = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).Add(v.ArrivalTime.Value),
                StartTime = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).Add(v.DepartureTime.Value),
                Legs      = v.Steps.Where(step => step.TravelMode == GoogleMapsApi.Entities.Directions.Request.TravelMode.Transit).Select(step => new Leg()
                {
                    To = null != step.TransitDetails?.ArrivalStop ? new Place()
                    {
                        Coordinate =
                            new Coordinate()
                        {
                            Lat = step.TransitDetails.ArrivalStop.Location.Latitude,
                            Lng = step.TransitDetails.ArrivalStop.Location.Longitude
                        },
                        Name = step.TransitDetails.ArrivalStop.Name
                    } : null,
                    From = null != step.TransitDetails?.DepartureStop ? new Place()
                    {
                        Coordinate =
                            new Coordinate()
                        {
                            Lat = step.TransitDetails.DepartureStop.Location.Latitude,
                            Lng = step.TransitDetails.DepartureStop.Location.Longitude
                        },
                        Name = step.TransitDetails.DepartureStop.Name
                    } : null,
                    Headsign = step.TransitDetails.Headsign,
                    Line     = null != step.TransitDetails.Lines ? new Models.Line()
                    {
                        Name        = step.TransitDetails.Lines.Name,
                        ShortName   = step.TransitDetails.Lines.ShortName,
                        VehicleType = "Unknown"
                    } : null,
                    EndTime   = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).Add(step.TransitDetails.ArrivalTime.Value),
                    StartTime = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).Add(step.TransitDetails.DepartureTime.Value),
                    NumStops  = step.TransitDetails.NumberOfStops
                }).ToArray()
            }).ToArray();

            return(new Plan()
            {
                Itineraries = routes
            });
        }
Exemplo n.º 4
0
        public async Task <Plan> GetDirectionsAsync(TransitDirectionsRequest request)
        {
            var directions = await _wienerLinienRoutingClient.RequestTripAsync(request);

            if (null == directions || directions.trips == null || !directions.trips.Any())
            {
                return(null);
            }

            var routes = directions.trips
                         .Select(d =>
            {
                Point departurePoint = d.trip.legs.First().points.Where(v => v.usage == "departure").Single();
                var departureTime    = ParseWLDateTime(departurePoint.dateTime);
                Point arrivalPoint   = d.trip.legs.Last().points.Where(v => v.usage == "arrival").Single();
                var arrivalTime      = ParseWLDateTime(arrivalPoint.dateTime);
                return(new Itinerary()
                {
                    EndTime = arrivalTime,
                    StartTime = departureTime,
                    Legs = d.trip.legs.Where(f => f.mode.type != "100").Select(v =>
                    {
                        Point legDeparturePoint = v.points.Where(e => e.usage == "departure").Single();
                        var legDepartureTime = ParseWLDateTime(legDeparturePoint.dateTime);
                        Point legArrivalPoint = v.points.Where(e => e.usage == "arrival").Single();
                        var legArrivalTime = ParseWLDateTime(legArrivalPoint.dateTime);
                        return new Models.Leg()
                        {
                            From = new Place()
                            {
                                Name = legArrivalPoint.name
                            },
                            To = new Place()
                            {
                                Name = legDeparturePoint.name
                            },
                            EndTime = legArrivalTime,
                            StartTime = legDepartureTime,
                            Headsign = v.mode.destination,
                            Line = new Models.Line()
                            {
                                Name = v.mode.name,
                                ShortName = v.mode.number,
                                VehicleType = v.mode.type
                            },
                            NumStops = v.stopSeq.Count()
                        };
                    }).ToArray(),
                });
            });
            IEnumerable <Itinerary> ordered;

            if (request.ArriveBy == false)
            {
                ordered = routes.OrderBy(r => Math.Abs((r.StartTime - request.DateTime).TotalSeconds));
            }
            else
            {
                ordered = routes.OrderBy(r => Math.Abs((r.EndTime - request.DateTime).TotalSeconds));
            }
            return(new Plan()
            {
                Itineraries = ordered.ToArray(),
            });
        }