Beispiel #1
0
// init is called before the application starts.
func init() {

	m := martini.Classic()
	m.Use(render.Renderer())

	m.Use(func(res http.ResponseWriter, req *http.Request) {
		authorization := &spark.Authorization{AccessToken: os.Getenv("SPARK_TOKEN")}
		spark.InitClient(authorization)
		ctx := appengine.NewContext(req)
		spark.SetHttpClient(urlfetch.Client(ctx), ctx)
	})

	m.Post("/spark", binding.Json(SparkEvent{}), func(sparkEvent SparkEvent, res http.ResponseWriter, req *http.Request, r render.Render) {
		ctx := appengine.NewContext(req)
		client := urlfetch.Client(ctx)

		message := spark.Message{ID: sparkEvent.Id}
		message.Get()
		log.Infof(ctx, message.Text)

		if strings.HasPrefix(message.Text, "/") {
			s := strings.Split(sparkEvent.Text, " ")

			command := s[0]
			log.Infof(ctx, "command = %s", command)
			if command == "/routes" {

				resp, _ := client.Get("http://galwaybus.herokuapp.com/routes.json")
				defer resp.Body.Close()
				contents, _ := ioutil.ReadAll(resp.Body)
				log.Infof(ctx, "body = %s\n", contents)

				var routeMap map[string]BusRoute
				json.Unmarshal([]byte(contents), &routeMap)

				text := "Routes:\n\n"
				for _, route := range routeMap {
					text = text + strconv.Itoa(route.Id) + " " + route.LongName + "\n"
				}

				message := spark.Message{
					RoomID: sparkEvent.RoomId,
					Text:   text,
				}
				message.Post()
			}
		}

	})

	http.Handle("/", m)
}
Beispiel #2
0
func init() {
	renderer := render.New(render.Options{})
	token := os.Getenv("SLACK_TOKEN")

	http.HandleFunc("/v1/cmd", func(w http.ResponseWriter, r *http.Request) {
		ctx := appengine.NewContext(r)

		req, err := goslash.ParseFormSlashCommandRequest(r)
		if err != nil {
			renderer.JSON(w, http.StatusInternalServerError, err.Error())
			return
		}

		if req.Token != token {
			log.Errorf(ctx, "received invalid token:%v from %v", req.Token, r.RemoteAddr)
			renderer.JSON(w, http.StatusForbidden, "invalid token")
			return
		}

		slashPlugins := map[string]plugins.Plugin{
			"echo":  echo.New(),
			"time":  time.New(),
			"突然":    suddendeath.New(),
			"LGTM":  lgtm.New(urlfetch.Client(ctx)),
			"akari": akari.New(),
		}

		slashCmd := plugins.New(urlfetch.Client(ctx), slashPlugins)

		if appengine.IsDevAppServer() {
			// development
			cmd, _ := req.CmdArgs()
			p, ok := slashPlugins[cmd]
			if !ok {
				renderer.JSON(w, http.StatusNotFound, "cmd not found")
				return
			}

			msg := p.Do(req)
			var jsonData bytes.Buffer
			if err := json.NewEncoder(&jsonData).Encode(&msg); err != nil {
				renderer.JSON(w, http.StatusInternalServerError, err.Error())
				return
			}
			renderer.JSON(w, http.StatusOK, jsonData.String())
		} else {
			// production
			renderer.Text(w, http.StatusOK, slashCmd.Execute(req))
		}
	})
}
Beispiel #3
0
func textMessageHandler(w http.ResponseWriter, r *http.Request) {

	ctx := appengine.NewContext(r)

	to := r.FormValue("to")
	text := r.FormValue("text")

	log.Debugf(ctx, "to: %s, text: %s.", to, text)

	chi, _ := strconv.ParseInt(os.Getenv("CHANNEL_ID"), 10, 64)
	chs := os.Getenv("CHANNEL_SECRET")
	mid := os.Getenv("MID")

	client := urlfetch.Client(ctx)
	bot, err := linebot.NewClient(chi, chs, mid, linebot.WithHTTPClient(client))
	if err != nil {
		log.Errorf(ctx, "Client initialization failure. to: %s, text: %s, context: %s", to, text, err.Error())
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	res, err := bot.SendText([]string{to}, text)
	if err != nil {
		log.Errorf(ctx, "Message Send Failed. to: %s, text: %s, context: %s", to, text, err.Error())
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	log.Infof(ctx, "Message send succeed. MessageID: %s, to: %s, text: %s", res.MessageID, to, text)
	w.WriteHeader(http.StatusOK)
}
Beispiel #4
0
func jobV2adsbHandler(r *http.Request, f *oldfdb.Flight) (string, error) {
	ctx := req2ctx(r)
	str := ""

	// Allow overwrite, for the (36,0) disastery
	// if f.HasTrack("ADSB") { return "", nil } // Already has one

	err, deb := f.GetV2ADSBTrack(urlfetch.Client(ctx))
	str += fmt.Sprintf("*getv2ADSB [%v]:-\n", err, deb)
	if err != nil {
		return str, err
	}

	if !f.HasTrack("ADSB") {
		return "", nil
	} // Didn't find one

	f.Analyse() // Retrigger Class-B stuff

	db := oldfgae.NewDB(r)
	if err := db.UpdateFlight(*f); err != nil {
		log.Errorf(ctx, "Persist Flight %s: %v", f, err)
		return str, err
	}
	log.Infof(ctx, "Updated flight %s", f)
	str += fmt.Sprintf("--\nFlight was updated\n")

	return str, nil
}
Beispiel #5
0
func registerFeed(w http.ResponseWriter, r *http.Request) *appError {
	s := strings.TrimSpace(r.FormValue("url"))
	if s == "" {
		return &appError{
			Error:   errInvalidRequest,
			Message: "url is required",
			Code:    http.StatusBadRequest,
		}
	}
	u, err := url.Parse(s)
	if err != nil {
		return &appError{
			Error:   err,
			Message: "can't parse url",
			Code:    http.StatusBadRequest,
		}
	}
	if !u.IsAbs() {
		return &appError{
			Error:   errInvalidRequest,
			Message: "require an absolute url",
			Code:    http.StatusBadRequest,
		}
	}
	c := appengine.NewContext(r)
	client := urlfetch.Client(c)
	f, err := fetchFeed(client, s)
	if err != nil {
		return &appError{
			Error:   err,
			Message: "failed to get",
			Code:    http.StatusInternalServerError,
		}
	}
	m := Magazine{
		Title:    f.Title,
		URL:      s,
		Creation: time.Now(),
		LastMod:  time.Now(),
	}
	m.Init(c)
	usr := user.Current(c)
	if usr == nil {
		return &appError{
			Error:   errUserRejected,
			Message: "failed to initialize user environment",
			Code:    http.StatusUnauthorized,
		}
	}
	err = RegisterMagazine(c, usr, &m, f)
	if err != nil {
		return &appError{
			Error:   err,
			Message: "failed to register",
			Code:    http.StatusInternalServerError,
		}
	}
	http.Redirect(w, r, "/", http.StatusFound)
	return nil
}
Beispiel #6
0
// count active users in channel with channels.info then users.getPresence
// very slow due to network
func activeUsersInChannel(c context.Context, channelId string) (users []string, err error) {
	bot := bot.WithClient(urlfetch.Client(c))
	members, err := bot.ChannelsInfo(channelId)
	l.Infof(c, "check %v", members)
	active := make(chan string, len(members))
	var wg sync.WaitGroup
	for i := range members {
		wg.Add(1)
		go func(user string, active chan string, wg *sync.WaitGroup) {
			defer wg.Done()
			l.Infof(c, "begin "+user)
			if p, err := bot.UsersGetPresence(user); err != nil {
				l.Errorf(c, "%s", err)
				return
			} else if p == "active" {
				active <- user
			}
			l.Infof(c, "done "+user)
		}(members[i], active, &wg)
	}
	wg.Wait()
	l.Infof(c, "done wait")
	close(active)
	users = make([]string, len(members))
	for user := range active {
		users = append(users, user)
	}
	return
}
Beispiel #7
0
func SendSimpleMessageHandler(w http.ResponseWriter, r *http.Request) {
	ctx := appengine.NewContext(r)
	httpc := urlfetch.Client(ctx)

	mg := mailgun.NewMailgun(
		"YOUR_DOMAIN_NAME", // Domain name
		"YOUR_API_KEY",     // API Key
		"YOUR_PUBLIC_KEY",  // Public Key
	)
	mg.SetClient(httpc)

	msg, id, err := mg.Send(mg.NewMessage(
		/* From */ "Excited User <mailgun@YOUR_DOMAIN_NAME>",
		/* Subject */ "Hello",
		/* Body */ "Testing some Mailgun awesomness!",
		/* To */ "*****@*****.**", "YOU@YOUR_DOMAIN_NAME",
	))
	if err != nil {
		msg := fmt.Sprintf("Could not send message: %v, ID %d, %+v", err, id, msg)
		http.Error(w, msg, http.StatusInternalServerError)
		return
	}

	w.Write([]byte("Message sent!"))
}
Beispiel #8
0
func getAccessToken(ctx context.Context, state, code string) (string, error) {
	values := make(url.Values)
	values.Add("client_id", "vmqwbq2tj8l57k9")
	values.Add("client_secret", "rpcztciueyunhba")
	values.Add("grant_type", "authorization_code")
	values.Add("code", code)
	values.Add("redirect_uri", redirectURI)

	client := urlfetch.Client(ctx)
	response, err := client.PostForm("https://api.dropbox.com/1/oauth2/token", values)
	if err != nil {
		return "", err
	}
	defer response.Body.Close()

	bs, _ := ioutil.ReadAll(response.Body)

	var data struct {
		AccessToken string `json:"access_token"`
		TokenType   string `json:"token_type"`
		UID         string `json:"uid"`
	}
	err = json.Unmarshal(bs, &data)
	if err != nil {
		return "", err
	}
	if data.AccessToken == "" {
		return "", fmt.Errorf("Invalid Access Token:%s", string(bs))
	}
	return data.AccessToken, nil
}
Beispiel #9
0
func authCallbackHandler(w http.ResponseWriter, r *http.Request) {
	ctx := appengine.NewContext(r)
	c := NewTwitterClient(ctx)
	token := r.FormValue("oauth_token")
	verificationCode := r.FormValue("oauth_verifier")
	log.Debugf(ctx, "oauth_token:%v oauth_verifier:%v", token, verificationCode)
	requestToken := FindRequest(ctx, token)
	if requestToken == nil {
		fmt.Fprint(w, "token not found")
		w.WriteHeader(500)
		return
	}
	accessToken, err := c.AuthorizeToken(requestToken, verificationCode)
	if err != nil {
		fmt.Fprint(w, err)
		w.WriteHeader(500)
		return
	}
	fmt.Fprintln(w, accessToken.AdditionalData)
	api := anaconda.NewTwitterApi(accessToken.Token, accessToken.Secret)
	api.HttpClient = urlfetch.Client(ctx)
	ok, err := api.VerifyCredentials()
	if err != nil {
		fmt.Fprint(w, err)
		w.WriteHeader(500)
		return
	}
	fmt.Fprintln(w, ok)
}
Beispiel #10
0
func updateFromSource2ForAppEngine(r *http.Request) (int64, bool, error) {
	var result int64
	ctx := appengine.NewContext(r)
	client := urlfetch.Client(ctx)
	resp, err := client.Get(source2Url)
	if err != nil {
		return 0, false, err
	}
	defer resp.Body.Close()

	dec := json.NewDecoder(resp.Body)
	if resp.StatusCode == 200 {
		var rate entities.Rate2Response
		dec.Decode(&rate)
		result = rate.TimestampUnix
		repo := repository.New(repoSize, true, r)
		if err := repo.Push(entities.Rate{
			Base: rate.Base,
			ID:   rate.TimestampUnix,
			RUB:  rate.Quotes["USDRUB"],
			JPY:  rate.Quotes["USDJPY"],
			GBP:  rate.Quotes["USDGBP"],
			USD:  rate.Quotes["USDUSD"],
			EUR:  rate.Quotes["USDEUR"],
			CNY:  rate.Quotes["USDCNY"],
			CHF:  rate.Quotes["USDCHF"]}); err != nil {
			return 0, false, fmt.Errorf("Push rate to repo error: %v", err)
		}
	} else {
		var err2Resp entities.Error2Response
		dec.Decode(&err2Resp)
		return 0, false, fmt.Errorf(err2Resp.ToString())
	}
	return result, true, nil
}
func notify(ctx context.Context, title, body string, to []string) error {
	b, err := json.Marshal(PostData{
		Notification: Notification{
			Title: title,
			Body:  body,
			Icon:  "ic_battery_alert_black",
			Tag:   "battery_low",
		},
		RegistrationIds: to,
		CollapseKey:     "battery_low",
	})

	if err != nil {
		return err
	}

	req, err := http.NewRequest("POST", "https://gcm-http.googleapis.com/gcm/send", bytes.NewReader(b))
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "key="+keys.GcmApplicationKey)

	c := urlfetch.Client(ctx)
	resp, err := c.Do(req)
	if err != nil {
		return err
	}

	log.Print(resp)

	return nil
}
Beispiel #12
0
// serveTwitterCallback handles callbacks from the Twitter OAuth server.
func serveTwitterCallback(c *context) error {
	token := c.r.FormValue("oauth_token")
	var ci connectInfo
	_, err := memcache.Gob.Get(c.c, token, &ci)
	if err != nil {
		return err
	}
	memcache.Delete(c.c, token)
	tempCred := &oauth.Credentials{
		Token:  token,
		Secret: ci.Secret,
	}

	httpClient := urlfetch.Client(c.c)
	tokenCred, _, err := oauthClient.RequestToken(httpClient, tempCred, c.r.FormValue("oauth_verifier"))
	if err != nil {
		return err
	}

	if err := c.updateUserInfo(func(u *userInfo) { u.TwitterCred = *tokenCred }); err != nil {
		return err
	}
	http.Redirect(c.w, c.r, ci.Redirect, 302)
	return nil
}
//createAppendingeStripeClient creates an httpclient on a per-request basis for use in making api calls to Stripe
//stripe's api is accessed via http requests, need a way to make these requests
//urlfetch is the appengine way of making http requests
//this func returns an httpclient *per request* aka per request to this app
//otherwise one request could use another requests httpclient
//this is for app engine only since the golang http.DefaultClient is unavailable
func createAppengineStripeClient(c context.Context) *client.API {
	//create http client
	httpClient := urlfetch.Client(c)

	//returns "sc" stripe client
	return client.New(stripePrivateKey, stripe.NewBackends(httpClient))
}
Beispiel #14
0
func downloadAccessToken(c context.Context, url string, auth *osin.BasicAuth, output map[string]interface{}) error {
	// download access token
	log.Infof(c, "Downloading token from %v", url)
	preq, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return err
	}
	if auth != nil {
		preq.SetBasicAuth(auth.Username, auth.Password)
	}

	pclient := urlfetch.Client(c)

	presp, err := pclient.Do(preq)
	if err != nil {
		return err
	}

	if presp.StatusCode != 200 {
		return errors.New("Invalid status code")
	}
	jdec := json.NewDecoder(presp.Body)
	err = jdec.Decode(&output)

	return err
}
Beispiel #15
0
func giffy(res http.ResponseWriter, req *http.Request) {
	ctx := appengine.NewContext(req)

	t := req.FormValue("term") + "gaming"

	client := urlfetch.Client(ctx)
	result, err := client.Get("http://api.giphy.com/v1/gifs/search?q=" + t + "&api_key=dc6zaTOxFJmzC")
	if err != nil {
		http.Error(res, err.Error(), 500)
		return
	}
	defer result.Body.Close()
	var obj struct {
		Data []struct {
			URL    string `json:"url"`
			Images struct {
				Original struct {
					URL string
				}
			}
		}
	}
	err = json.NewDecoder(result.Body).Decode(&obj)
	if err != nil {
		http.Error(res, err.Error(), 500)
		return
	}
	for _, img := range obj.Data {
		fmt.Fprintf(res, `<a href="%v">%v</a><img src="%v"><br>`, img.URL, img.URL, img.Images.Original.URL)
	}
	cookie := genCookie(res, req)
	m := Model(cookie)
	tpl.ExecuteTemplate(res, "gifs.html", m)
}
Beispiel #16
0
func SendComplexMessageHandler(w http.ResponseWriter, r *http.Request) {
	ctx := appengine.NewContext(r)
	httpc := urlfetch.Client(ctx)

	mg := mailgun.NewMailgun(
		"YOUR_DOMAIN_NAME", // Domain name
		"YOUR_API_KEY",     // API Key
		"YOUR_PUBLIC_KEY",  // Public Key
	)
	mg.SetClient(httpc)

	message := mg.NewMessage(
		/* From */ "Excited User <mailgun@YOUR_DOMAIN_NAME>",
		/* Subject */ "Hello",
		/* Body */ "Testing some Mailgun awesomness!",
		/* To */ "*****@*****.**",
	)
	message.AddCC("*****@*****.**")
	message.AddBCC("*****@*****.**")
	message.SetHtml("<html>HTML version of the body</html>")
	message.AddAttachment("files/test.jpg")
	message.AddAttachment("files/test.txt")

	msg, id, err := mg.Send(message)
	if err != nil {
		msg := fmt.Sprintf("Could not send message: %v, ID %d, %+v", err, id, msg)
		http.Error(w, msg, http.StatusInternalServerError)
		return
	}

	w.Write([]byte("Message sent!"))
}
Beispiel #17
0
func (session *Session) makeRequest(url string, params Params) ([]byte, error) {
	buf := &bytes.Buffer{}
	mime, err := params.Encode(buf)

	if err != nil {
		return nil, fmt.Errorf("cannot encode params. %v", err)
	}

	client := urlfetch.Client(session.context)

	//HACK: http://stackoverflow.com/questions/10523906/sslcertificateerror-the-handshake-operation-timed-out-when-trying-to-get-an
	transport := client.Transport.(*urlfetch.Transport)
	transport.AllowInvalidServerCertificate = true

	response, err := client.Post(url, mime, buf)

	if err != nil {
		return nil, fmt.Errorf("cannot reach facebook server. %v", err)
	}

	defer response.Body.Close()

	buf = &bytes.Buffer{}
	_, err = io.Copy(buf, response.Body)

	if err != nil {
		return nil, fmt.Errorf("cannot read facebook response. %v", err)
	}

	return buf.Bytes(), nil
}
Beispiel #18
0
func (calculations *Calculations) GetMap(r *http.Request) (string, error) {
	var mapCountries = []string{}
	var mapColors = []string{"DBDCDD"}

	for _, country := range calculations.CountryShare.Countries {
		mapCountries = append(mapCountries, country.Code)
		mapColors = append(mapColors, MAP_HIGHLIGHTED_COLOR)
	}

	urlParams := []string{MAP_URL,
		"chld=" + strings.Join(mapCountries, "|"),
		"chco=" + strings.Join(mapColors, "|"),
	}

	ctx := newappengine.NewContext(r)
	client := urlfetch.Client(ctx)
	resp, err := client.Get(strings.Join(urlParams, "&"))
	if err != nil {
		return "", err
	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}
	result := base64.StdEncoding.EncodeToString(body)
	result = "data:image/png;base64," + result
	return result, nil
}
Beispiel #19
0
func handleGetGif(res http.ResponseWriter, req *http.Request) {
	ctx := appengine.NewContext(req)

	t := req.FormValue("term")
	if t == "" {
		t = "funny+cat"
	}

	client := urlfetch.Client(ctx)
	result, err := client.Get("http://api.giphy.com/v1/gifs/search?q=" + t + "&api_key=dc6zaTOxFJmzC")
	if err != nil {
		http.Error(res, err.Error(), 500)
		return
	}
	defer result.Body.Close()
	var obj struct {
		Data []struct {
			URL    string `json:"url"`
			Images struct {
				Original struct {
					URL string
				}
			}
		}
	}
	err = json.NewDecoder(result.Body).Decode(&obj)
	if err != nil {
		http.Error(res, err.Error(), 500)
		return
	}
	for _, img := range obj.Data {
		fmt.Fprintf(res, `<a href="%v">%v</a><img src="%v"><br>`, img.URL, img.URL, img.Images.Original.URL)
	}
}
Beispiel #20
0
func chargeAccount(ctx context.Context, stripeToken string) error {
	// because we're on app engine, use a custom http client
	b := stripe.BackendConfiguration{
		stripe.APIBackend,
		"https://api.stripe.com/v1",
		urlfetch.Client(ctx),
	}

	id, _ := uuid.NewV4()

	for {
		chargeParams := &stripe.ChargeParams{
			Amount:   100 * 200000,
			Currency: "usd",
			Desc:     "Charge for [email protected]",
		}
		chargeParams.IdempotencyKey = id.String()
		chargeParams.SetSource(stripeToken)
		chargeClient := &charge.Client{
			Key: stripe.Key,
			B:   b,
		}
		ch, err := chargeClient.New(chargeParams)
		if err != nil {
			if nerr, ok := err.(net.Error); ok && nerr.Temporary() {
				time.Sleep(time.Second)
				continue
			}
			return err
		}
		log.Infof(ctx, "CHARGE: %v", ch)
		return nil
	}
}
// PrimaryPublicCertificates returns primary's PublicCertificates.
func PrimaryPublicCertificates(c context.Context, primaryURL string) (*PublicCertificates, error) {
	cacheKey := fmt.Sprintf("pub_certs:%s", primaryURL)
	var pubCerts []byte
	setCache := false
	item, err := memcache.Get(c, cacheKey)
	if err != nil {
		setCache = true
		if err != memcache.ErrCacheMiss {
			log.Warningf(c, "failed to get cert from cache: %v", err)
		}
		pubCerts, err = downloadCert(urlfetch.Client(c), primaryURL)
		if err != nil {
			log.Errorf(c, "failed to download cert: %v", err)
			return nil, err
		}
	} else {
		pubCerts = item.Value
	}
	pc := &PublicCertificates{}
	if err = json.Unmarshal(pubCerts, pc); err != nil {
		log.Errorf(c, "failed to unmarshal cert: %v %v", string(pubCerts), err)
		return nil, err
	}
	if setCache {
		err = memcache.Set(c, &memcache.Item{
			Key:        cacheKey,
			Value:      pubCerts,
			Expiration: time.Hour,
		})
		if err != nil {
			log.Warningf(c, "failed to set cert to cache: %v", err)
		}
	}
	return pc, nil
}
Beispiel #22
0
func (api *GithubAPI) getAccessToken(state, code string) (string, error) {
	values := make(url.Values)
	values.Add("client_id", "767154e6915134caade5")
	values.Add("client_secret", "50648a71510c21bb77e229692fc882dfbe8ea35d")
	values.Add("code", code)
	values.Add("state", state)

	client := urlfetch.Client(api.ctx)
	response, err := client.PostForm("https://github.com/login/oauth/access_token", values)
	if err != nil {
		return "", err
	}
	defer response.Body.Close()

	bs, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return "", err
	}

	values, err = url.ParseQuery(string(bs))
	if err != nil {
		return "", err
	}
	return values.Get("access_token"), nil
}
Beispiel #23
0
func jobV2adsbHandler(r *http.Request, f *oldfdb.Flight) (string, error) {
	c := appengine.NewContext(r)
	str := ""

	if f.HasTrack("ADSB") {
		return "", nil
	} // Already has one

	err, deb := f.GetV2ADSBTrack(urlfetch.Client(c))
	str += fmt.Sprintf("*getv2ADSB [%v]:-\n", err, deb)
	if err != nil {
		return str, err
	}

	if !f.HasTrack("ADSB") {
		return "", nil
	} // Didn't find one

	f.Analyse() // Retrigger Class-B stuff

	db := oldfgae.FlightDB{C: oldappengine.NewContext(r)}
	if err := db.UpdateFlight(*f); err != nil {
		log.Errorf(c, "Persist Flight %s: %v", f, err)
		return str, err
	}
	log.Infof(c, "Updated flight %s", f)
	str += fmt.Sprintf("--\nFlight was updated\n")

	return str, nil
}
Beispiel #24
0
func recaptchaCheck(ctx context.Context, response, ip string) (bool, error) {
	if appengine.IsDevAppServer() {
		return true, nil
	}

	form := url.Values{}
	form.Add("secret", os.Getenv("SECRET"))
	form.Add("response", response)
	form.Add("remoteip", ip)
	req, err := http.NewRequest("POST", recaptchaURL, strings.NewReader(form.Encode()))
	if err != nil {
		return false, err
	}

	cli := urlfetch.Client(ctx)

	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
	resp, err := cli.Do(req)
	if err != nil {
		return false, err
	}

	var recaptcha recaptchaResponse
	if err := json.NewDecoder(resp.Body).Decode(&recaptcha); err != nil {
		return false, err
	}

	if !recaptcha.Success {
		log.Warningf(ctx, "%+v", recaptcha)
		return false, nil
	}

	return true, nil
}
Beispiel #25
0
func (api *GithubAPI) getAccessToken(state, code string) (string, error) {
	values := make(url.Values)
	values.Add("client_id", "0ccd33716940f347065e")
	values.Add("client_secret", "4c21ab338de0449ae13019de25629a7b85e08641")
	values.Add("code", code)
	values.Add("state", state)

	client := urlfetch.Client(api.ctx)
	response, err := client.PostForm("https://github.com/login/oauth/access_token", values)
	if err != nil {
		return "", err
	}
	defer response.Body.Close()

	bs, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return "", err
	}

	values, err = url.ParseQuery(string(bs))
	if err != nil {
		return "", err
	}
	return values.Get("access_token"), nil
}
Beispiel #26
0
func Client(c context.Context) *xmlsoccer.Client {
	return &xmlsoccer.Client{
		BaseURL: xmlsoccer.DemoURL,
		APIKey:  os.Getenv("XMLSOCCER_API_KEY"),
		Client:  urlfetch.Client(c),
	}
}
Beispiel #27
0
// Do performs the request, the json received in the response is decoded
// and stored in the value pointed by v.
// Do can be used to perform the request created with NewRequest, as the latter
// it should be used only for API requests not implemented in this library.
func (c *Client) Do(req *http.Request, v interface{}) (*http.Response, error) {

	resp, err := urlfetch.Client(c.ctx).Do(req)
	if err != nil {
		return nil, err
	}

	defer resp.Body.Close()

	if AuthTest {
		// If AuthTest is enabled, the reponse won't be the
		// one defined in the API endpoint.
		err = json.NewDecoder(resp.Body).Decode(&AuthTestResponse)
	} else {
		if c := resp.StatusCode; c < 200 || c > 299 {
			return resp, fmt.Errorf("Server returns status %d", c)
		}

		if v != nil {
			if w, ok := v.(io.Writer); ok {
				io.Copy(w, resp.Body)
			} else {
				err = json.NewDecoder(resp.Body).Decode(v)
			}
		}
	}
	return resp, err
}
Beispiel #28
0
// Call out to the flight database, and get back a condensed summary of the flights (flightnumber,
// times, waypoints) which flew to/from a NORCAL airport (SFO,SJC,OAK) for the time range (a day?)
func GetProcedureMap(r *http.Request, s, e time.Time) (map[string]fdb.CondensedFlight, error) {
	ret := map[string]fdb.CondensedFlight{}

	// This procedure map stuff is expensive, and brittle; so disable by default.
	return ret, nil

	client := urlfetch.Client(req2ctx(r))

	encoding := "gob"
	url := fmt.Sprintf("http://fdb.serfr1.org/api/procedures?encoding=%s&tags=:NORCAL:&s=%d&e=%d",
		encoding, s.Unix(), e.Unix())

	condensedFlights := []fdb.CondensedFlight{}

	if resp, err := client.Get(url); err != nil {
		return ret, err
	} else {
		defer resp.Body.Close()

		if resp.StatusCode != http.StatusOK {
			return ret, fmt.Errorf("Bad status fetching proc map for %s: %v", url, resp.Status)
		} else if err := ReadEncodedData(resp, encoding, &condensedFlights); err != nil {
			return ret, err
		}
	}

	for _, cf := range condensedFlights {
		ret[cf.BestFlightNumber] = cf
	}

	return ret, nil
}
Beispiel #29
0
func chargeAccount(ctx context.Context, stripeToken string) error {
	// because we're on app engine, use a custom http client
	// this is being set globally, however
	// if we wanted to do it this way, we'd have to use a lock
	// https://youtu.be/KT4ki_ClX2A?t=1018
	hc := urlfetch.Client(ctx)
	stripe.SetHTTPClient(hc)

	id, _ := uuid.NewV4()

	for {
		chargeParams := &stripe.ChargeParams{
			Amount:   100 * 200000,
			Currency: "usd",
			Desc:     "Charge for [email protected]",
		}
		chargeParams.IdempotencyKey = id.String()
		chargeParams.SetSource(stripeToken)
		ch, err := charge.New(chargeParams)
		// https://youtu.be/KT4ki_ClX2A?t=1310
		if err != nil {
			if nerr, ok := err.(net.Error); ok && nerr.Temporary() {
				time.Sleep(time.Second)
				continue
			}
			return err
		}
		log.Infof(ctx, "CHARGE: %v", ch)
		log.Infof(ctx, "IDEMPOTENCY: %v", chargeParams.IdempotencyKey)
		return nil
	}
}
Beispiel #30
0
func handleCron(w http.ResponseWriter, r *http.Request) *appError {
	// X-Appengine-Cron: true
	c := appengine.NewContext(r)
	a, err := LoadMagazines(c)
	if err != nil {
		return &appError{
			Error:   err,
			Message: "failed to load",
			Code:    http.StatusInternalServerError,
		}
	}
	client := urlfetch.Client(c)
	for _, m := range a {
		f, err := fetchFeed(client, m.URL)
		if err != nil {
			log.Errorf(c, "fetch url: %v", err)
			continue
		}
		if err = SendArticles(c, m, f); err != nil {
			log.Errorf(c, "send article: %v", err)
			continue
		}
	}
	return nil
}