szczanieckiej/traffic/feeds.go

package traffic

import (
	"apiote.xyz/p/szczanieckiej/config"
	"apiote.xyz/p/szczanieckiej/file"

	"fmt"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"time"

	"golang.org/x/text/language"
	"golang.org/x/text/transform"

	"git.sr.ht/~sircmpwn/go-bare"
)

func LastUpdate(feedsPath, feedID string) (time.Time, error) {
	updatesFilename := filepath.Join(feedsPath, "updated.bare")
	updatesFile, err := os.Open(updatesFilename)
	if err != nil {
		return time.Time{}, fmt.Errorf("while opening updates file: %w", err)
	}
	defer updatesFile.Close()

	var lastUpdated map[string]string
	err = bare.UnmarshalReader(updatesFile, &lastUpdated)
	if err != nil {
		return time.Time{}, fmt.Errorf("while unmarshaling updates file: %w", err)
	}
	t, err := time.Parse(time.RFC3339, lastUpdated[feedID])
	if err != nil {
		return time.Time{}, fmt.Errorf("while parsing update time: %w", err)
	}
	return t, nil
}

type Feed interface {
	fmt.Stringer
	ConvertVehicles(string) error
	GetVersions(time.Time) ([]Version, error)
	GetLocation() *time.Location
	RealtimeFeeds() []string
	Transformer() transform.Transformer
	Name() string
	Attribution() map[language.Tag]string // SHOULD have und tag
	Description() map[language.Tag]string // SHOULD have und tag
	Flags() FeedFlags
	FeedPrepareZip(string) error
}

type HeadsignSource uint

const (
	HeadsignTripHeadsing HeadsignSource = iota
	HeadsignTripLastStop
)

type FeedFlags struct {
	Headsign     HeadsignSource
	StopIdFormat string
	StopName     string
	LineName     string
}

func FeedPath(cfg config.Config, feed Feed) string {
	return filepath.Join(cfg.FeedsPath, feed.String())
}

func RegisterFeeds() map[string]Feed {
	return map[string]Feed{
		"poznan_ztm": ZtmPoznan{
			client: http.Client{
				Timeout: 30 * time.Second,
			},
		},
		"krakow_ztp": ZtpKrakow{},
		"gzm_ztm":    GzmZtm{},
	}
}

func MakeVersion(s string, location *time.Location) (Version, error) {
	version := Version{}
	versionDates := strings.Split(s, "_")
	if len(versionDates) != 2 {
		return version, fmt.Errorf("invalid version string %s, not /.*_.*/", s)
	}
	validFrom, err := time.ParseInLocation("20060102", versionDates[0], location)
	if err != nil {
		return version, fmt.Errorf("invalid first part in %s: %w", s, err)
	}
	validTill, err := time.ParseInLocation("20060102", versionDates[1], location)
	if err != nil {
		return version, fmt.Errorf("invalid second part in %s: %w", s, err)
	}
	version.ValidFrom = validFrom
	version.ValidTill = validTill
	return version, nil
}

func ListVersions(cfg config.Config, f Feed) ([]Version, error) {
	versions := []Version{}
	versionNames, err := file.ListVersions(FeedPath(cfg, f), f.GetLocation())
	if err != nil {
		return versions, err
	}
	for _, name := range versionNames {
		version, err := MakeVersion(name, f.GetLocation())
		if err != nil {
			return versions, err
		}
		versions = append(versions, version)
	}
	return versions, err
}

func FindValidVersions(versions []Version, now time.Time) []Version {
	i := 0
	for _, version := range versions {
		if version.ValidFrom.Before(now) {
			i++
		} else {
			break
		}
	}
	if i > 0 {
		i = i - 1
	}
	validVersions := versions[i:]
	return validVersions
}