messageCenter/entity/util.go

package entity

import (
	"encoding/json"
	"fmt"
	"reflect"
	"sort"
	"strings"

	quitl "app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/redis"
)

const (
	Date_Full_Layout = "2006-01-02 15:04:05"
	//baseMysql
	SOCIALIZE_CHAT_SESSION      = "socialize_chat_session"
	SOCIALIZE_MESSAGE           = "socialize_message"
	SOCIALIZE_MESSAGE_MAILBOX   = "socialize_message_mailbox"
	SOCIALIZE_TENANT_ROBOT      = "socialize_tenant_robot"
	BASE_USER                   = "base_user"
	SOCIALIZE_CHAT_GROUP        = "socialize_chat_group"
	SOCIALIZE_CHAT_GROUP_NOTICE = "socialize_chat_group_notice"
	SOCIALIZE_CHAT_GROUP_PERSON = "socialize_chat_group_person"
	BASE_POSITION               = "base_position"
	User_message_list           = "user_message_list"
	//mainMysql
	ENTNICHE_USER = "entniche_user"
	//mongo
	ENTNICHE_DELETE    = "entniche_delete"
	SOCIALIZE_APPRAISE = "socialize_message_appraise"
	SOCIALIZE_SUMMARY  = "socialize_summary"
)
const (
	SUCCESS_CODE = int64(0)
	ERROR_CODE   = int64(1)
)
const redisModule = "msgCount"

func SafeConvert2String(obj interface{}) string {
	if obj != nil {
		return obj.(string)
	}
	return ""
}

// in数据处理
func Inhandle(data *[]map[string]interface{}) (messId string) {
	if len(*data) == 0 {
		messId = "''"
		return
	}
	for k, m := range *data {
		if k > 0 {
			messId += `,`
		}
		messId += "'" + quitl.InterfaceToStr(m["messageId"]) + "'"
	}
	return
}

type SubPush struct {
	Data  map[string]interface{} `json:"data"`
	Count int                    `json:"count"`
}

// 获取redis key
func todayKey(userType int64, userId int64) string {
	return fmt.Sprintf("%s_%d_%d", "messageCount", userType, userId)
}
func GetData(userType int64, userId int64) (*SubPush, error) {
	pc_a, err := redis.GetNewBytes(redisModule, todayKey(userType, userId))
	if err != nil {
		return nil, err
	}
	if pc_a == nil {
		return nil, nil
	}
	var p *SubPush
	if err := json.Unmarshal(*pc_a, &p); err != nil {
		return nil, err
	}
	return p, nil
}
func SetData(userType int64, userId int64, data map[string]interface{}, survivalTime int) {
	redis.Put(redisModule, todayKey(userType, userId), data, survivalTime)
}

func IntJoin(elems []int64, sep string) string {
	switch len(elems) {
	case 0:
		return ""
	case 1:
		return quitl.InterfaceToStr(elems[0])
	}
	var b strings.Builder
	b.Grow(len(elems))
	for k, s := range elems {
		if k > 0 {
			b.WriteString(sep)
		}
		b.WriteString(quitl.InterfaceToStr(s))
	}
	return b.String()
}

// 排序 排序键必须为数字类型
type SortBy struct {
	Data    []map[string]interface{}
	Sortkey string
}

func (a SortBy) Len() int { return len(a.Data) }

func (a SortBy) Swap(i, j int) {
	a.Data[i], a.Data[j] = a.Data[j], a.Data[i]
}

func (a SortBy) Less(i, j int) bool {
	//return Float64(a.Data[i][a.Sortkey]) < Float64(a.Data[j][a.Sortkey])
	m := a.Data[i][a.Sortkey]
	n := a.Data[j][a.Sortkey]
	w := reflect.ValueOf(m)
	v := reflect.ValueOf(n)
	switch v.Kind() {
	case reflect.String:
		return w.String() < v.String()
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return w.Int() < v.Int()
	case reflect.Float64, reflect.Float32:
		return w.Float() < v.Float()
	default:
		return fmt.Sprintf("%v", w) < fmt.Sprintf("%v", v)
	}
}

// 根据指定字符排序
//
//	m := []map[string]int{
//	   {"k": 2},
//	   {"k": 1},
//	   {"k": 3},
//	}
//
// customer.SortData(&m, "k", true)
// ture  倒序3, 2, 1
// fmt.Println(m)
func SortData(data interface{}, sortkey string, reverse bool) {
	//func SortData(data interface{}, sortkey string, reverse bool) {
	var db []map[string]interface{}
	err := quitl.Bind(data, &db)
	if err != nil {
		fmt.Println(err)
		return
	}
	stb := SortBy{db, sortkey}
	if !reverse {
		sort.Sort(stb)
	} else {
		sort.Sort(sort.Reverse(stb))
	}
	err = quitl.Bind(stb.Data, data)
	if err != nil {
		fmt.Println(err)
	}

}