app.go
changeset 80 d6e8807818c4
parent 67 1ff7afce37fe
child 83 adc39ae774c0
equal deleted inserted replaced
79:d030a6eb770b 80:d6e8807818c4
     5 	"github.com/sendgrid/rest"
     5 	"github.com/sendgrid/rest"
     6 	"log"
     6 	"log"
     7 	"strings"
     7 	"strings"
     8 )
     8 )
     9 
     9 
    10 var (
    10 var ()
    11 	ourScopes = []string{
       
    12 		"read",
       
    13 		"write",
       
    14 		"follow",
       
    15 	}
       
    16 )
       
    17 
    11 
    18 type registerApp struct {
    12 type registerApp struct {
    19 	ID           string `json:"id"`
    13 	ID           string `json:"id"`
    20 	ClientID     string `json:"client_id"`
    14 	ClientID     string `json:"client_id"`
    21 	ClientSecret string `json:"client_secret"`
    15 	ClientSecret string `json:"client_secret"`
    22 }
    16 }
    23 
    17 
    24 func registerApplication(name string, scopes []string, redirectURI, baseURL string) (g *Gondole, err error) {
    18 // NewApp registers a new instance
    25 	g = &Gondole{
    19 func NewApp(name string, scopes []string, redirectURI, baseURL string) (g *Client, err error) {
       
    20 	var endpoint string
       
    21 
       
    22 	if baseURL != "" {
       
    23 		endpoint = baseURL
       
    24 	}
       
    25 
       
    26 	g = &Client{
    26 		Name: name,
    27 		Name: name,
       
    28 		APIBase: endpoint,
    27 	}
    29 	}
    28 
    30 
    29 	req := g.prepareRequest("apps")
    31 	req := g.prepareRequest("apps")
    30 	if redirectURI != "" {
    32 	if redirectURI != "" {
    31 		req.QueryParams["redirect_uris"] = redirectURI
    33 		req.QueryParams["redirect_uris"] = redirectURI
    45 
    47 
    46 	err = json.Unmarshal([]byte(r.Body), &resp)
    48 	err = json.Unmarshal([]byte(r.Body), &resp)
    47 	if err != nil {
    49 	if err != nil {
    48 		log.Fatalf("error can not register app: %v", err)
    50 		log.Fatalf("error can not register app: %v", err)
    49 	}
    51 	}
    50 	g.ID = resp.ClientID
       
    51 	g.Secret = resp.ClientSecret
       
    52 
    52 
    53 	server := &Server{
       
    54 		ID:          g.ID,
       
    55 		Name:        name,
       
    56 		BearerToken: g.Secret,
       
    57 		BaseURL:     baseURL,
       
    58 	}
       
    59 	err = server.WriteToken(name)
       
    60 	if err != nil {
    53 	if err != nil {
    61 		log.Fatalf("error: can not write token for %s", name)
    54 		log.Fatalf("error: can not write token for %s", name)
    62 	}
    55 	}
    63 	return
       
    64 }
       
    65 
    56 
    66 // NewApp registers a new instance
    57 	g = &Client{
    67 func NewApp(name string, scopes []string, redirectURI, baseURL  string) (g *Gondole, err error) {
    58 		Name:    name,
    68 
    59 		ID:      resp.ClientID,
    69 	if baseURL != "" {
    60 		Secret:  resp.ClientSecret,
    70 		APIEndpoint = baseURL
    61 		APIBase: endpoint,
    71 	}
       
    72 
       
    73 	// Load configuration, will register if none is found
       
    74 	cnf, err := LoadConfig(name)
       
    75 	if err != nil {
       
    76 		// Nothing exist yet
       
    77 		cnf := Config{
       
    78 			Default: name,
       
    79 		}
       
    80 		err = cnf.Write()
       
    81 		if err != nil {
       
    82 			log.Fatalf("error: can not write config for %s", name)
       
    83 		}
       
    84 
       
    85 		// Now register this through OAuth
       
    86 		if scopes == nil {
       
    87 			scopes = ourScopes
       
    88 		}
       
    89 
       
    90 		g, err = registerApplication(name, scopes, redirectURI, baseURL)
       
    91 
       
    92 	} else {
       
    93 		g = &Gondole{
       
    94 			Name:   cnf.Name,
       
    95 			ID:     cnf.ID,
       
    96 			Secret: cnf.BearerToken,
       
    97 		}
       
    98 	}
    62 	}
    99 
    63 
   100 	return
    64 	return
   101 }
    65 }