forked from rancher/norman
-
Notifications
You must be signed in to change notification settings - Fork 0
/
convert.go
150 lines (130 loc) · 2.73 KB
/
convert.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package convert
import (
"encoding/json"
"errors"
"fmt"
"strconv"
"strings"
"time"
"unicode"
)
func Singular(value interface{}) interface{} {
if slice, ok := value.([]string); ok {
if len(slice) == 0 {
return nil
}
return slice[0]
}
if slice, ok := value.([]interface{}); ok {
if len(slice) == 0 {
return nil
}
return slice[0]
}
return value
}
func ToString(value interface{}) string {
single := Singular(value)
if single == nil {
return ""
}
return fmt.Sprint(single)
}
func ToTimestamp(value interface{}) (int64, error) {
str := ToString(value)
if str == "" {
return 0, errors.New("Invalid date")
}
t, err := time.Parse(time.RFC3339, str)
if err != nil {
return 0, err
}
return t.UnixNano() / 1000000, nil
}
func ToBool(value interface{}) bool {
value = Singular(value)
b, ok := value.(bool)
if ok {
return b
}
str := strings.ToLower(ToString(value))
return str == "true" || str == "t" || str == "yes" || str == "y"
}
func ToNumber(value interface{}) (int64, error) {
value = Singular(value)
i, ok := value.(int64)
if ok {
return i, nil
}
return strconv.ParseInt(ToString(value), 10, 64)
}
func Capitalize(s string) string {
if len(s) <= 1 {
return strings.ToUpper(s)
}
return strings.ToUpper(s[:1]) + s[1:]
}
func LowerTitle(input string) string {
runes := []rune(input)
for i := 0; i < len(runes); i++ {
if unicode.IsUpper(runes[i]) &&
(i == 0 ||
i == len(runes)-1 ||
unicode.IsUpper(runes[i+1])) {
runes[i] = unicode.ToLower(runes[i])
} else {
break
}
}
return string(runes)
}
func IsEmpty(v interface{}) bool {
return v == nil || v == "" || v == 0 || v == false
}
func ToMapInterface(obj interface{}) map[string]interface{} {
v, _ := obj.(map[string]interface{})
return v
}
func ToMapSlice(obj interface{}) []map[string]interface{} {
if v, ok := obj.([]map[string]interface{}); ok {
return v
}
vs, _ := obj.([]interface{})
result := []map[string]interface{}{}
for _, item := range vs {
if v, ok := item.(map[string]interface{}); ok {
result = append(result, v)
} else {
return nil
}
}
return result
}
func ToStringSlice(data interface{}) []string {
if v, ok := data.([]string); ok {
return v
}
if v, ok := data.([]interface{}); ok {
result := []string{}
for _, item := range v {
result = append(result, ToString(item))
}
return result
}
return nil
}
func ToObj(data interface{}, into interface{}) error {
bytes, err := json.Marshal(data)
if err != nil {
return err
}
return json.Unmarshal(bytes, into)
}
func EncodeToMap(obj interface{}) (map[string]interface{}, error) {
bytes, err := json.Marshal(obj)
if err != nil {
return nil, err
}
result := map[string]interface{}{}
return result, json.Unmarshal(bytes, result)
}