lib/types/data.go

package types

import (
	"encoding/json"
	"errors"
)

// 錯誤訊息
var (
	ErrExistKey = errors.New("not exist")
	ErrFormat   = errors.New("error format")
)

// Data 資料
type Data map[string]interface{}

// Get 取得資料
func (data Data) Get(key string) (interface{}, error) {
	value, exist := data[key]
	if !exist {
		return "", ErrExistKey
	}

	return value, nil
}

// GetSlice 取得切片
func (data Data) GetSlice(key string) (res Slice, err error) {
	value, err := data.Get(key)
	if err != nil {
		return nil, err
	}

	switch value := value.(type) {
	case []interface{}:
		return value, nil
	case Slice:
		return value, nil
	default:
		return nil, ErrFormat
	}
}

// MustGetSlice 強制取得切片
func (data Data) MustGetSlice(key string) Slice {
	values, _ := data.GetSlice(key)
	return values
}

// GetString 取得字串
func (data Data) GetString(key string) (string, error) {
	value, err := data.Get(key)
	if err != nil {
		return "", err
	}

	switch value := value.(type) {
	case []byte:
		return string(value), nil
	case string:
		return value, nil
	default:
		return "", ErrFormat
	}
}

// MustGetString 強制取得字串
func (data Data) MustGetString(key string) string {
	value, _ := data.GetString(key)
	return value
}

