func main() {
flag.Parse()
var client *maps.Client
var err error
if *apiKey != "" {
client, err = maps.NewClient(maps.WithAPIKey(*apiKey))
} else if *clientID != "" || *signature != "" {
client, err = maps.NewClient(maps.WithClientIDAndSignature(*clientID, *signature))
} else {
usageAndExit("Please specify an API Key, or Client ID and Signature.")
}
check(err)
r := &maps.GeocodingRequest{
Address: *address,
Language: *language,
Region: *region,
}
parseComponents(*components, r)
parseBounds(*bounds, r)
parseLatLng(*latlng, r)
parseResultType(*resultType, r)
parseLocationType(*locationType, r)
resp, err := client.Geocode(context.Background(), r)
check(err)
pretty.Println(resp)
}
func main() {
flag.Parse()
if *apiKey == "" {
usageAndExit("Please specify an API Key.")
}
client, err := maps.NewClient(maps.WithAPIKey(*apiKey))
if err != nil {
log.Fatalf("error %v", err)
}
r := &maps.SpeedLimitsRequest{}
if *units == "KPH" {
r.Units = maps.SpeedLimitKPH
}
if *units == "MPH" {
r.Units = maps.SpeedLimitMPH
}
if *path == "" && *placeIDs == "" {
usageAndExit("Please specify either a path to be snapped, or a list of Place IDs.")
}
parsePath(*path, r)
parsePlaceIDs(*placeIDs, r)
resp, err := client.SpeedLimits(context.Background(), r)
if err != nil {
log.Fatalf("error %v", err)
}
pretty.Println(resp)
}
func main() {
flag.Parse()
var client *maps.Client
var err error
if *apiKey != "" {
client, err = maps.NewClient(maps.WithAPIKey(*apiKey))
} else if *clientID != "" || *signature != "" {
client, err = maps.NewClient(maps.WithClientIDAndSignature(*clientID, *signature))
} else {
usageAndExit("Please specify an API Key, or Client ID and Signature.")
}
check(err)
r := &maps.QueryAutocompleteRequest{
Input: *input,
Language: *language,
Radius: *radius,
Offset: *offset,
}
parseLocation(*location, r)
resp, err := client.QueryAutocomplete(context.Background(), r)
check(err)
pretty.Println(resp)
}
func main() {
flag.Parse()
var client *maps.Client
var err error
if *apiKey != "" {
client, err = maps.NewClient(maps.WithAPIKey(*apiKey))
} else if *clientID != "" || *signature != "" {
client, err = maps.NewClient(maps.WithClientIDAndSignature(*clientID, *signature))
} else {
usageAndExit("Please specify an API Key, or Client ID and Signature.")
}
check(err)
t, err := strconv.Atoi(*timestamp)
check(err)
r := &maps.TimezoneRequest{
Language: *language,
Timestamp: time.Unix(int64(t), 0),
}
parseLocation(*location, r)
resp, err := client.Timezone(context.Background(), r)
check(err)
pretty.Println(resp)
}
func main() {
flag.Parse()
var client *maps.Client
var err error
if *apiKey != "" {
client, err = maps.NewClient(maps.WithAPIKey(*apiKey))
} else if *clientID != "" || *signature != "" {
client, err = maps.NewClient(maps.WithClientIDAndSignature(*clientID, *signature))
} else {
usageAndExit("Please specify an API Key, or Client ID and Signature.")
}
check(err)
r := &maps.TextSearchRequest{
Query: *query,
Language: *language,
Radius: *radius,
OpenNow: *opennow,
}
parseLocation(*location, r)
parsePriceLevels(*minprice, *maxprice, r)
resp, err := client.TextSearch(context.Background(), r)
check(err)
pretty.Println(resp)
}
func main() {
flag.Parse()
if *apiKey == "" {
usageAndExit("Please specify an API Key.")
}
client, err := maps.NewClient(maps.WithAPIKey(*apiKey))
check(err)
r := &maps.SnapToRoadRequest{
Interpolate: *interpolate,
}
if *path == "" {
usageAndExit("Please specify a path to be snapped.")
}
parsePath(*path, r)
resp, err := client.SnapToRoad(context.Background(), r)
check(err)
pretty.Println(resp)
}
func main() {
flag.Parse()
var client *maps.Client
var err error
if *apiKey != "" {
client, err = maps.NewClient(maps.WithAPIKey(*apiKey))
} else if *clientID != "" || *signature != "" {
client, err = maps.NewClient(maps.WithClientIDAndSignature(*clientID, *signature))
} else {
usageAndExit("Please specify an API Key, or Client ID and Signature.")
}
check(err)
r := &maps.ElevationRequest{}
if *samples > 0 {
r.Samples = *samples
}
if *locations != "" {
l, err := decodeLocations(*locations)
check(err)
r.Locations = l
}
if *path != "" {
p, err := decodePath(*path)
check(err)
r.Path = p
}
resp, err := client.Elevation(context.Background(), r)
if err != nil {
log.Fatalf("Could not request elevations: %v", err)
}
pretty.Println(resp)
}
func main() {
flag.Parse()
var client *maps.Client
var err error
if *apiKey != "" {
client, err = maps.NewClient(maps.WithAPIKey(*apiKey))
} else if *clientID != "" || *signature != "" {
client, err = maps.NewClient(maps.WithClientIDAndSignature(*clientID, *signature))
} else {
usageAndExit("Please specify an API Key, or Client ID and Signature.")
}
check(err)
r := &maps.PlacePhotoRequest{
PhotoReference: *photoreference,
MaxHeight: uint(*maxheight),
MaxWidth: uint(*maxwidth),
}
resp, err := client.PlacePhoto(context.Background(), r)
check(err)
log.Printf("Content-Type: %v\n", resp.ContentType)
img, err := resp.Image()
check(err)
log.Printf("Image bounds: %v", img.Bounds())
if *basename != "" {
filename := fmt.Sprintf("%s.%s", *basename, "jpg")
f, err := os.Create(filename)
check(err)
err = jpeg.Encode(f, img, &jpeg.Options{Quality: 85})
check(err)
log.Printf("Wrote image to %s\n", filename)
}
}
func main() {
flag.Parse()
var client *maps.Client
var err error
if *apiKey != "" {
client, err = maps.NewClient(maps.WithAPIKey(*apiKey))
} else if *clientID != "" || *signature != "" {
client, err = maps.NewClient(maps.WithClientIDAndSignature(*clientID, *signature))
} else {
usageAndExit("Please specify an API Key, or Client ID and Signature.")
}
check(err)
r := &maps.DistanceMatrixRequest{
Language: *language,
DepartureTime: *departureTime,
ArrivalTime: *arrivalTime,
}
if *origins != "" {
r.Origins = strings.Split(*origins, "|")
}
if *destinations != "" {
r.Destinations = strings.Split(*destinations, "|")
}
lookupMode(*mode, r)
lookupAvoid(*avoid, r)
lookupUnits(*units, r)
lookupTransitMode(*transitMode, r)
lookupTransitRoutingPreference(*transitRoutingPreference, r)
resp, err := client.DistanceMatrix(context.Background(), r)
check(err)
pretty.Println(resp)
}
func main() {
flag.Parse()
var client *maps.Client
var err error
if *apiKey != "" {
client, err = maps.NewClient(maps.WithAPIKey(*apiKey))
} else if *clientID != "" || *signature != "" {
client, err = maps.NewClient(maps.WithClientIDAndSignature(*clientID, *signature))
} else {
usageAndExit("Please specify an API Key, or Client ID and Signature.")
}
check(err)
r := &maps.PlaceDetailsRequest{
PlaceID: *placeID,
}
resp, err := client.PlaceDetails(context.Background(), r)
check(err)
pretty.Println(resp)
}
func main() {
// set up command line options
var stravaAccessToken, mapsAccessToken string
var resetCommuteCounter bool
flag.BoolVar(&resetCommuteCounter, "reset-commute-counter", true, "Reset Commute Counter")
flag.StringVar(&stravaAccessToken, "strava-token", os.Getenv("STRAVA_TOKEN"), "Strava Access Token")
flag.StringVar(&mapsAccessToken, "maps-token", os.Getenv("MAPS_TOKEN"), "Google Maps Access Token")
flag.Parse()
if stravaAccessToken == "" {
fmt.Println("\nPlease provide a strava-token")
flag.PrintDefaults()
os.Exit(1)
}
if mapsAccessToken == "" {
fmt.Println("\nPlease provide a maps-token")
flag.PrintDefaults()
os.Exit(1)
}
// open the persistence backend
db := &persistence.DB{Store: persistence.Open()}
defer db.Close()
mapsClient, err := maps.NewClient(maps.WithAPIKey(mapsAccessToken))
if err != nil {
fmt.Printf("fatal error: %s", err)
os.Exit(1)
}
client := strava.NewClient(stravaAccessToken)
service := strava.NewCurrentAthleteService(client)
activities, err := service.ListActivities().Do()
if err != nil {
fmt.Println(err)
os.Exit(1)
}
// reset in the internal counter if asked
reset(db, resetCommuteCounter, activities)
for _, e := range activities {
fmt.Print(e.Name)
if strings.Count(e.Name, "-") == 0 {
city, country := geocode(mapsClient, e.StartLocation[0], e.StartLocation[1])
name := e.StartDateLocal.Format("02/01/2006") + " " + city + ", " + country + " - "
if e.Commute {
name += "Commute #" + db.Increment() + " - "
}
name += e.Name
s := strava.NewActivitiesService(client)
_, err = s.Update(e.Id).Name(name).Do()
if err != nil {
fmt.Println(err)
}
fmt.Printf("... updated with new name (%s)\n", name)
} else {
fmt.Println("... ignored")
}
}
}
func main() {
flag.Parse()
var client *maps.Client
var err error
if *apiKey != "" {
client, err = maps.NewClient(maps.WithAPIKey(*apiKey), maps.WithRateLimit(2))
} else if *clientID != "" || *signature != "" {
client, err = maps.NewClient(maps.WithClientIDAndSignature(*clientID, *signature))
} else {
usageAndExit("Please specify an API Key, or Client ID and Signature.")
}
check(err)
r := &maps.DirectionsRequest{
Origin: *origin,
Destination: *destination,
DepartureTime: *departureTime,
ArrivalTime: *arrivalTime,
Alternatives: *alternatives,
Language: *language,
Region: *region,
}
lookupMode(*mode, r)
lookupUnits(*units, r)
lookupTransitRoutingPreference(*transitRoutingPreference, r)
lookupTrafficModel(*trafficModel, r)
if *waypoints != "" {
r.Waypoints = strings.Split(*waypoints, "|")
}
if *avoid != "" {
for _, a := range strings.Split(*avoid, "|") {
switch a {
case "tolls":
r.Avoid = append(r.Avoid, maps.AvoidTolls)
case "highways":
r.Avoid = append(r.Avoid, maps.AvoidHighways)
case "ferries":
r.Avoid = append(r.Avoid, maps.AvoidFerries)
default:
log.Fatalf("Unknown avoid restriction %s", a)
}
}
}
if *transitMode != "" {
for _, t := range strings.Split(*transitMode, "|") {
switch t {
case "bus":
r.TransitMode = append(r.TransitMode, maps.TransitModeBus)
case "subway":
r.TransitMode = append(r.TransitMode, maps.TransitModeSubway)
case "train":
r.TransitMode = append(r.TransitMode, maps.TransitModeTrain)
case "tram":
r.TransitMode = append(r.TransitMode, maps.TransitModeTram)
case "rail":
r.TransitMode = append(r.TransitMode, maps.TransitModeRail)
}
}
}
if *iterations == 1 {
routes, waypoints, err := client.Directions(context.Background(), r)
check(err)
pretty.Println(waypoints)
pretty.Println(routes)
} else {
done := make(chan iterationResult)
for i := 0; i < *iterations; i++ {
go func(i int) {
startTime := time.Now()
_, _, err := client.Directions(context.Background(), r)
done <- iterationResult{
fmt.Sprintf("Iteration %2d: round trip %.2f seconds", i, float64(time.Now().Sub(startTime))/1000000000),
err,
}
}(i)
}
for i := 0; i < *iterations; i++ {
result := <-done
if err != nil {
fmt.Printf("error: %+v\n", result.err)
} else {
fmt.Println(result.result)
}
}
}
}