back to simpler

Author: drewda

server/directions/awsrouter/awsrouter.go

@@ -66,13 +66,6 @@ func NewRouter(lc LocationClient, calculator string) *Router {
 	}
 }
 
-func (h *Router) Capabilities() directions.Capabilities {
-	return directions.Capabilities{
-		SupportedModes:   []model.StepMode{model.StepModeAuto, model.StepModeWalk},
-		SupportsArriveBy: false,
-	}
-}
-
 func (h *Router) Request(ctx context.Context, req model.DirectionRequest) (*model.Directions, error) {
 	// Input validation
 	if err := directions.ValidateDirectionRequest(req); err != nil {

server/directions/directions.go

@@ -11,15 +11,8 @@ import (
 	"github.com/interline-io/transitland-lib/server/model"
 )
 
-// Capabilities describes what a routing handler supports.
-type Capabilities struct {
-	SupportedModes   []model.StepMode
-	SupportsArriveBy bool
-}
-
 type Handler interface {
 	Request(context.Context, model.DirectionRequest) (*model.Directions, error)
-	Capabilities() Capabilities
 }
 
 type handlerFunc func() Handler
@@ -81,13 +74,6 @@ func HandleRequest(ctx context.Context, pref string, req model.DirectionRequest)
 		return &model.Directions{Success: false, Exception: &a}, nil
 	}
 
-	// Validate request against handler capabilities
-	caps := handler.Capabilities()
-	if req.ArriveBy != nil && *req.ArriveBy && !caps.SupportsArriveBy {
-		a := "arrive_by is not supported by this routing provider"
-		return &model.Directions{Success: false, Exception: &a}, nil
-	}
-
 	// Call the handler
 	h, err := handler.Request(ctx, req)
 	a := log.For(ctx).Trace()

server/directions/directions_test.go

@@ -42,13 +42,6 @@ func MakeBasicTests() map[string]model.DirectionRequest {
 			To:       &BaseTo,
 			DepartAt: &BaseTime,
 		},
-		"transit_arrive_by": {
-			Mode:     model.StepModeTransit,
-			From:     &BaseFrom,
-			To:       &BaseTo,
-			DepartAt: &BaseTime,
-			ArriveBy: ptrBool(true),
-		},
 		"no_dest_fail": {
 			Mode:     model.StepModeWalk,
 			From:     &BaseFrom,
@@ -107,6 +100,3 @@ func HandlerTest(t *testing.T, h directions.Handler, tc TestCase) *model.Directi
 	return ret
 }
 
-func ptrBool(v bool) *bool {
-	return &v
-}

server/directions/directionstest/directionstest.go

@@ -25,13 +25,6 @@ type Router struct {
 	Clock clock.Clock
 }
 
-func (h *Router) Capabilities() directions.Capabilities {
-	return directions.Capabilities{
-		SupportedModes:   []model.StepMode{model.StepModeAuto, model.StepModeBicycle, model.StepModeWalk, model.StepModeTransit, model.StepModeLine},
-		SupportsArriveBy: false,
-	}
-}
-
 func (h *Router) Request(ctx context.Context, req model.DirectionRequest) (*model.Directions, error) {
 	// Prepare response
 	ret := model.Directions{

server/directions/linerouter/linerouter.go

@@ -60,13 +60,6 @@ func NewRouter(client *http.Client, endpoint string, apikey string) *Router {
 	}
 }
 
-func (h *Router) Capabilities() directions.Capabilities {
-	return directions.Capabilities{
-		SupportedModes:   []model.StepMode{model.StepModeTransit, model.StepModeWalk, model.StepModeBicycle},
-		SupportsArriveBy: true,
-	}
-}
-
 func (h *Router) Request(ctx context.Context, req model.DirectionRequest) (*model.Directions, error) {
 	if err := directions.ValidateDirectionRequest(req); err != nil {
 		return &model.Directions{Success: false, Exception: aws.String("invalid input")}, nil

server/directions/tlrouter/tlrouter.go

@@ -57,13 +57,6 @@ func NewRouter(client *http.Client, endpoint string, apikey string) *Router {
 	}
 }
 
-func (h *Router) Capabilities() directions.Capabilities {
-	return directions.Capabilities{
-		SupportedModes:   []model.StepMode{model.StepModeAuto, model.StepModeBicycle, model.StepModeWalk},
-		SupportsArriveBy: true,
-	}
-}
-
 func (h *Router) Request(ctx context.Context, req model.DirectionRequest) (*model.Directions, error) {
 	if err := directions.ValidateDirectionRequest(req); err != nil {
 		return &model.Directions{Success: false, Exception: aws.String("invalid input")}, nil
@@ -78,7 +71,7 @@ func (h *Router) Request(ctx context.Context, req model.DirectionRequest) (*mode
 		input.Costing = "auto"
 	case model.StepModeBicycle:
 		input.Costing = "bicycle"
-	case model.StepModeWalk:
+	case model.StepModeWalk, model.StepModeTransit:
 		input.Costing = "pedestrian"
 	default:
 		return &model.Directions{Success: false, Exception: aws.String("unsupported travel mode")}, nil
@@ -97,27 +90,14 @@ func (h *Router) Request(ctx context.Context, req model.DirectionRequest) (*mode
 	// Ensure we are in UTC
 	departAt = departAt.In(time.UTC)
 
-	// Set date_time for time-aware routing
-	arriveBy := req.ArriveBy != nil && *req.ArriveBy
-	if req.DepartAt != nil {
-		dtType := 1 // depart_at
-		if arriveBy {
-			dtType = 2 // arrive_by
-		}
-		input.DateTime = &DateTime{
-			Type:  dtType,
-			Value: departAt.Format("2006-01-02T15:04"),
-		}
-	}
-
 	// Make request
 	res, err := makeRequest(ctx, input, h.client, h.endpoint, h.apikey)
 	if err != nil || len(res.Trip.Legs) == 0 {
 		log.For(ctx).Error().Err(err).Msg("valhalla router failed to calculate route")
 		return &model.Directions{Success: false, Exception: aws.String("could not calculate route")}, nil
 	}
 	// Prepare response
-	ret := makeDirections(res, departAt, arriveBy)
+	ret := makeDirections(res, departAt)
 	ret.Origin = wpiWaypoint(req.From)
 	ret.Destination = wpiWaypoint(req.To)
 	ret.Success = true
@@ -154,7 +134,7 @@ func makeRequest(ctx context.Context, req Request, client *http.Client, endpoint
 	return &res, nil
 }
 
-func makeDirections(res *Response, requestedTime time.Time, arriveBy bool) *model.Directions {
+func makeDirections(res *Response, departAt time.Time) *model.Directions {
 	// Create itinerary summary
 	itin := model.Itinerary{}
 
@@ -166,15 +146,8 @@ func makeDirections(res *Response, requestedTime time.Time, arriveBy bool) *mode
 	ret.EndTime = &itin.EndTime
 	ret.DataSource = aws.String("OSM")
 
-	// When arrive_by is set, requestedTime is the desired arrival time;
-	// compute the actual start time by subtracting the total duration.
-	startAt := requestedTime
-	if arriveBy {
-		startAt = requestedTime.Add(-time.Duration(res.Trip.Summary.Time) * time.Second)
-	}
-
 	// Create legs for itinerary
-	prevLegDepartAt := startAt
+	prevLegDepartAt := departAt
 	for _, vleg := range res.Trip.Legs {
 		// Decode shape using custom 1e6 scale
 		shapeDecoder := polyline.Codec{
@@ -255,8 +228,8 @@ func makeDirections(res *Response, requestedTime time.Time, arriveBy bool) *mode
 	// Add summary
 	itin.Duration = makeDuration(res.Trip.Summary.Time)
 	itin.Distance = makeDistance(res.Trip.Summary.Length, res.Units)
-	itin.StartTime = startAt
-	itin.EndTime = startAt.Add(time.Duration(res.Trip.Summary.Time) * time.Second)
+	itin.StartTime = departAt
+	itin.EndTime = departAt.Add(time.Duration(res.Trip.Summary.Time) * time.Second)
 	itin.From = itin.Legs[0].From
 	itin.To = itin.Legs[0].To
 	ret.Duration = itin.Duration
@@ -269,13 +242,6 @@ func makeDirections(res *Response, requestedTime time.Time, arriveBy bool) *mode
 type Request struct {
 	Locations []RequestLocation `json:"locations"`
 	Costing   string            `json:"costing"`
-	DateTime  *DateTime         `json:"date_time,omitempty"`
-}
-
-type DateTime struct {
-	// Type: 0 = current depart, 1 = depart_at, 2 = arrive_by
-	Type  int    `json:"type"`
-	Value string `json:"value"`
 }
 
 type RequestLocation struct {