// GetStringSlice 取得字串切片
func (data Data) GetStringSlice(key string) (res []string, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case string:
			res = append(res, v)
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetStringSlice 強制取得字串切片
func (data Data) MustGetStringSlice(key string) []string {
	values, _ := data.GetStringSlice(key)
	return values
}

// GetBytes 取得字串
func (data Data) GetBytes(key string) ([]byte, error) {
	value, err := data.Get(key)
	if err != nil {
		return nil, err
	}

	switch value := value.(type) {
	case []byte:
		return value, nil
	case string:
		return []byte(value), nil
	default:
		return nil, ErrFormat
	}
}

// MustGetBytes 強制取得字串
func (data Data) MustGetBytes(key string) []byte {
	value, _ := data.GetBytes(key)
	return value
}

// GetData 取得資料
func (data Data) GetData(key string) (Data, error) {
	value, err := data.Get(key)
	if err != nil {
		return nil, err
	}

	switch value := value.(type) {
	case map[string]interface{}:
		return Data(value), nil
	case Data:
		return value, nil
	default:
		return nil, ErrFormat
	}
}

// MustGetData 強制取得資料
func (data Data) MustGetData(key string) Data {
	value, _ := data.GetData(key)
	return value
}

// GetDataSlice 取得資料切片
func (data Data) GetDataSlice(key string) ([]Data, error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	var list []Data
	for _, v := range values {
		switch v := v.(type) {
		case Data:
			list = append(list, v)
		default:
			return nil, ErrFormat
		}
	}

	return list, nil
}

// MustGetDataSlice 強制取得資料切片
func (data Data) MustGetDataSlice(key string) []Data {
	values, _ := data.GetDataSlice(key)
	return values
}

// GetFloat64 取得64位元浮點數
func (data Data) GetFloat64(key string) (float64, error) {
	value, err := data.Get(key)
	if err != nil {
		return 0, err
	}

	switch value := value.(type) {
	case float32:
		return float64(value), nil
	case float64:
		return value, nil
	default:
		return 0, ErrFormat
	}
}

// MustGetFloat64 強制取得64位元浮點數
func (data Data) MustGetFloat64(key string) float64 {
	value, _ := data.GetFloat64(key)
	return value
}

// GetFloat64Slice 取得64位元浮點數切片
func (data Data) GetFloat64Slice(key string) (res []float64, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case int:
			res = append(res, float64(v))
		case uint:
			res = append(res, float64(v))
		case int8:
			res = append(res, float64(v))
		case uint8:
			res = append(res, float64(v))
		case int16:
			res = append(res, float64(v))
		case uint16:
			res = append(res, float64(v))
		case int32:
			res = append(res, float64(v))
		case uint32:
			res = append(res, float64(v))
		case int64:
			res = append(res, float64(v))
		case uint64:
			res = append(res, float64(v))
		case float32:
			res = append(res, float64(v))
		case float64:
			res = append(res, v)
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetFloat64Slice 強制取得64位元浮點數切片
func (data Data) MustGetFloat64Slice(key string) []float64 {
	values, _ := data.GetFloat64Slice(key)
	return values
}

// GetInt64 取得64位元整數
func (data Data) GetInt64(key string) (int64, error) {
	value, err := data.Get(key)
	if err != nil {
		return 0, err
	}

	switch value := value.(type) {
	case int:
		return int64(value), nil
	case uint:
		return int64(value), nil
	case int8:
		return int64(value), nil
	case uint8:
		return int64(value), nil
	case int16:
		return int64(value), nil
	case uint16:
		return int64(value), nil
	case int32:
		return int64(value), nil
	case uint32:
		return int64(value), nil
	case int64:
		return value, nil
	case float64:
		return int64(value), nil
	default:
		return 0, ErrFormat
	}
}

// MustGetInt64 強制取得64位元整數
func (data Data) MustGetInt64(key string) int64 {
	value, _ := data.GetInt64(key)
	return value
}

// GetInt64Slice 取得64位元整數切片
func (data Data) GetInt64Slice(key string) (res []int64, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case int:
			res = append(res, int64(v))
		case uint:
			res = append(res, int64(v))
		case int8:
			res = append(res, int64(v))
		case uint8:
			res = append(res, int64(v))
		case int16:
			res = append(res, int64(v))
		case uint16:
			res = append(res, int64(v))
		case int32:
			res = append(res, int64(v))
		case uint32:
			res = append(res, int64(v))
		case int64:
			res = append(res, v)
		case uint64:
			res = append(res, int64(v))
		case float32:
			res = append(res, int64(v))
		case float64:
			res = append(res, int64(v))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetInt64Slice 強制取得64位元整數切片
func (data Data) MustGetInt64Slice(key string) []int64 {
	values, _ := data.GetInt64Slice(key)
	return values
}

// GetUint64 取得64位元正整數
func (data Data) GetUint64(key string) (uint64, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	if value < 0 {
		return 0, ErrFormat
	}

	return uint64(value), nil
}

// MustGetUint64 強制取得64位元正整數
func (data Data) MustGetUint64(key string) uint64 {
	value, _ := data.GetUint64(key)
	return value
}

// GetUint64Slice 取得64位元正整數切片
func (data Data) GetUint64Slice(key string) (res []uint64, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case int:
			res = append(res, uint64(v))
		case uint:
			res = append(res, uint64(v))
		case int8:
			res = append(res, uint64(v))
		case uint8:
			res = append(res, uint64(v))
		case int16:
			res = append(res, uint64(v))
		case uint16:
			res = append(res, uint64(v))
		case int32:
			res = append(res, uint64(v))
		case uint32:
			res = append(res, uint64(v))
		case int64:
			res = append(res, uint64(v))
		case uint64:
			res = append(res, v)
		case float32:
			res = append(res, uint64(v))
		case float64:
			res = append(res, uint64(v))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetUint64Slice 強制取得64位元正整數切片
func (data Data) MustGetUint64Slice(key string) []uint64 {
	values, _ := data.GetUint64Slice(key)
	return values
}

// GetInt 取得整數
func (data Data) GetInt(key string) (int, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return int(value), nil
}

// MustGetInt 強制取得整數
func (data Data) MustGetInt(key string) int {
	value, _ := data.GetInt(key)
	return value
}

// GetIntSlice 取得整數切片
func (data Data) GetIntSlice(key string) (res []int, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case int:
			res = append(res, v)
		case uint:
			res = append(res, int(v))
		case int8:
			res = append(res, int(v))
		case uint8:
			res = append(res, int(v))
		case int16:
			res = append(res, int(v))
		case uint16:
			res = append(res, int(v))
		case int32:
			res = append(res, int(v))
		case uint32:
			res = append(res, int(v))
		case int64:
			res = append(res, int(v))
		case uint64:
			res = append(res, int(v))
		case float32:
			res = append(res, int(v))
		case float64:
			res = append(res, int(v))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetIntSlice 強制取得整數切片
func (data Data) MustGetIntSlice(key string) []int {
	values, _ := data.GetIntSlice(key)
	return values
}

// GetUint 取得正整數
func (data Data) GetUint(key string) (uint, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	if value < 0 {
		return 0, ErrFormat
	}

	return uint(value), nil
}

// MustGetUint 強制取得正整數
func (data Data) MustGetUint(key string) uint {
	value, _ := data.GetUint(key)
	return value
}

// GetUintSlice 取得正整數切片
func (data Data) GetUintSlice(key string) (res []uint, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case int:
			res = append(res, uint(v))
		case uint:
			res = append(res, v)
		case int8:
			res = append(res, uint(v))
		case uint8:
			res = append(res, uint(v))
		case int16:
			res = append(res, uint(v))
		case uint16:
			res = append(res, uint(v))
		case int32:
			res = append(res, uint(v))
		case uint32:
			res = append(res, uint(v))
		case int64:
			res = append(res, uint(v))
		case uint64:
			res = append(res, uint(v))
		case float32:
			res = append(res, uint(v))
		case float64:
			res = append(res, uint(v))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetUintSlice 強制取得正整數切片
func (data Data) MustGetUintSlice(key string) []uint {
	values, _ := data.GetUintSlice(key)
	return values
}

// GetInt16 取得16位元整數
func (data Data) GetInt16(key string) (int16, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return int16(value), nil
}

// MustGetInt16 強制取得16位元整數
func (data Data) MustGetInt16(key string) uint16 {
	value, _ := data.GetUint16(key)
	return value
}

// GetInt16Slice 取得16位元整數切片
func (data Data) GetInt16Slice(key string) (res []int16, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case int:
			res = append(res, int16(v))
		case uint:
			res = append(res, int16(v))
		case int8:
			res = append(res, int16(v))
		case uint8:
			res = append(res, int16(v))
		case int16:
			res = append(res, v)
		case uint16:
			res = append(res, int16(v))
		case int32:
			res = append(res, int16(v))
		case uint32:
			res = append(res, int16(v))
		case int64:
			res = append(res, int16(v))
		case uint64:
			res = append(res, int16(v))
		case float32:
			res = append(res, int16(v))
		case float64:
			res = append(res, int16(v))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetInt16Slice 強制取得16位元整數切片
func (data Data) MustGetInt16Slice(key string) []int16 {
	values, _ := data.GetInt16Slice(key)
	return values
}

// GetUint16 取得16位元正整數
func (data Data) GetUint16(key string) (uint16, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	if value < 0 {
		return 0, ErrFormat
	}

	return uint16(value), nil
}

// MustGetUint16 強制取得16位元正整數
func (data Data) MustGetUint16(key string) uint16 {
	value, _ := data.GetUint16(key)
	return value
}

// GetUint16Slice 取得16位元正整數切片
func (data Data) GetUint16Slice(key string) (res []uint16, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case int:
			res = append(res, uint16(v))
		case uint:
			res = append(res, uint16(v))
		case int8:
			res = append(res, uint16(v))
		case uint8:
			res = append(res, uint16(v))
		case int16:
			res = append(res, uint16(v))
		case uint16:
			res = append(res, v)
		case int32:
			res = append(res, uint16(v))
		case uint32:
			res = append(res, uint16(v))
		case int64:
			res = append(res, uint16(v))
		case uint64:
			res = append(res, uint16(v))
		case float32:
			res = append(res, uint16(v))
		case float64:
			res = append(res, uint16(v))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetUint16Slice 強制取得16位元正整數切片
func (data Data) MustGetUint16Slice(key string) []uint16 {
	values, _ := data.GetUint16Slice(key)
	return values
}

// GetInt8 取得8位元整數
func (data Data) GetInt8(key string) (int8, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return int8(value), nil
}

// MustGetInt8 強制取得8位元整數
func (data Data) MustGetInt8(key string) int8 {
	value, _ := data.GetInt8(key)
	return value
}

// GetInt8Slice 取得8位元整數切片
func (data Data) GetInt8Slice(key string) (res []int8, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case int:
			res = append(res, int8(v))
		case uint:
			res = append(res, int8(v))
		case int8:
			res = append(res, v)
		case uint8:
			res = append(res, int8(v))
		case int16:
			res = append(res, int8(v))
		case uint16:
			res = append(res, int8(v))
		case int32:
			res = append(res, int8(v))
		case uint32:
			res = append(res, int8(v))
		case int64:
			res = append(res, int8(v))
		case uint64:
			res = append(res, int8(v))
		case float32:
			res = append(res, int8(v))
		case float64:
			res = append(res, int8(v))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetInt8Slice 強制取得8位元整數切片
func (data Data) MustGetInt8Slice(key string) []int8 {
	values, _ := data.GetInt8Slice(key)
	return values
}

// GetUint8 取得8位元正整數
func (data Data) GetUint8(key string) (uint8, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	if value < 0 {
		return 0, ErrFormat
	}

	return uint8(value), nil
}

// MustGetUint8 強制取得8位元正整數
func (data Data) MustGetUint8(key string) uint8 {
	value, _ := data.GetUint8(key)
	return value
}

// GetUint8Slice 取得8位元正整數切片
func (data Data) GetUint8Slice(key string) (res []uint8, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v := v.(type) {
		case int:
			res = append(res, uint8(v))
		case uint:
			res = append(res, uint8(v))
		case int8:
			res = append(res, uint8(v))
		case uint8:
			res = append(res, v)
		case int16:
			res = append(res, uint8(v))
		case uint16:
			res = append(res, uint8(v))
		case int32:
			res = append(res, uint8(v))
		case uint32:
			res = append(res, uint8(v))
		case int64:
			res = append(res, uint8(v))
		case uint64:
			res = append(res, uint8(v))
		case float32:
			res = append(res, uint8(v))
		case float64:
			res = append(res, uint8(v))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

// MustGetUint8Slice 強制取得8位元正整數切片
func (data Data) MustGetUint8Slice(key string) []uint8 {
	values, _ := data.GetUint8Slice(key)
	return values
}

// GetBool 取得布林值
func (data Data) GetBool(key string) (bool, error) {
	value, err := data.Get(key)
	if err != nil {
		return false, err
	}

	switch value := value.(type) {
	case uint8:
		return value > 0, nil
	case int64:
		return value > 0, nil
	case float64:
		return value > 0, nil
	case bool:
		return value, nil
	}

	return false, ErrFormat
}

// MustGetBool 強制取得布林值
func (data Data) MustGetBool(key string) bool {
	value, _ := data.GetBool(key)
	return value
}

// GetTimestamp 取得時間戳記
func (data Data) GetTimestamp(key string) (Timestamp, error) {
	value, err := data.Get(key)
	if err != nil {
		return 0, err
	}

	switch value := value.(type) {
	case int:
		return Timestamp(value), nil
	case uint:
		return Timestamp(value), nil
	case int64:
		return Timestamp(value), nil
	case uint64:
		return Timestamp(value), nil
	case float64:
		return Timestamp(value), nil

	case Timestamp:
		return value, nil
	}

	return 0, ErrFormat
}

// MustGetTimestamp 強制取得時間戳記
func (data Data) MustGetTimestamp(key string) Timestamp {
	value, _ := data.GetTimestamp(key)
	return value
}

// JSON 取得json
func (data Data) JSON() ([]byte, error) {
	bs, err := json.Marshal(&data)
	if err != nil {
		return nil, err
	}

	return bs, nil
}

// MustJSON 強制取得json
func (data Data) MustJSON() []byte {
	bs, _ := data.JSON()
	return bs
}

// GetPage 取得頁數
func (data Data) GetPage(key string) (*Page, error) {
	value, err := data.Get(key)
	if err != nil {
		return nil, err
	}

	switch value := value.(type) {
	case Page:
		return &value, nil
	}

	return nil, ErrFormat
}

// MustGetPage 強制取得頁數
func (data Data) MustGetPage(key string) *Page {
	value, _ := data.GetPage(key)

	return value
}