Example #1
1
func sortQuery(u *url.URL) {
	q := u.Query()
	if len(q) == 0 {
		return
	}
	arKeys := make([]string, len(q))
	i := 0
	for k, _ := range q {
		arKeys[i] = k
		i++
	}
	sort.Strings(arKeys)
	buf := new(bytes.Buffer)
	for _, k := range arKeys {
		sort.Strings(q[k])
		for _, v := range q[k] {
			if buf.Len() > 0 {
				buf.WriteRune('&')
			}
			buf.WriteString(fmt.Sprintf("%s=%s", k, url.QueryEscape(v)))
		}
	}

	// Rebuild the raw query string
	u.RawQuery = buf.String()
}
func SignAmazonUrl(origUrl *url.URL, api AmazonProductAPI) (signedUrl string, err error) {

	escapeUrl := strings.Replace(origUrl.RawQuery, ",", "%2C", -1)
	escapeUrl = strings.Replace(escapeUrl, ":", "%3A", -1)

	params := strings.Split(escapeUrl, "&")
	sort.Strings(params)
	sortedParams := strings.Join(params, "&")

	toSign := fmt.Sprintf("GET\n%s\n%s\n%s", origUrl.Host, origUrl.Path, sortedParams)

	hasher := hmac.New(sha256.New, []byte(api.SecretKey))
	_, err = hasher.Write([]byte(toSign))
	if err != nil {
		return "", err
	}

	hash := base64.StdEncoding.EncodeToString(hasher.Sum(nil))

	hash = url.QueryEscape(hash)

	newParams := fmt.Sprintf("%s&Signature=%s", sortedParams, hash)

	origUrl.RawQuery = newParams

	return origUrl.String(), nil
}
func returnlatlng(address string) interface{} {
	var Url *url.URL
	Url, err := url.Parse("http://maps.google.com")
	if err != nil {
		panic("Error Panic")
	}

	Url.Path += "/maps/api/geocode/json"
	//fmt.Println(address)
	parameters := url.Values{}
	parameters.Add("address", address)
	Url.RawQuery = parameters.Encode()
	Url.RawQuery += "&sensor=false"

	// fmt.Println("URL " + Url.String())

	res, err := http.Get(Url.String())
	//
	if err != nil {
		panic("Error Panic")
	}
	//  fmt.Println(res)
	defer res.Body.Close()
	var v map[string]interface{}
	dec := json.NewDecoder(res.Body)
	if err := dec.Decode(&v); err != nil {
		fmt.Println("ERROR: " + err.Error())
	}

	lat := v["results"].([]interface{})[0].(map[string]interface{})["geometry"].(map[string]interface{})["location"] //.(map[string]interface{})["lat"]
	//fmt.Println(lat)
	// lng := v["results"].([]interface{})[0].(map[string] interface{})["geometry"].(map[string] interface{})["location"].(map[string]interface{})["lng"]
	//fmt.Println("The latittude",lat,"and the longitude",lng)
	return lat
}
Example #4
0
func Test_buildRequestUrl(t *testing.T) {
	user, _ := user.Current()
	url1 := url.URL{Scheme: "http", Host: "localhost:8080", Path: "/webhdfs/v1/test"}

	q := url1.Query()
	q.Set("user.name", user.Username)
	url1.RawQuery = q.Encode()

	conf := Configuration{Addr: url1.Host}

	u, err := buildRequestUrl(conf, &Path{Name: "/test"}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if url1 != *u {
		t.Errorf("Expecting url [%v], but got [%v]", url1.String(), u.String())
	}

	// test with params
	v := url.Values{}
	v.Add("op1", "OP_1")
	v.Add("op2", "OP_2")
	v.Add("user.name", user.Username)
	url1.RawQuery = v.Encode()

	params := map[string]string{
		"op1": "OP_1",
		"op2": "OP_2",
	}

	u, err = buildRequestUrl(conf, &Path{Name: "/test"}, &params)
	if url1 != *u {
		t.Errorf("Expecting url [%v], but got [%v]", url1.String(), u.String())
	}
}
Example #5
0
func (cam *Camera) url(action string, params *map[string]string) string {
	u := url.URL{}
	q := url.Values{}

	u.Scheme = "http"
	u.Host = cam.ipaddress
	u.Path = "/camera/" + action

	if params != nil {
		for key, value := range *params {
			q.Set(key, value)
		}
	}

	// GoPro expects parameters in a certain order,
	// the password always has to be the first.
	// So this won't work at the moment:
	// q.Set("t", cam.password)

	// Instead we prepend the password "manually":
	u.RawQuery = "t=" + cam.password

	if query := q.Encode(); len(query) > 0 {
		u.RawQuery += "&" + query
	}

	return u.String()
}
Example #6
0
func getLinkToNextPage(
	requestURL url.URL,
	offset int64,
	limit int64,
	total int64,
) LinkType {
	maxOffset := GetMaxOffset(total, limit)

	if offset+limit <= maxOffset {
		offset = offset + limit
		q := requestURL.Query()
		q.Set("offset", strconv.FormatInt(offset, 10))
		requestURL.RawQuery = q.Encode()
	} else if offset == 0 {
		offset = 0
		q := requestURL.Query()
		q.Del("offset")
		requestURL.RawQuery = q.Encode()
	}

	return LinkType{
		Rel:   "next",
		Href:  requestURL.String(),
		Title: getPageNumberAsTitle(offset, limit),
	}
}
Example #7
0
File: vk.go Project: Alezhka/vk
// URL returns redirect url for application authentication
func (a Auth) URL() string {
	u := url.URL{}
	u.Host = oauthHost
	u.Scheme = oauthScheme
	u.Path = oauthPath

	if len(a.RedirectURI) == 0 {
		a.RedirectURI = oauthRedirectURI
	}
	if len(a.ResponseType) == 0 {
		a.ResponseType = oauthResponseType
	}
	if len(a.Display) == 0 {
		a.Display = oauthDisplay
	}

	values := u.Query()
	values.Add(paramResponseType, a.ResponseType)
	values.Add(paramScope, a.Scope.String())
	values.Add(paramAppID, int64s(a.ID))
	values.Add(paramRedirectURI, a.RedirectURI)
	values.Add(paramVersion, defaultVersion)
	values.Add(paramDisplay, a.Display)
	u.RawQuery = values.Encode()

	return u.String()
}
func GetSinglePricePrepped(name string, appid uint64) (*AssetPrice, error) {
	var Url *url.URL

	Url, err := url.Parse(baseUrl + "/market/priceoverview")
	if err != nil {
		panic(err)
	}

	parameters := url.Values{}
	parameters.Add("currency", Currency)
	parameters.Add("appid", fmt.Sprintf("%v", appid))
	parameters.Add("market_hash_name", name)
	Url.RawQuery = parameters.Encode()

	client := http.Client{Timeout: time.Duration(60) * time.Second}
	req, _ := http.NewRequest("GET", Url.String(), nil)

	resp, err := client.Do(req)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	defer resp.Body.Close()

	var jsonResp AssetPrice

	err = json.NewDecoder(resp.Body).Decode(&jsonResp)
	if err != nil {
		return nil, err
	}

	return &jsonResp, nil

}
Example #9
0
func apicall(u *neturl.URL) (*http.Response, error) {
	apikeys := []string{
		"sehm98r8ss3fddjfs8rwxur435xjav94",
		"trtrn4tdhzeruuypctm55a8m5td9z4ce",
		"cc7qrdaxn9h47ds39nmgzb9hnutxfsrr",
		"cbygdtw624xmfn2hr2sw3ayaeekg9cvy",
		"7zsnd2q7npg5bch8hacae7t28xskn8vr",
	}

	// if val, ok := options["apikey"]; ok {
	// 	apikeys = append([]string{to.String(val)}, apikeys...)
	// }

	rawQuery := u.RawQuery
	if len(rawQuery) > 0 {
		rawQuery += "&apikey="
	} else {
		rawQuery += "apikey="
	}

	var resp *http.Response
	var apierr error
	for _, apikey := range apikeys {
		u.RawQuery = rawQuery + apikey
		resp, apierr = http.Get(u.String())
		if apierr == nil {
			return resp, nil
		}
	}

	return nil, merry.Wrap(apierr)
}
Example #10
0
func rpmURL(cmd RpmCmd, cs RpmControls) string {
	var u url.URL

	u.Host = cmd.Collector
	u.Path = "agent_listener/invoke_raw_method"

	if cs.UseTLS {
		u.Scheme = "https"
	} else {
		u.Scheme = "http"
	}

	query := url.Values{}
	query.Set("marshal_format", "json")
	query.Set("protocol_version", procotolVersion)
	query.Set("method", cmd.Name)
	query.Set("license_key", cs.License)

	if len(cmd.RunID) > 0 {
		query.Set("run_id", cmd.RunID)
	}

	u.RawQuery = query.Encode()
	return u.String()
}
Example #11
0
func encodeToken(referal *url.URL, outhToken *oauth2.Token) error {
	str := outhToken.Extra("expires_in")
	expiresIn, err := strconv.Atoi(fmt.Sprintf("%v", str))
	if err != nil {
		return errs.WithStack(errors.New("cant convert expires_in to integer " + err.Error()))
	}
	str = outhToken.Extra("refresh_expires_in")
	refreshExpiresIn, err := strconv.Atoi(fmt.Sprintf("%v", str))
	if err != nil {
		return errs.WithStack(errors.New("cant convert refresh_expires_in to integer " + err.Error()))
	}
	tokenData := &app.TokenData{
		AccessToken:      &outhToken.AccessToken,
		RefreshToken:     &outhToken.RefreshToken,
		TokenType:        &outhToken.TokenType,
		ExpiresIn:        &expiresIn,
		RefreshExpiresIn: &refreshExpiresIn,
	}
	b, err := json.Marshal(tokenData)
	if err != nil {
		return errs.WithStack(errors.New("cant marshal token data struct " + err.Error()))
	}

	parameters := url.Values{}
	parameters.Add("token", outhToken.AccessToken) // Temporary keep the old "token" param. We will drop this param as soon as UI adopt the new json param.
	parameters.Add("token_json", string(b))
	referal.RawQuery = parameters.Encode()

	return nil
}
Example #12
0
func GetNameBySymbol(s string) (string, bool) {
	u := url.URL{Scheme: "http", Host: "hq.sinajs.cn", Path: "/"}
	q := u.Query()
	q.Set("list", s)
	u.RawQuery = q.Encode()
	log.Println(u.String())

	res, err := http.Get(u.String())
	if err != nil {
		log.Println(err.Error())
		return "", false
	}
	body, err := ioutil.ReadAll(res.Body)
	defer res.Body.Close()
	if err != nil {
		log.Println(err.Error())
		return "", false
	}
	//	log.Println(GBKtoUTF8(string(body)))
	content := string(body)
	if strings.Contains(content, ",") != true {
		log.Println("Invalid symbol")
		return "", false
	}
	name := content[strings.Index(content, "\"")+1 : strings.Index(content, ",")]
	log.Println(GBKtoUTF8(name))

	//	log.Printf("length:%d\n", len(name))

	return GBKtoUTF8(name), true

}
Example #13
0
// URL returns a suitable URL, such as for the Google Authenticator app
// example: otpauth://totp/Example:[email protected]?secret=JBSWY3DPEHPK3PXP&issuer=Example
func (otp *Totp) url() (string, error) {

	// verify the proper initialization
	if err := totpHasBeenInitialized(otp); err != nil {
		return "", err
	}

	secret := base32.StdEncoding.EncodeToString(otp.key)
	u := url.URL{}
	v := url.Values{}
	u.Scheme = "otpauth"
	u.Host = "totp"
	u.Path = otp.label()
	v.Add("secret", secret)
	v.Add("counter", fmt.Sprintf("%d", otp.getIntCounter()))
	v.Add("issuer", otp.issuer)
	v.Add("digits", strconv.Itoa(otp.digits))
	v.Add("period", strconv.Itoa(otp.stepSize))
	switch otp.hashFunction {
	case crypto.SHA256:
		v.Add("algorithm", "SHA256")
		break
	case crypto.SHA512:
		v.Add("algorithm", "SHA512")
		break
	default:
		v.Add("algorithm", "SHA1")
		break
	}
	u.RawQuery = v.Encode()
	return u.String(), nil
}
Example #14
0
// Download and parse OAuth2 JSON access request
func downloadData(method string, u *url.URL, auth *BasicAuth, transport http.RoundTripper, output ResponseData) error {
	var postdata url.Values
	var body io.Reader
	var contenttype string

	if method == "POST" {
		// Convert query parameters to post data
		postdata = u.Query()
		u.RawQuery = ""
		body = strings.NewReader(postdata.Encode())
		contenttype = "application/x-www-form-urlencoded"
	}

	// Create a new request
	preq, err := http.NewRequest(method, u.String(), body)
	if err != nil {
		return err
	}

	if auth != nil {
		preq.SetBasicAuth(auth.Username, auth.Password)
	}

	// Set content type for post request
	if contenttype != "" {
		preq.Header.Set("Content-Type", contenttype)
	}

	// Explicitly set accept header to JSON
	preq.Header.Set("Accept", "application/json")

	// do request
	client := &http.Client{}
	if transport != nil {
		client.Transport = transport
	}
	presp, err := client.Do(preq)
	if err != nil {
		return err
	}

	// must close body
	defer presp.Body.Close()

	// decode JSON and detect OAuth error
	jdec := json.NewDecoder(presp.Body)
	if err = jdec.Decode(&output); err == nil {
		if em, eok := output["error"]; eok {
			return NewError(fmt.Sprintf("%v", em), fmt.Sprintf("%v", output["error_description"]),
				fmt.Sprintf("%v", output["error_uri"]), fmt.Sprintf("%v", output["state"]))
		}
	}

	// If no OAuth error was detected, make sure we don't return success in an error case
	if err == nil && presp.StatusCode != 200 {
		return errors.New(fmt.Sprintf("Invalid status code (%d): %s", presp.StatusCode, presp.Status))
	}

	return err
}
Example #15
0
func ForwardToErrorHandler(w http.ResponseWriter, r *http.Request, err error, errorHandlerURL url.URL) {
	q := errorHandlerURL.Query()
	q.Set("error", err.Error())
	errorHandlerURL.RawQuery = q.Encode()

	http.Redirect(w, r, errorHandlerURL.String(), http.StatusFound)
}
Example #16
0
func TwitchLoginHandler(w http.ResponseWriter, r *http.Request) {
	token, err := controllerhelpers.GetToken(r)
	if err == http.ErrNoCookie {
		http.Error(w, "You are not logged in.", http.StatusUnauthorized)
		return
	} else if err != nil {
		http.Error(w, "Invalid jwt", http.StatusBadRequest)
		return
	}

	id := token.Claims.(*controllerhelpers.TF2StadiumClaims).PlayerID
	player, _ := player.GetPlayerByID(id)
	loginURL := url.URL{
		Scheme: "https",
		Host:   "api.twitch.tv",
		Path:   "kraken/oauth2/authorize",
	}

	//twitchRedirectURL := config.Constants.PublicAddress + "/" + "twitchAuth"
	twitchRedirectURL, _ := url.Parse(config.Constants.PublicAddress)
	twitchRedirectURL.Path = "twitchAuth"

	values := loginURL.Query()
	values.Set("response_type", "code")
	values.Set("client_id", config.Constants.TwitchClientID)
	values.Set("redirect_uri", twitchRedirectURL.String())
	values.Set("scope", "channel_check_subscription user_subscriptions channel_subscriptions user_read")
	values.Set("state", xsrftoken.Generate(config.Constants.CookieStoreSecret, player.SteamID, "GET"))
	loginURL.RawQuery = values.Encode()

	http.Redirect(w, r, loginURL.String(), http.StatusTemporaryRedirect)
}
Example #17
0
func (s *server) buildURL(method, id string, opts streamOpts) string {
	loc := url.URL{
		Scheme: "http",
		Host:   s.config.Addr,
		Path:   fmt.Sprintf("/%s/%s", method, id),
	}
	if s.config.TLSConfig != nil {
		loc.Scheme = "https"
	}

	query := url.Values{}
	if opts.stdin {
		query.Add(urlParamStdin, "1")
	}
	if opts.stdout {
		query.Add(urlParamStdout, "1")
	}
	if opts.stderr {
		query.Add(urlParamStderr, "1")
	}
	if opts.tty {
		query.Add(urlParamTTY, "1")
	}
	for _, c := range opts.command {
		query.Add(urlParamCommand, c)
	}
	loc.RawQuery = query.Encode()

	return loc.String()
}
Example #18
0
//Req : base request for ipfs access
func (fs *IPfsfs) Req(path string, arg string) (resp *http.Response, size int64, err error) {
	u := url.URL{}
	u.Scheme = "http"
	u.Host = ipfsHost
	u.Path = api + path
	if arg != "" {
		val := url.Values{}
		val.Set("arg", arg)
		val.Set("encoding", "json")
		u.RawQuery = val.Encode()
	}
	logger.Debug("URL : %s", u.String())
	resp, err = http.Get(u.String())
	if resp == nil {
		return nil, 0, err
	}
	size = resp.ContentLength
	if resp.StatusCode != 200 {
		return resp, 0, errors.New(resp.Status)
	}
	if err != nil {
		return resp, 0, err
	}
	return resp, size, err
}
Example #19
0
// Parses the querystring (q= parameter) and moves special tokens such as
// "lang:c" from the querystring into separate arguments.
func RewriteQuery(u url.URL) url.URL {
	// query is a copy which we will modify using Set() and use in the result
	query := u.Query()

	querystr := query.Get("q")
	queryWords := []string{}
	for _, word := range strings.Split(querystr, " ") {
		fmt.Printf("word = %v\n", word)
		lower := strings.ToLower(word)
		if strings.HasPrefix(lower, "filetype:") {
			query.Add("filetype", strings.ToLower(word[len("filetype:"):]))
		} else if strings.HasPrefix(lower, "-filetype:") {
			query.Add("nfiletype", strings.ToLower(word[len("-filetype:"):]))
		} else if strings.HasPrefix(lower, "package:") {
			query.Set("package", word[len("package:"):])
		} else if strings.HasPrefix(lower, "pkg:") {
			query.Set("package", word[len("pkg:"):])
		} else if strings.HasPrefix(lower, "-package:") {
			query.Add("npackage", word[len("-package:"):])
		} else if strings.HasPrefix(lower, "-pkg:") {
			query.Add("npackage", word[len("-pkg:"):])
		} else if strings.HasPrefix(lower, "path:") || strings.HasPrefix(lower, "file:") {
			query.Add("path", word[len("path:"):])
		} else if strings.HasPrefix(lower, "-path:") || strings.HasPrefix(lower, "-file:") {
			query.Add("npath", word[len("-path:"):])
		} else {
			queryWords = append(queryWords, word)
		}
	}
	query.Set("q", strings.Join(queryWords, " "))
	u.RawQuery = query.Encode()

	return u
}
Example #20
0
// NewRequest creates a new HTTP request and applies necessary auth headers if
// set.
func (c *Client) NewRequest(params map[string]string, method string, u url.URL, body io.Reader) *http.Request {

	p := url.Values{}

	// Build up our request parameters
	for k, v := range params {
		p.Add(k, v)
	}

	// Add the params to our URL
	u.RawQuery = p.Encode()

	// Build the request, no point in checking for errors here as we're just
	// passing a string version of an url.URL struct and http.NewRequest returns
	// error only if can't process an url.ParseRequestURI().
	req, _ := http.NewRequest(method, u.String(), body)

	if c.VCDAuthHeader != "" && c.VCDToken != "" {
		// Add the authorization header
		req.Header.Add(c.VCDAuthHeader, c.VCDToken)
		// Add the Accept header for VCD
		req.Header.Add("Accept", "application/*+xml;version=5.6")
	}

	return req

}
Example #21
0
func DownloadOneStockPerDay(symbol string, date string) error {
	u := url.URL{Scheme: "http", Host: "market.finance.sina.com.cn", Path: "/downxls.php"}
	q := u.Query()
	q.Set("date", date)
	q.Set("symbol", symbol)
	u.RawQuery = q.Encode()

	log.Println(u.String())

	td := GetStockInOneDay(u.String())
	if len(td) > 0 {

		var ops DBOps
		ops.Init()
		err := ops.Open()
		if err != nil {
			log.Println("open the database failed.")
			log.Fatal(err)
		}
		defer ops.Close()

		ops.CopyDataIntoTable(td)
	} else {
		log.Printf("%s:%s#No DATA\n", symbol, date)
	}

	return nil
}
Example #22
0
File: url.go Project: bfhhq/go-sdk
func BuildSwfPlayUrl(conf *Configure, fileType FileType, videoUrl, swfUrl string, timeOut time.Duration) (string, error) {
	fid := ""
	for _, p := range strings.Split(videoUrl, "&") {
		kv := strings.Split(p, "=")
		if len(kv) == 2 && kv[0] == "fid" {
			fid = kv[1]
			break
		}
	}

	if len(fid) == 0 {
		return "", errors.New("invalid vidoe url, fid not found!")
	}

	if len(swfUrl) == 0 {
		swfUrl = SwfUrl
	}

	playUrl := url.URL{}
	playUrl.Path = swfUrl

	params := url.Values{}
	params.Add("vk", videoUrl)

	if fileType == Private {
		playToken := CreatePlayToken(conf.AccessKey, conf.SecretKey, fid, timeOut)

		params.Add("tk", playToken)
	}

	playUrl.RawQuery = params.Encode()

	return playUrl.String(), nil
}
Example #23
0
func getRepos(URL *url.URL) (map[string]string, error) {
	URL.RawQuery = "format=JSON"
	resp, err := http.Get(URL.String())
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	content, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	const xssTag = ")]}'\n"
	content = bytes.TrimPrefix(content, []byte(xssTag))

	m := map[string]*Project{}
	if err := json.Unmarshal(content, &m); err != nil {
		return nil, err
	}

	result := map[string]string{}
	for k, v := range m {
		result[k] = v.CloneURL
	}
	return result, nil
}
Example #24
0
func removeQueryArgument(u *url.URL, arguments ...string) {
	query := u.Query()
	for _, argument := range arguments {
		query.Del(argument)
	}
	u.RawQuery = query.Encode()
}
Example #25
0
File: web.go Project: jmj/bosun
func Shorten(w http.ResponseWriter, r *http.Request) {
	u := url.URL{
		Scheme: "https",
		Host:   "www.googleapis.com",
		Path:   "/urlshortener/v1/url",
	}
	if schedule.Conf.ShortURLKey != "" {
		u.RawQuery = "key=" + schedule.Conf.ShortURLKey
	}
	j, err := json.Marshal(struct {
		LongURL string `json:"longUrl"`
	}{
		r.Referer(),
	})
	if err != nil {
		serveError(w, err)
		return
	}
	req, err := http.Post(u.String(), "application/json", bytes.NewBuffer(j))
	if err != nil {
		serveError(w, err)
		return
	}
	io.Copy(w, req.Body)
	req.Body.Close()
}
Example #26
0
func (c *chain) match(URL *url.URL) bool {
	path := strings.Split(URL.EscapedPath(), "/")
	lenPath := len(path)
	query := URL.Query()

	if c.lenPattern > lenPath {
		return false
	}

	if c.pattern[c.lenPattern-1] != "*" && c.lenPattern < lenPath {
		return false
	}

	for key, value := range c.pattern {
		if len(value) == 0 {
			if len(path[key]) == 0 {
				continue
			}

			return false
		}

		if value[0] == ':' {
			query.Add(value[1:], path[key])
			continue
		}

		if value[0] != '*' && value != path[key] {
			return false
		}
	}

	URL.RawQuery = query.Encode()
	return true
}
Example #27
0
func (gw2 *GW2Api) fetchEndpoint(ver, tag string, params url.Values, result interface{}) (err error) {
	var endpoint *url.URL
	endpoint, _ = url.Parse("https://api.guildwars2.com")
	endpoint.Path += "/" + ver + "/" + tag
	if params != nil {
		endpoint.RawQuery = params.Encode()
	}

	var resp *http.Response
	if resp, err = gw2.client.Get(endpoint.String()); err != nil {
		return err
	}
	var data []byte
	if data, err = ioutil.ReadAll(resp.Body); err != nil {
		return err
	}
	defer resp.Body.Close()

	if err = json.Unmarshal(data, &result); err != nil {
		var gwerr APIError
		if err = json.Unmarshal(data, &gwerr); err != nil {
			return err
		}
		return fmt.Errorf("Endpoint returned error: %s", gwerr)
	}
	return
}
Example #28
0
// applyToURL merged the filter into a URL.
func (gf *GameFilter) applyToURL(u *url.URL) {
	if gf == nil {
		return
	}

	values := u.Query()

	if len(gf.Name) > 0 {
		values.Set("name", gf.Name)
	}

	if len(gf.Abbreviation) > 0 {
		values.Set("abbreviation", gf.Abbreviation)
	}

	if gf.Released > 0 {
		values.Set("released", strconv.Itoa(gf.Released))
	}

	if len(gf.Platform) > 0 {
		values.Set("platform", gf.Platform)
	}

	if len(gf.Region) > 0 {
		values.Set("region", gf.Region)
	}

	if len(gf.Moderator) > 0 {
		values.Set("moderator", gf.Moderator)
	}

	gf.Romhack.applyToQuery("romhack", &values)

	u.RawQuery = values.Encode()
}
Example #29
0
func Detect_language(q string) string {
	var Url *url.URL
	Url, err := url.Parse("https://www.googleapis.com")
	if err != nil {
		fmt.Println(err)
	}

	Url.Path += "/language/translate/v2/detect"
	parameters := url.Values{}
	parameters.Add("q", q)
	parameters.Add("key", Google_key())
	Url.RawQuery = parameters.Encode()

	resp, err := http.Get(Url.String())
	if err != nil {
		fmt.Println(err)
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)

	var data gtresponse
	json.Unmarshal(body, &data)

	lang := data.Data.Detections[0][0].Language
	return lang
}
Example #30
0
func queryHTTPTracker(infoHashes []string, u *url.URL) (tr []InfoHashDetails, err error) {
	uq := u.Query()
	for _, infoHash := range infoHashes {
		uq.Add("info_hash", infoHash)
	}

	log.Println("HTTP INFO HASH DEBUG REMOVE THIS", uq)

	// Don't report IPv6 address, the user might prefer to keep
	// that information private when communicating with IPv4 hosts.
	if false {
		ipv6Address, err := findLocalIPV6AddressFor(u.Host)
		if err == nil {
			log.Println("our ipv6", ipv6Address)
			uq.Add("ipv6", ipv6Address)
		}
	}

	// This might reorder the existing query string in the Announce url
	// This might break some broken trackers that don't parse URLs properly.

	u.RawQuery = uq.Encode()

	tr, err = getTrackerInfo(u.String())
	if tr == nil || err != nil {
		log.Println("Error: Could not fetch tracker info:", err)
	}
	return
}