136 lines
2.7 KiB
Go
136 lines
2.7 KiB
Go
package common
|
|
|
|
import (
|
|
"encoding/json"
|
|
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
)
|
|
|
|
type ID = primitive.ObjectID
|
|
|
|
// ToJsonM 将struct转换为 Json Map
|
|
func ToJsonM(obj interface{}) (map[string]interface{}, error) {
|
|
j, err := json.Marshal(obj)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
m := make(map[string]interface{})
|
|
if err := json.Unmarshal(j, &m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, err
|
|
}
|
|
|
|
func ToBsonM(s interface{}) (bson.M, error) {
|
|
data, err := bson.Marshal(s)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
m := make(bson.M)
|
|
if err := bson.Unmarshal(data, &m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func MapToJsonString(m map[string]string) (string, error) {
|
|
if data, err := json.Marshal(m); err != nil {
|
|
return "", err
|
|
} else {
|
|
return string(data), nil
|
|
}
|
|
}
|
|
|
|
// MapToStruct s is struct ptr
|
|
func MapToStruct(s interface{}, m map[string]interface{}) error {
|
|
bsonBytes, err := bson.Marshal(m)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return bson.Unmarshal(bsonBytes, s)
|
|
}
|
|
|
|
// JSONStruct2Map 将struct转换为Map
|
|
func JSONStruct2Map(obj interface{}) (map[string]interface{}, error) {
|
|
m := make(map[string]interface{})
|
|
j, err := json.Marshal(obj)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := json.Unmarshal(j, &m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, err
|
|
}
|
|
|
|
// Map2JSONStruct 将map转换为Json struct
|
|
func Map2JSONStruct(v interface{}, m map[string]interface{}) error {
|
|
j, err := json.Marshal(m)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := json.Unmarshal(j, v); err != nil {
|
|
return err
|
|
}
|
|
return err
|
|
}
|
|
|
|
func IDArray(ids []string) ([]ID, error) {
|
|
var idArray []ID
|
|
for _, id := range ids {
|
|
_id, err := primitive.ObjectIDFromHex(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
idArray = append(idArray, _id)
|
|
}
|
|
|
|
return idArray, nil
|
|
}
|
|
|
|
func ObjectIDs2String(obj []primitive.ObjectID) []string {
|
|
arr := []string{}
|
|
if len(obj) == 0 {
|
|
return arr
|
|
}
|
|
for _, o := range obj {
|
|
arr = append(arr, o.Hex())
|
|
}
|
|
return arr
|
|
}
|
|
|
|
func String2ObjectID(obj []string) []primitive.ObjectID {
|
|
arr := []primitive.ObjectID{}
|
|
for _, o := range obj {
|
|
oid, err := primitive.ObjectIDFromHex(o)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
arr = append(arr, oid)
|
|
}
|
|
return arr
|
|
}
|
|
|
|
// PercentOf - calculate what percent [number1] is of [number2].
|
|
// ex. 300 is 12.5% of 2400
|
|
func PercentOf(part int, total int) float64 {
|
|
return (float64(part) * float64(100)) / float64(total)
|
|
}
|
|
|
|
func MergeMap(src, dest map[string]interface{}) map[string]interface{} {
|
|
if len(src) == 0 {
|
|
return dest
|
|
}
|
|
if len(dest) == 0 {
|
|
return src
|
|
}
|
|
if len(src) == 0 && len(dest) == 0 {
|
|
return make(map[string]interface{})
|
|
}
|
|
for k, v := range dest {
|
|
src[k] = v
|
|
}
|
|
return src
|
|
}
|