141 lines
3.6 KiB
Go
141 lines
3.6 KiB
Go
package integration
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
|
|
"rideaware/internal/config"
|
|
"rideaware/internal/export"
|
|
"rideaware/internal/user"
|
|
"rideaware/internal/workout"
|
|
)
|
|
|
|
type GarminClient struct {
|
|
oauthService *OAuthService
|
|
workoutRepo *workout.Repository
|
|
userRepo *user.Repository
|
|
}
|
|
|
|
func NewGarminClient() *GarminClient {
|
|
return &GarminClient{
|
|
oauthService: NewOAuthService(),
|
|
workoutRepo: workout.NewRepository(),
|
|
userRepo: user.NewRepository(),
|
|
}
|
|
}
|
|
|
|
// BuildAuthURL constructs the Garmin OAuth2 PKCE authorization URL.
|
|
func (c *GarminClient) BuildAuthURL(userID uint) (string, error) {
|
|
cfg := config.OAuth.Garmin
|
|
if cfg.ClientID == "" {
|
|
return "", fmt.Errorf("Garmin OAuth is not configured")
|
|
}
|
|
|
|
stateToken, _, codeChallenge, err := c.oauthService.GenerateStateWithPKCE(userID, "garmin")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
params := url.Values{
|
|
"client_id": {cfg.ClientID},
|
|
"response_type": {"code"},
|
|
"redirect_uri": {cfg.RedirectURI},
|
|
"scope": {"TRAINING_API"},
|
|
"state": {stateToken},
|
|
"code_challenge": {codeChallenge},
|
|
"code_challenge_method": {"S256"},
|
|
}
|
|
|
|
return cfg.AuthURL + "?" + params.Encode(), nil
|
|
}
|
|
|
|
// HandleCallback exchanges the authorization code for tokens and stores them.
|
|
func (c *GarminClient) HandleCallback(code, stateToken string) (uint, error) {
|
|
state, err := c.oauthService.ValidateState(stateToken)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if state.Provider != "garmin" {
|
|
return 0, fmt.Errorf("invalid state provider: expected garmin, got %s", state.Provider)
|
|
}
|
|
|
|
cfg := config.OAuth.Garmin
|
|
params := url.Values{
|
|
"grant_type": {"authorization_code"},
|
|
"code": {code},
|
|
"redirect_uri": {cfg.RedirectURI},
|
|
"client_id": {cfg.ClientID},
|
|
"code_verifier": {state.CodeVerifier},
|
|
}
|
|
|
|
tokenResp, err := c.oauthService.ExchangeCode(cfg.TokenURL, params)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("Garmin token exchange failed: %w", err)
|
|
}
|
|
|
|
if err := c.oauthService.SaveConnection(state.UserID, "garmin", tokenResp); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return state.UserID, nil
|
|
}
|
|
|
|
// PushWorkout sends a structured workout to Garmin Connect via the Training API.
|
|
// If the Training API is not yet available, returns an error with instructions to use FIT export.
|
|
func (c *GarminClient) PushWorkout(workoutID, userID uint) error {
|
|
accessToken, err := c.oauthService.GetValidToken(userID, "garmin")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
w, err := c.workoutRepo.GetWorkoutByID(workoutID, userID)
|
|
if err != nil {
|
|
return fmt.Errorf("workout not found: %w", err)
|
|
}
|
|
|
|
u, err := c.userRepo.GetUserByID(userID)
|
|
if err != nil {
|
|
return fmt.Errorf("user not found: %w", err)
|
|
}
|
|
|
|
ftp := 0
|
|
if u.Profile != nil {
|
|
ftp = u.Profile.FTP
|
|
}
|
|
if ftp <= 0 {
|
|
return fmt.Errorf("FTP must be set in your profile before pushing workouts")
|
|
}
|
|
|
|
fitData, err := export.EncodeFITWorkout(w, ftp)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate FIT workout: %w", err)
|
|
}
|
|
|
|
// Push FIT file to Garmin Training API
|
|
apiURL := "https://apis.garmin.com/training-api/workout"
|
|
req, err := http.NewRequest("POST", apiURL, bytes.NewReader(fitData))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
req.Header.Set("Authorization", "Bearer "+accessToken)
|
|
req.Header.Set("Content-Type", "application/octet-stream")
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to push workout to Garmin: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
|
|
body, _ := io.ReadAll(resp.Body)
|
|
return fmt.Errorf("Garmin API returned status %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
|
|
return nil
|
|
}
|