Golang query.Values函数代码示例

func constructQueryString(data interface{}) (string, error) {
	v, err := query.Values(data)
	if err != nil {
		return "", nil
	}
	return v.Encode(), nil
}

func (a *Adaptor) EditUserProfile(userProfile *client.UserProfile) (bool, *adaptor.AdaptorError) {
	var editSuccess int

	params, queryErr := query.Values(userProfile)

	if queryErr != nil {
		ln.Err("error query user profile", ln.Map{"err": queryErr.Error()})
		return false, adaptor.NewError("error query user profile")
	}

	err := a.apidClient.DoFunction("editUserProfile", params, &editSuccess)

	if err != nil {
		ln.Err("error updating user profile", ln.Map{"err": err.Error(), "user_profile": userProfile})
		return false, adaptor.NewError("error updating user profile")
	}

	if editSuccess == 0 {
		// check if the user exists
		user, adaptorError := a.GetUserProfile(userProfile.UserID)

		if adaptorError != nil {
			ln.Err("error when getting user profile", ln.Map{"err": adaptorError.Error(), "user_id": userProfile.UserID})
			return false, adaptor.NewError("error when getting user profile")
		}
		if user == nil {
			return false, adaptor.NewErrorWithStatus("user profile not found", http.StatusNotFound)
		}
		// no fields were changed
		return true, nil
	}

	return true, nil
}

func TestEncodeDecodeQuery(t *testing.T) {

	const expected = "entities=c%2F1&entities=c%2F2&origin=mysystem"

	q := Query{}
	q.Origin = "mysystem"
	q.Entities = []string{"c/1", "c/2"}

	v, err := query.Values(q)

	if err != nil {
		t.Fatal(err)
	}

	t.Log(v.Encode())

	if v.Encode() != expected {
		t.Fatalf("Expected %s, got %s", expected, v.Encode())
	}

	q2 := new(Query)
	decoder := schema.NewDecoder()
	err = decoder.Decode(q2, v)

	if err != nil {
		t.Fatal(err)
	}

	if q.Origin != q2.Origin {
		t.Fatalf("Expected %s, got %s", q.Origin, q2.Origin)
	}
}

func (r *Request) GetRequestURI() (*url.URL, error) {
	queryParams, err := query.Values(r)
	if err != nil {
		return nil, err
	}
	return url.ParseRequestURI(fmt.Sprintf("%s?%s", APIURL, queryParams.Encode()))
}

func (cli *OpsGenieAlertClient) List(req alerts.ListAlertsRequest) (*alerts.ListAlertsResponse, error) {
	req.ApiKey = cli.apiKey
	// validate the mandatory parameter: apiKey
	if req.ApiKey == "" {
		return nil, errors.New("ApiKey is a mandatory field and can not be empty.")
	}
	v, _ := goquery.Values(req)
	var resp *goreq.Response
	var err error
	for i := 0; i < cli.retries; i++ {
		resp, err = cli.buildRequest("GET", LIST_ALERTS_URL+"?"+v.Encode(), nil).Do()
		if err == nil {
			break
		}
		time.Sleep(TIME_SLEEP_BETWEEN_REQUESTS)
	}
	if err != nil {
		return nil, errors.New("Could not retrieve the alert: a problem occured while sending the request")
	}
	// check the returning HTTP status code
	httpStatusCode := resp.StatusCode
	if httpStatusCode >= 400 && httpStatusCode < 500 {
		return nil, errors.New(fmt.Sprintf("Client error %d returned", httpStatusCode))
	}
	if httpStatusCode >= 500 {
		return nil, errors.New(fmt.Sprintf("Server error %d returned", httpStatusCode))
	}
	var listAlertsResp alerts.ListAlertsResponse
	// check if the response can be unmarshalled
	if err = resp.Body.FromJsonTo(&listAlertsResp); err != nil {
		return nil, errors.New("Server response can not be parsed.")
	}
	return &listAlertsResp, nil
}

