app.go
changeset 35 27c58d359940
parent 27 15abafa6cd90
child 65 0d245f3b076f
equal deleted inserted replaced
34:69711df3beac 35:27c58d359940
     1 package gondole
     1 package gondole
     2 
     2 
     3 import (
     3 import (
     4 
     4 	"encoding/json"
       
     5 	"github.com/sendgrid/rest"
       
     6 	"log"
       
     7 	"strings"
     5 )
     8 )
     6 
     9 
     7 // NewApp registers a new instance
    10 var (
     8 func NewApp(name, redirectURI string) (g *Gondole, err error) {
    11 	ourScopes = []string{
     9 	// Load configuration, will register if none is found
    12 		"read",
       
    13 		"write",
       
    14 		"follow",
       
    15 	}
       
    16 )
    10 
    17 
       
    18 type registerApp struct {
       
    19 	ID           int64  `json:"id"`
       
    20 	ClientID     int64  `json:"Client_id"`
       
    21 	ClientSecret string `json:"client_secret"`
       
    22 }
       
    23 
       
    24 func registerApplication(name string, scopes []string, redirectURI string) (g *Gondole, err error) {
    11 	g = &Gondole{
    25 	g = &Gondole{
    12 		Name:   name,
    26 		Name: name,
    13 		//ID:     config.ID,
    27 	}
    14 		//Secret: config.BearerToken,
    28 
       
    29 	req := g.prepareRequest("apps")
       
    30 	if redirectURI != "" {
       
    31 		req.QueryParams["redirect_uris"] = redirectURI
       
    32 	} else {
       
    33 		req.QueryParams["redirect_uris"] = NoRedirect
       
    34 	}
       
    35 	req.QueryParams["client_name"] = name
       
    36 	req.QueryParams["scopes"] = strings.Join(scopes, " ")
       
    37 	req.Method = rest.Post
       
    38 
       
    39 	r, err := rest.API(req)
       
    40 	if err != nil {
       
    41 		log.Fatalf("error can not register app: %v", err)
       
    42 	}
       
    43 
       
    44 	var resp registerApp
       
    45 
       
    46 	err = json.Unmarshal([]byte(r.Body), &resp)
       
    47 	if err != nil {
       
    48 		log.Fatalf("error can not register app: %v", err)
       
    49 	}
       
    50 	g.ID = resp.ClientID
       
    51 	g.Secret = resp.ClientSecret
       
    52 
       
    53 	server := &Server{
       
    54 		ID:          g.ID,
       
    55 		Name:        name,
       
    56 		BearerToken: g.Secret,
       
    57 	}
       
    58 	err = server.WriteToken(name)
       
    59 	if err != nil {
       
    60 		log.Fatalf("error: can not write token for %s", name)
    15 	}
    61 	}
    16 	return
    62 	return
    17 }
    63 }
    18 
    64 
       
    65 // NewApp registers a new instance
       
    66 func NewApp(name string, scopes []string, redirectURI string) (g *Gondole, err error) {
       
    67 	// Load configuration, will register if none is found
       
    68 	cnf, err := LoadConfig(name)
       
    69 	if err != nil {
       
    70 		// Nothing exist yet
       
    71 		cnf := Config{
       
    72 			Default: name,
       
    73 		}
       
    74 		err = cnf.Write()
       
    75 		if err != nil {
       
    76 			log.Fatalf("error: can not write config for %s", name)
       
    77 		}
       
    78 
       
    79 		// Now register this through OAuth
       
    80 		if scopes == nil {
       
    81 			scopes = ourScopes
       
    82 		}
       
    83 
       
    84 		g, err = registerApplication(name, scopes, redirectURI)
       
    85 
       
    86 	} else {
       
    87 		g = &Gondole{
       
    88 			Name:   cnf.Name,
       
    89 			ID:     cnf.ID,
       
    90 			Secret: cnf.BearerToken,
       
    91 		}
       
    92 	}
       
    93 
       
    94 	return
       
    95 }