vrnp/main.go

package main

import "encoding/json"
import "fmt"
import "log"
import "net/http"
import "net/url"
import "os"
import "slices"
import "strconv"
import "time"

type DMResponse struct {
	Departures []DMDeparture `json:"departureList"`
}

type DMDeparture struct {
	StopName      string        `json:"stopName"`
	Platform      string        `json:"platform"`
	Countdown     string        `json:"countdown"`
	DateTime      DMDateTime    `json:"dateTime"`
	RealDateTime  *DMDateTime   `json:"realDateTime"`
	ServingLine   DMServingLine `json:"servingLine"`
	OnwardStopSeq []DMStop      `json:"onwardStopSeq"`
}

type DMServingLine struct {
	Symbol    string `json:"symbol"`
	Direction string `json:"direction"`
}

type DMStop struct {
	PlaceID string `json:"placeID"`
	Place   string `json:"place"`
	NameWO  string `json:"nameWO"`
}

type DMDateTime struct {
	Hour   string `json:"hour"`
	Minute string `json:"minute"`
}

func FetchDepartures(stopId string) (*DMResponse, error) {
	// Create request object
	req, err := http.NewRequest("GET", "https://www.vrn.de/mngvrn/XML_DM_REQUEST", nil)
	if err != nil {
		return nil, err
	}

	// Configure our request
	query := url.Values{}
	query.Set("coordOutputFormat", "EPSG:4326")
	query.Set("depType", "stopEvents")
	query.Set("includeCompleteStopSeq", "1")
	query.Set("limit", "10")
	query.Set("locationServerActive", "0")
	query.Set("mode", "direct")
	query.Set("name_dm", stopId)
	query.Set("outputFormat", "json")
	query.Set("type_dm", "stop")
	query.Set("useOnlyStops", "1")
	query.Set("useRealtime", "1")
	req.URL.RawQuery = query.Encode()

	// Send the request, wait max 10 seconds
	client := http.Client{
		Timeout: 10 * time.Second,
	}
	res, err := client.Do(req)
	if err != nil {
		return nil, err
	}

	defer res.Body.Close()
	var dmResponse DMResponse
	err = json.NewDecoder(res.Body).Decode(&dmResponse)
	if err != nil {
		return nil, err
	}

	return &dmResponse, nil
}

func main() {
	password := os.Getenv("VRNP_PASSWORD")
	if len(password) == 0 {
		panic("Required environment variable VRNP_PASSWORD is not set");
	}

	http.HandleFunc("/departures", func(w http.ResponseWriter, r *http.Request) {
		user, pass, ok := r.BasicAuth()
		if !(ok && user == "admin" && pass == password) {
			http.Error(w, "You shall not pass", http.StatusUnauthorized)
			return
		}

		query := r.URL.Query()

		if query["stop_id"] == nil || len(query["stop_id"]) < 1 {
			http.Error(w, "Missing query parameter: stop_id", http.StatusBadRequest)
			return
		}
		stopId := query["stop_id"][0]

		var platform *string = nil
		if query["platform"] != nil && len(query["platform"]) != 0 {
			platform = &query["platform"][0]
		}

		ds, err := FetchDepartures(stopId)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		for _, d := range ds.Departures {
			if platform != nil {
				if d.Platform != *platform {
					continue
				}
			}

			direction := d.ServingLine.Direction
			if len(d.OnwardStopSeq) != 0 {
				last := d.OnwardStopSeq[len(d.OnwardStopSeq)-1]
				if slices.Contains([]string{"5", "6"}, last.PlaceID) {
					direction = last.NameWO
				}
			}

			leaving := fmt.Sprintf("%s min", d.Countdown)
			countdown, err := strconv.Atoi(d.Countdown)
			if err == nil {
				if countdown == 0 {
					leaving = "sofort"
				}
				if countdown > 20 {
					dt := d.DateTime
					if d.RealDateTime != nil {
						dt = *d.RealDateTime
					}
					leaving = fmt.Sprintf("%02s:%02s", dt.Hour, dt.Minute)
				}
			}

			fmt.Fprintf(w, "%2s %-22s %6s\n",
				d.ServingLine.Symbol,
				direction[:min(len(direction), 22)],
				leaving,
			)
		}
	})
	log.Fatal(http.ListenAndServe(":8000", nil))
}