// addOptions adds the parameters in opt as URL query parameters to s.  opt
// must be a struct whose fields may contain "url" tags.
func addRouteOptions(route string, options interface{}) (*url.URL, error) {
	Debug(DbgInfo, "Adding options %+v to route '%s'\n", options, route)
	u, err := url.Parse(route)
	if err != nil {
		Debug(DbgError, "url.Parse(%s) error: %s\n", route, err)
		errStr := wski18n.T("Unable to parse URL '{{.route}}': {{.err}}",
			map[string]interface{}{"route": route, "err": err})
		werr := MakeWskError(errors.New(errStr), EXITCODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
		return nil, werr
	}

	v := reflect.ValueOf(options)
	if v.Kind() == reflect.Ptr && v.IsNil() {
		return u, nil
	}

	qs, err := query.Values(options)
	if err != nil {
		Debug(DbgError, "query.Values(%#v) error: %s\n", options, err)
		errStr := wski18n.T("Unable to process URL query options '{{.options}}': {{.err}}",
			map[string]interface{}{"options": fmt.Sprintf("%#v", options), "err": err})
		werr := MakeWskError(errors.New(errStr), EXITCODE_ERR_GENERAL, DISPLAY_MSG, NO_DISPLAY_USAGE)
		return nil, werr
	}

	u.RawQuery = qs.Encode()
	Debug(DbgInfo, "Returning route options '%s' from input struct %+v\n", u.String(), options)
	return u, nil
}

func (it *Iter) getPage() error {
	form, err := query.Values(it.params)
	if err != nil {
		return err
	}

	var listRes listResponse

	_, err = it.client.execute(it.route, it.vars, &form, &listRes)
	if err != nil {
		return err
	}

	it.hasMore = listRes.HasMore
	if it.params.After != "" {
		it.params.After = listRes.Cursor
	} else {
		it.params.Before = listRes.Cursor
	}

	// Create a pointer to a slice value and set it to the slice
	// MakeSlice allocates a value on the stack that is not addressable
	dataPtr := reflect.New(it.valuesType)
	dataPtr.Elem().Set(reflect.MakeSlice(it.valuesType, 0, 0))

	if err := json.Unmarshal(listRes.Data, dataPtr.Interface()); err != nil {
		return err
	}
	it.values = dataPtr.Elem()

	return nil
}

func (repo CloudControllerRouteRepository) Find(host string, domain models.DomainFields, path string, port int) (models.Route, error) {
	var route models.Route
	queryString := queryStringForRouteSearch(host, domain.GUID, path, port)

	q := struct {
		Query                string `url:"q"`
		InlineRelationsDepth int    `url:"inline-relations-depth"`
	}{queryString, 1}

	opt, _ := query.Values(q)

	found := false
	apiErr := repo.gateway.ListPaginatedResources(
		repo.config.APIEndpoint(),
		fmt.Sprintf("/v2/routes?%s", opt.Encode()),
		resources.RouteResource{},
		func(resource interface{}) bool {
			keepSearching := true
			route = resource.(resources.RouteResource).ToModel()
			if doesNotMatchVersionSpecificAttributes(route, path, port) {
				return keepSearching
			}

			found = true
			return !keepSearching
		})

	if apiErr == nil && !found {
		apiErr = errors.NewModelNotFoundError("Route", host)
	}

	return route, apiErr
}

func addOptions(s string, opt interface{}) (string, error) {
	v := reflect.ValueOf(opt)

	if v.Kind() == reflect.Ptr && v.IsNil() {
		return s, nil
	}

	origURL, err := url.Parse(s)
	if err != nil {
		return s, err
	}

	origValues := origURL.Query()

	newValues, err := query.Values(opt)
	if err != nil {
		return s, err
	}

	for k, v := range newValues {
		origValues[k] = v
	}

	origURL.RawQuery = origValues.Encode()
	return origURL.String(), nil
}

func (c *Client) resource(path string, params interface{}) url.URL {
	bp := map[string][]string{
		"v": []string{CLIENT_VERSION},
	}
	if len(c.accessToken) > 0 {
		bp["oauth_token"] = []string{c.accessToken}
	} else {
		bp["client_id"] = []string{c.clientId}
		bp["client_secret"] = []string{c.clientSecret}
	}

	// TODO(dolapo): location params..

	u := url.URL{
		Scheme:   "https",
		Host:     BASE_API_URL,
		Path:     "/v2/" + path,
		RawQuery: url.Values(bp).Encode(),
	}

	if params != nil {
		q, _ := query.Values(params)
		u.RawQuery += "&" + q.Encode()
	}

	return u
}

func (r *RedditClient) Submit(kind, title, text, subreddit string) {
	log.Print(`Submitting...`)

	bodyContent := SubmitRequest{
		Kind:     kind,
		Title:    title,
		Text:     text,
		SR:       subreddit,
		Resubmit: true,
	}

	v, _ := query.Values(bodyContent)
	bodyBuffer := bytes.NewBufferString(v.Encode())

	request, err := http.NewRequest("POST", "https://oauth.reddit.com/api/submit", bodyBuffer)
	if err != nil {
		log.Fatal(err)
	}
	request.Header.Set(`Content-type`, `application/x-www-form-urlencoded`)
	log.Print(request)

	response, err := r.DoAuthorized(request)
	if err != nil {
		log.Fatal(err)
	}
	log.Print(response)

	defer response.Body.Close()
	bodyBytes, _ := ioutil.ReadAll(response.Body)
	log.Print(string(bodyBytes))
}

// Events retrieves events for the currently authenticated user.
//
// See: https://developers.box.com/docs/#events-get-events-for-a-user
func (e *EventService) Events(options EventQueryOptions) (*http.Response, *EventCollection, error) {
	queryString, err := query.Values(options)
	if err != nil {
		return nil, nil, err
	}

	req, err := e.NewRequest(
		"GET",
		"/events?"+queryString.Encode(),
		nil,
	)
	if err != nil {
		return nil, nil, err
	}
	var data EventCollection
	resp, err := e.Do(req, &data)
	if err != nil {
		return resp, nil, err
	}
	for _, eve := range data.Entries {
		if eve.Source == nil {
			continue
		}
		if err = finishParsing(eve); err != nil {
			return resp, nil, err
		}
	}
	return resp, &data, err
}

// NewRequest creates an API request. A relative URL path can be provided in
// urlStr, in which case it is resolved relative to the base URL of the Client.
// Relative URL paths should always be specified without a preceding slash. If
// specified, the value pointed to by body is JSON encoded and included as the
// request body.
func (c *Client) NewRequest(method, path string, opt interface{}) (*http.Request, error) {
	u := *c.baseURL
	// Set the encoded opaque data
	u.Opaque = c.baseURL.Path + path

	q, err := query.Values(opt)
	if err != nil {
		return nil, err
	}
	u.RawQuery = q.Encode()

	req := &http.Request{
		Method:     method,
		URL:        &u,
		Proto:      "HTTP/1.1",
		ProtoMajor: 1,
		ProtoMinor: 1,
		Header:     make(http.Header),
		Host:       u.Host,
	}

	req.Header.Set("Accept", "application/json")
	req.Header.Set("PRIVATE-TOKEN", c.token)
	if c.UserAgent != "" {
		req.Header.Set("User-Agent", c.UserAgent)
	}

	return req, nil
}

// encodeBodyForm url encodes the value pointed to by bodyForm into an
// io.Reader, typically for use as a Request Body.
func encodeBodyForm(bodyForm interface{}) (io.Reader, error) {
	values, err := goquery.Values(bodyForm)
	if err != nil {
		return nil, err
	}
	return strings.NewReader(values.Encode()), nil
}

// Convert an interface{} to a urlencoded querystring
func ToQueryString(q interface{}) (string, error) {
	v, err := query.Values(q)
	if err != nil {
		return "", err
	}
	return v.Encode(), nil
}