query/query.go

// Copyright 2019 The Tango Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package query

import (
	"fmt"
	"html/template"
	"net/http"
	"net/url"
	"strconv"
)

// ErrorKeyIsNotExist represents an error with no key exist
type ErrorKeyIsNotExist struct {
	Key string
}

func (e ErrorKeyIsNotExist) Error() string {
	return fmt.Sprintf("Key %s is not exist", e.Key)
}

// Queries a new enhancement of http.Request
type Queries url.Values

// GetQuery returns queries
func GetQuery(req *http.Request) Queries {
	return Queries(req.URL.Query())
}

// Values returns http.Request values
func (f Queries) Values() url.Values {
	return url.Values(f)
}

// String returns request form as string
func (f Queries) String(key string) (string, error) {
	if v, ok := f.Values()[key]; ok {
		return v[0], nil
	}
	return "", ErrorKeyIsNotExist{key}
}

// Strings returns request form as strings
func (f Queries) Strings(key string) ([]string, error) {
	if v, ok := f.Values()[key]; ok {
		return v, nil
	}
	return nil, ErrorKeyIsNotExist{key}
}

// Escape returns request form as escaped string
func (f Queries) Escape(key string) (string, error) {
	s, err := f.String(key)
	if err != nil {
		return "", err
	}
	return template.HTMLEscapeString(s), nil
}

// Int returns request form as int
func (f Queries) Int(key string) (int, error) {
	s, err := f.String(key)
	if err != nil {
		return 0, err
	}
	return strconv.Atoi(s)
}

// Int32 returns request form as int32
func (f Queries) Int32(key string) (int32, error) {
	s, err := f.String(key)
	if err != nil {
		return 0, err
	}
	v, err := strconv.ParseInt(s, 10, 32)
	return int32(v), err
}

// Int64 returns request form as int64
func (f Queries) Int64(key string) (int64, error) {
	s, err := f.String(key)
	if err != nil {
		return 0, err
	}
	v, err := strconv.ParseInt(s, 10, 64)
	return v, err
}

// Uint returns request form as uint
func (f Queries) Uint(key string) (uint, error) {
	s, err := f.String(key)
	if err != nil {
		return 0, err
	}
	v, err := strconv.ParseUint(s, 10, 64)
	return uint(v), err
}

// Uint32 returns request form as uint32
func (f Queries) Uint32(key string) (uint32, error) {
	s, err := f.String(key)
	if err != nil {
		return 0, err
	}
	v, err := strconv.ParseUint(s, 10, 32)
	return uint32(v), err
}

// Uint64 returns request form as uint64
func (f Queries) Uint64(key string) (uint64, error) {
	s, err := f.String(key)
	if err != nil {
		return 0, err
	}
	return strconv.ParseUint(s, 10, 64)
}

// Bool returns request form as bool
func (f Queries) Bool(key string) (bool, error) {
	s, err := f.String(key)
	if err != nil {
		return false, err
	}
	return strconv.ParseBool(s)
}

// Float32 returns request form as float32
func (f Queries) Float32(key string) (float32, error) {
	s, err := f.String(key)
	if err != nil {
		return 0, err
	}
	v, err := strconv.ParseFloat(s, 64)
	return float32(v), err
}

// Float64 returns request form as float64
func (f Queries) Float64(key string) (float64, error) {
	s, err := f.String(key)
	if err != nil {
		return 0, err
	}
	return strconv.ParseFloat(s, 64)
}

// MustString returns request form as string with default
func (f Queries) MustString(key string, defaults ...string) string {
	if v, ok := f.Values()[key]; ok {
		return v[0]
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return ""
}

// MustStrings returns request form as strings with default
func (f Queries) MustStrings(key string, defaults ...[]string) []string {
	if v, ok := f.Values()[key]; ok {
		return v
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return []string{}
}

// MustEscape returns request form as escaped string with default
func (f Queries) MustEscape(key string, defaults ...string) string {
	if v, ok := f.Values()[key]; ok {
		return template.HTMLEscapeString(v[0])
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return ""
}

// MustInt returns request form as int with default
func (f Queries) MustInt(key string, defaults ...int) int {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.Atoi(v[0])
		if err == nil {
			return i
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}

// MustInt32 returns request form as int32 with default
func (f Queries) MustInt32(key string, defaults ...int32) int32 {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseInt(v[0], 10, 32)
		if err == nil {
			return int32(i)
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}

// MustInt64 returns request form as int64 with default
func (f Queries) MustInt64(key string, defaults ...int64) int64 {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseInt(v[0], 10, 64)
		if err == nil {
			return i
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}

// MustUint returns request form as uint with default
func (f Queries) MustUint(key string, defaults ...uint) uint {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseUint(v[0], 10, 64)
		if err == nil {
			return uint(i)
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}

// MustUint32 returns request form as uint32 with default
func (f Queries) MustUint32(key string, defaults ...uint32) uint32 {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseUint(v[0], 10, 32)
		if err == nil {
			return uint32(i)
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}

// MustUint64 returns request form as uint64 with default
func (f Queries) MustUint64(key string, defaults ...uint64) uint64 {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseUint(v[0], 10, 64)
		if err == nil {
			return i
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}

// MustFloat32 returns request form as float32 with default
func (f Queries) MustFloat32(key string, defaults ...float32) float32 {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseFloat(v[0], 32)
		if err == nil {
			return float32(i)
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}

// MustFloat64 returns request form as float64 with default
func (f Queries) MustFloat64(key string, defaults ...float64) float64 {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseFloat(v[0], 64)
		if err == nil {
			return i
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}

// MustBool returns request form as bool with default
func (f Queries) MustBool(key string, defaults ...bool) bool {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseBool(v[0])
		if err == nil {
			return i
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return false
}