Dexcom V2

client.go

@@ -1,59 +1,23 @@
 package dexcomClient
 
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"os/exec"
+import "fmt"
 
-	"github.com/gorilla/mux"
-)
-
-type DexcomClient struct {
-	AuthCode    string
-	DexcomToken string
-	config      *Config
-	oAuthToken  *Token
-	logger
+type Client struct {
+	token   string
+	sandbox bool
 }
 
-func NewClient(config *Config) *DexcomClient {
-	dc := &DexcomClient{
-		config: config,
-		logger: &defaultLogger{config: config},
-	}
-
-	if config.IsDev {
-		fmt.Println("Dev server starting on :8000")
-		url := config.getBaseUrl() + "/v1/oauth2/login?client_id=" + config.ClientId + "&redirect_uri=" + config.RedirectURI + "&response_type=code&scope=offline_access"
-		fmt.Println(url)
-		defer dc.startDevServer(url)
+func (c *Client) getURL(path string) string {
+	base := baseUrl
+	if c.sandbox {
+		base = sandboxUrl
 	}
-	return dc
+	return fmt.Sprintf("%s%s", base, path)
 }
 
-func NewClientWithToken(config *Config, token *Token) *DexcomClient {
-	return &DexcomClient{
-		config:     config,
-		oAuthToken: token,
-		logger:     &defaultLogger{config: config},
+func NewClient(token string) *Client {
+	dc := &Client{
+		token: token,
 	}
-}
-
-func (client *DexcomClient) startDevServer(url string) {
-	server := &http.Server{Addr: ":8000"}
-
-	router := mux.NewRouter()
-	router.Path("/oauth").Queries("code", "{code}").HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		client.AuthCode = req.FormValue("code")
-		_, err := client.GetOauthToken()
-		if err != nil {
-			panic(err)
-		}
-		server.Shutdown(context.Background())
-	})
-
-	server.Handler = router
-	exec.Command("open", url)
-	server.ListenAndServe()
+	return dc
 }

config.go

@@ -1,105 +1,6 @@
 package dexcomClient
 
-import (
-	"encoding/json"
-	"errors"
-	"io/ioutil"
-	"net/http"
-	"strings"
-	"time"
-)
-
 const (
-	baseUrl = "https://api.dexcom.com"
-	devUrl  = "https://sandbox-api.dexcom.com"
-	authUrl = "/v1/oauth2/token"
+	baseUrl    = "https://api.dexcom.com"
+	sandboxUrl = "https://sandboxUrl-api.dexcom.com"
 )
-
-type Config struct {
-	ClientId     string
-	ClientSecret string
-	RedirectURI  string
-	Sandbox      bool
-	IsDev        bool
-	IsDebug      bool
-	Logging      bool
-}
-
-type Token struct {
-	AccessToken   string `json:"access_token"`
-	ExpiresIn     int64  `json:"expires_in"`
-	TokenType     string `json:"token_type"`
-	RefreshToken  string `json:"refresh_token"`
-	TimeRefreshed int64
-}
-
-func (client *DexcomClient) GetOauthToken() (*Token, error) {
-
-	if client.oAuthToken != nil {
-		expired := client.oAuthToken.TimeRefreshed + client.oAuthToken.ExpiresIn <= time.Now().Unix()
-		if expired {
-			goto REQUEST
-		}
-		return client.oAuthToken, nil
-	}
-
-	REQUEST:
-	token, err := client.authenticate()
-	if err != nil {
-		return nil, err
-	}
-	client.oAuthToken = token
-	token.TimeRefreshed = time.Now().Unix()
-	return token, err
-}
-
-func (client *DexcomClient) GetOAuthTokenWithAuth(authorization string) (*Token, error) {
-	client.oAuthToken = &Token{}
-	token, err := client.authenticate()
-	if err != nil {
-		return nil, err
-	}
-	client.oAuthToken = token
-	token.TimeRefreshed = time.Now().Unix()
-	return token, err
-}
-
-func (client *DexcomClient) SetOAuthToken(token *Token) {
-	client.oAuthToken = token
-}
-
-func (c *Config) getBaseUrl() string {
-	if c.Sandbox {
-		return devUrl
-	}
-	return baseUrl
-}
-
-func (client *DexcomClient) authenticate() (*Token, error) {
-	req, _ := http.NewRequest("POST", client.config.getBaseUrl()+authUrl, client.getAuthPayload())
-	req.Header.Add("content-type", "application/x-www-form-urlencoded")
-	req.Header.Add("cache", "no-cache")
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-
-	body, _ := ioutil.ReadAll(resp.Body)
-	var token Token
-	json.Unmarshal(body, &token)
-
-	if token.RefreshToken == "" {
-		return nil, errors.New("auth error")
-	}
-
-	return &token, nil
-}
-
-func (client *DexcomClient) getAuthPayload() *strings.Reader {
-	clientSecret := "client_secret=" + client.config.ClientSecret + "&"
-	clientId := "client_id=" + client.config.ClientId + "&"
-	code := "code=" + client.AuthCode + "&"
-	redirectUri := "redirect_uri=" + client.config.RedirectURI
-	b := clientSecret + clientId + code + "grant_type=authorization_code&" + redirectUri
-	return strings.NewReader(b)
-}

devices.go

@@ -2,48 +2,40 @@ package dexcomClient
 
 import (
 	"encoding/json"
-	"io/ioutil"
+	"fmt"
 	"net/http"
+
+	"github.com/ryan-berger/dexcomClient/model"
 )
 
-type Device struct {
-	Model          string
-	LastUploadDate string
-	AlertSettings  []AlertSetting
-}
 
-type AlertSetting struct {
-	AlertName   string
-	Value       int
-	Unit        string
-	Snooze      int
-	Delay       int
-	Enabled     bool
-	SystemTime  string
-	DisplayTime string
+type deviceResponse struct {
+	Devices []model.Device `json:"devices"`
 }
 
-func (client *DexcomClient) GetDevices() ([]*Device, error) {
-	url := client.config.getBaseUrl() + "/v1/users/self/devices"
-	req, _ := http.NewRequest("GET", url, nil)
+func (c *Client) GetDevices() ([]model.Device, error) {
+	url := c.getURL("/v2/users/self/devices")
+	req, err := http.NewRequest("GET", url, nil)
 
-	req.Header.Add("authorization", "Bearer ")
-	resp, err := http.DefaultClient.Do(req)
+	// TODO:
 	if err != nil {
 		return nil, err
 	}
 
-	body, err := ioutil.ReadAll(resp.Body)
+	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", c.token))
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return nil, err
 	}
 
-	var devices []*Device
+	var devResp deviceResponse
+	err = json.
+		NewDecoder(resp.Body).
+		Decode(&devResp)
 
-	err = json.Unmarshal(body, &devices)
 	if err != nil {
 		return nil, err
 	}
 
-	return devices, err
+	return devResp.Devices, nil
 }