Esempio n. 1
0
func GetToken(code string) (resp *napping.Response, err error) {
	endPoint := "oauth/device/token"
	header := http.Header{
		"Content-type": []string{"application/json"},
		"User-Agent":   []string{clearance.UserAgent},
		"Cookie":       []string{clearance.Cookies},
	}
	params := napping.Params{
		"code":          code,
		"client_id":     ClientId,
		"client_secret": ClientSecret,
	}.AsUrlValues()

	req := napping.Request{
		Url:    fmt.Sprintf("%s/%s", ApiUrl, endPoint),
		Method: "POST",
		Params: &params,
		Header: &header,
	}

	resp, err = napping.Send(&req)
	if err == nil && resp.Status() == 403 && retries < 3 {
		retries += 1
		err = newClearance()
		if err == nil {
			resp, err = GetToken(code)
		}
	}

	return resp, err
}
Esempio n. 2
0
// do is an easy function for performing requests against Mandrill's API.
func do(url string, data interface{}, result interface{}) error {
	// merr can store a the JSON object returned by mandrill on errors
	merr := newError()
	// prepare and send the request
	rr := &napping.Request{
		Url:     "https://mandrillapp.com/api/1.0" + url,
		Method:  "POST",
		Payload: data,
		Result:  result,
		Error:   merr}
	res, err := napping.Send(rr)

	// network error
	if err != nil {
		return err
	}
	// mandrill error
	if res.Status() != 200 {
		if merr != nil {
			return merr
		} else {
			// a return JSON was not found/parsed
			fmt.Errorf("mandrill: unknown error happened")
		}
	}
	// no error happened
	return nil
}
Esempio n. 3
0
// LookupImporters gets the import paths of all downstream packages known by
// GoDoc.org to import this Package.
func (p *Package) LookupImporters() error {
	url := apiUrl + p.ImportPath
	var e apiError
	var result apiResponse
	var importers []string
	req := napping.Request{
		Url:    url,
		Method: "GET",
		Result: &result,
		Error:  &e,
	}
	resp, err := napping.Send(&req)
	if err != nil {
		return err
	}
	if resp.Status() != 200 {
		msg := fmt.Sprintf("Unexpected status from server: %d", resp.Status())
		return errors.New(msg)
	}
	for _, r := range result.Results {
		if r.Path == downtestPackage {
			continue // Don't test self
		}
		importers = append(importers, r.Path)
	}
	sort.Strings(importers)
	p.Importers = importers
	return nil
}
Esempio n. 4
0
func Post(endPoint string, payload *bytes.Buffer) (resp *napping.Response, err error) {
	header := http.Header{
		"Content-type":      []string{"application/json"},
		"Authorization":     []string{fmt.Sprintf("Bearer %s", config.Get().TraktToken)},
		"trakt-api-key":     []string{ClientId},
		"trakt-api-version": []string{ApiVersion},
		"User-Agent":        []string{clearance.UserAgent},
		"Cookie":            []string{clearance.Cookies},
	}

	req := napping.Request{
		Url:        fmt.Sprintf("%s/%s", ApiUrl, endPoint),
		Method:     "POST",
		RawPayload: true,
		Payload:    payload,
		Header:     &header,
	}

	resp, err = napping.Send(&req)
	if err == nil && resp.Status() == 403 && retries < 3 {
		retries += 1
		err = newClearance()
		if err == nil {
			resp, err = Post(endPoint, payload)
		}
	}

	return resp, err
}
Esempio n. 5
0
func GetCode() (code *Code, err error) {
	endPoint := "oauth/device/code"
	header := http.Header{
		"Content-type": []string{"application/json"},
		"User-Agent":   []string{clearance.UserAgent},
		"Cookie":       []string{clearance.Cookies},
	}
	params := napping.Params{
		"client_id": ClientId,
	}.AsUrlValues()

	req := napping.Request{
		Url:    fmt.Sprintf("%s/%s", ApiUrl, endPoint),
		Method: "POST",
		Params: &params,
		Header: &header,
	}

	resp, err := napping.Send(&req)
	if err == nil && resp.Status() == 403 && retries < 3 {
		retries += 1
		err = newClearance()
		if err == nil {
			code, err = GetCode()
		}
	} else {
		resp.Unmarshal(&code)
	}

	if err == nil && resp.Status() != 200 {
		err = errors.New(fmt.Sprintf("Unable to get Trakt code: %d", resp.Status()))
	}

	return code, err
}
Esempio n. 6
0
func (int *InternalAPI) GetCurrentHead(env string) string {
	conf := (*int.Config)[env]
	if conf == nil {
		return ""
	}

	url := conf.BaseURL
	authKey := conf.AuthKey

	if url == "" || authKey == "" {
		return ""
	}

	result := struct {
		CurrentHead string `json:"current_head"`
	}{}

	req := napping.Request{
		Url:    fmt.Sprintf("%s%s", url, "/current_head"),
		Method: "GET",
		Result: &result,
		Header: &http.Header{},
	}
	req.Header.Set("X-Internal-Key", authKey)
	_, err := napping.Send(&req)

	if err != nil {
		return ""
	}

	return result.CurrentHead
}
Esempio n. 7
0
func GetWithAuth(endPoint string, params url.Values) (resp *napping.Response, err error) {
	header := http.Header{
		"Content-type":      []string{"application/json"},
		"Authorization":     []string{fmt.Sprintf("Bearer %s", config.Get().TraktToken)},
		"trakt-api-key":     []string{ClientId},
		"trakt-api-version": []string{ApiVersion},
		"User-Agent":        []string{clearance.UserAgent},
		"Cookie":            []string{clearance.Cookies},
	}

	req := napping.Request{
		Url:    fmt.Sprintf("%s/%s", ApiUrl, endPoint),
		Method: "GET",
		Params: &params,
		Header: &header,
	}

	resp, err = napping.Send(&req)
	if err == nil && resp.Status() == 403 && retries < 3 {
		retries += 1
		err = newClearance()
		if err == nil {
			resp, err = GetWithAuth(endPoint, params)
		}
	}

	return resp, err
}
Esempio n. 8
0
func GetSurgeClearances() {
	header := http.Header{
		"Content-type": []string{"application/json"},
	}
	params := napping.Params{}.AsUrlValues()

	req := napping.Request{
		Url:    fmt.Sprintf("%s/%s", "https://cloudhole.surge.sh", "cloudhole.json"),
		Method: "GET",
		Params: &params,
		Header: &header,
	}

	resp, err := napping.Send(&req)

	var tmpClearances []*Clearance
	if err == nil && resp.Status() == 200 {
		resp.Unmarshal(&tmpClearances)
	}

	apiKey := config.Get().CloudHoleKey
	for _, clearance := range tmpClearances {
		if clearance.Key == apiKey {
			clearances = append(clearances, clearance)
		}
	}
}
Esempio n. 9
0
// Authenticate with Stormpath using supplied credentials.  Username may be
// either a username or the user's email.
func (app *Application) Authenticate(username, password string) (Account, error) {
	acct := Account{}
	s := username + ":" + password
	value := base64.URLEncoding.EncodeToString([]byte(s))
	m := map[string]string{
		"type":  "basic",
		"value": value,
	}
	loginUrl := app.Href + "/loginAttempts"
	var resp struct {
		Account struct {
			Href string `json:"href"`
		} `json:"account"`
	}
	e := new(StormpathError)
	req := &napping.Request{
		Userinfo: app.userinfo(),
		Url:      loginUrl,
		Method:   "POST",
		Payload:  &m,
		Result:   &resp,
		Error:    &e,
	}
	res, err := napping.Send(req)
	if err != nil {
		return acct, err
	}
	if res.Status() != 200 {
		log.Println(res.Status())
		log.Println(res)
		log.Println(e)
		return acct, InvalidUsernamePassword
	}
	return app.GetAccount(resp.Account.Href)
}
Esempio n. 10
0
// CreateAccount creates a new account accessible to the application.
func (app *Application) CreateAccount(template Account) (Account, error) {
	/*
		data := &map[string]string{
			"username":  username,
			"password":  password,
			"email":     email,
			"surname":   surname,
			"givenName": givenName,
		}
	*/
	url := app.Href + "/accounts"
	acct := Account{}
	e := new(StormpathError)
	req := &napping.Request{
		Userinfo: app.userinfo(),
		Url:      url,
		Method:   "POST",
		Payload:  &template,
		Result:   &acct,
		Error:    e,
	}
	res, err := napping.Send(req)
	if err != nil {
		return acct, err
	}
	acct.app = app
	if res.Status() != 201 {
		log.Println(res.Status())
		log.Println(e)
		return acct, BadResponse
	}
	return acct, nil
}
Esempio n. 11
0
// Delete removes an account from Stormpath.
func (a *Account) Delete() error {
	e := new(StormpathError)
	req := &napping.Request{
		Userinfo: a.app.userinfo(),
		Url:      a.Href,
		Method:   "DELETE",
		Error:    e,
	}
	res, err := napping.Send(req)
	if err != nil {
		return err
	}
	if res.Status() != 204 {
		log.Println(res.Status())
		log.Println(e)
		return BadResponse
	}
	return nil // Successful deletion
}
Esempio n. 12
0
// Update saves the account to Stormpath.
func (a *Account) Update() error {
	e := new(StormpathError)
	req := &napping.Request{
		Userinfo: a.app.userinfo(),
		Url:      a.Href,
		Method:   "POST",
		Payload:  &a,
		Error:    e,
	}
	res, err := napping.Send(req)
	if err != nil {
		return err
	}
	if res.Status() != 200 {
		log.Println(res.Status())
		log.Println(e)
		return BadResponse
	}
	return nil // Successful update
}
Esempio n. 13
0
// do is an easy function for performing requests against Mandrill's API.
func do(url string, data interface{}, result interface{}) error {
	err := newError()

	rr := &napping.Request{
		Url:     "https://mandrillapp.com/api/1.0" + url,
		Method:  "POST",
		Payload: data,
		Result:  result,
		Error:   err}

	status, errs := napping.Send(rr)

	if errs == nil {
		return nil
	}

	fmt.Println(status, rr.Error)

	return errs
}
Esempio n. 14
0
func GetClearance() (clearance *Clearance, err error) {
	if len(clearances) > 0 {
		clearance = clearances[rand.Intn(len(clearances))]
		return clearance, nil
	}

	apiKey := config.Get().CloudHoleKey
	if apiKey == "" {
		return defaultClearance, nil
	}

	header := http.Header{
		"Content-type":  []string{"application/json"},
		"Authorization": []string{apiKey},
	}
	params := napping.Params{}.AsUrlValues()

	req := napping.Request{
		Url:    fmt.Sprintf("%s/%s", "https://cloudhole.herokuapp.com", "clearances"),
		Method: "GET",
		Params: &params,
		Header: &header,
	}

	resp, err := napping.Send(&req)

	if err == nil && resp.Status() == 200 {
		resp.Unmarshal(&clearances)
	} else if resp.Status() == 503 {
		GetSurgeClearances()
	}

	if len(clearances) > 0 {
		clearance = clearances[rand.Intn(len(clearances))]
	} else {
		err = errors.New("Failed to get new clearance.")
		clearance = defaultClearance
	}

	return clearance, err
}
Esempio n. 15
0
// GetAccount returns the specified account object, if it exists.
func (app *Application) GetAccount(href string) (Account, error) {
	acct := Account{}
	e := new(StormpathError)
	req := &napping.Request{
		Userinfo: app.userinfo(),
		Url:      href,
		Method:   "GET",
		Result:   &acct,
		Error:    e,
	}
	res, err := napping.Send(req)
	if err != nil {
		return acct, err
	}
	acct.app = app
	if res.Status() != 200 {
		log.Println(res.Status())
		log.Println(e)
		return acct, BadResponse
	}
	return acct, nil
}