l_msg_api/paramset.go

package l_msg_api

import (
	"context"
	"encoding/json"
	"fmt"
	"gitea.cdlsxd.cn/rzy_tools/request"
	"gitea.cdlsxd.cn/self-tools/l_msg_api/cache"
	"gitea.cdlsxd.cn/self-tools/l_msg_api/httpclient"
	"reflect"
	"strings"
	"time"
)

func (m *MessageCenter) parseOACreateParam(formModel *FormsData) (out []byte) {
	req := formDataRequest{
		Base: m.base,
	}
	req.FormComponentValues = formModel.FormComponentValues
	req.Finance = formModel.Finance
	req.formBase = formModel.formBase
	out, _ = json.Marshal(req)
	return
}

func (m *MessageCenter) parseSmsSendParam(tels []string, jsonParam string) (out []byte) {
	out, _ = json.Marshal(smsRequest{
		Base:  m.base,
		Tels:  strings.Join(tels, ","),
		Param: jsonParam,
	})
	return
}
func (m *MessageCenter) parseSendBlackBoardParam(title, content string, receiver blackboardReceiverView) (out []byte) {
	out, _ = json.Marshal(dingTalkBlackBoardSendReq{
		Base:               m.base,
		Content:            content,
		Title:              title,
		BlackboardReceiver: receiver,
	})
	return
}

func (m *MessageCenter) getAccessToken() (string, error) {
	var data accessTokenResponse
	if tokenInstance, exist := cache.InstanceCacheMap().Get(m.ClientKey); exist {
		data = tokenInstance.(accessTokenResponse)
		if int64(data.AccessExpire) >= time.Now().Unix() {
			return data.AccessToken, nil
		}
	}
	var authParam, _ = json.Marshal(map[string]string{"client_key": m.ClientKey, "client_secret": m.ClientSecret})
	err := m.accessPost(accessToken, authParam, &data)
	if err != nil {
		return "", err
	}
	cache.InstanceCacheMap().Put(m.ClientKey, data)
	return data.AccessToken, err
}

func (m *MessageCenter) send(ctx context.Context, path requestPathIndex, data []byte, resReflect interface{}) (err error) {
	switch m.option.RequestWay {
	case Rpc:
		//return m.rpc(ctx, requestAddr, data, resReflect)
	default:
		requestAddr := requestPath[path][Http]
		return m.post(ctx, requestAddr, data, resReflect)
	}
	return
}

//func (m *MessageCenter) rpc(ctx context.Context, path string, data []byte, resReflect interface{}) (err error) {
//
//	client := protoc.InstanceMsgClient(m.Host)
//	client.FinanceNotify(ctx, a)
//	return
//}

func (m *MessageCenter) post(ctx context.Context, path string, data []byte, resReflect interface{}) (err error) {
	var body responseBody
	res, err := httpclient.FastHttpPost(fmt.Sprintf("%s%s", m.Host, path), m.header, data, timeOut)
	if err != nil {
		return
	}
	if err = json.Unmarshal(res, &body); err != nil {
		return fmt.Errorf("请求失败:%s", string(res))
	}
	if body.Code != 0 {
		return fmt.Errorf("请求失败:%s", body.Msg)
	}

	dataByte, err := json.Marshal(body.Data)
	if err != nil {
		return fmt.Errorf("未知的返回格式:%s", string(dataByte))
	}
	if err = json.Unmarshal(dataByte, resReflect); err != nil {
		return fmt.Errorf("未知的返回格式:%s", string(dataByte))
	}

	return
}

func (m *MessageCenter) OtherSend(ctx context.Context, request *request.Request) (res request.Response, err error) {
	res, err = request.Send()
	return
}

func (m *MessageCenter) accessPost(path requestPathIndex, data []byte, resReflect interface{}) (err error) {
	pathStr := requestPath[path][Http]
	var body responseBody
	res, err := httpclient.FastHttpPost(fmt.Sprintf("%s%s", m.Host, pathStr), m.header, data, timeOut)
	if err != nil {
		return
	}
	if err = json.Unmarshal(res, &body); err != nil {
		return fmt.Errorf("请求失败:%s", string(res))
	}
	if body.Code != 0 {
		return fmt.Errorf("请求失败:%s", body.Msg)
	}

	dataByte, err := json.Marshal(body.Data)
	if err != nil {
		return fmt.Errorf("未知的返回格式:%s", string(dataByte))
	}
	if err = json.Unmarshal(dataByte, &resReflect); err != nil {
		return fmt.Errorf("未知的返回格式:%s", string(dataByte))
	}

	return
}

func (m *MessageCenter) setHeader() (err error) {
	m.header = map[string]string{"content-type": "application/json; charset=utf-8"}
	token, err := m.getAccessToken()
	if err != nil {
		return
	}
	m.header = map[string]string{"Authorization": token, "content-type": "application/json; charset=utf-8"}
	return
}

// StructToMap 将一个struct转换为map[string]interface{}
func structToMap(obj interface{}) map[string]interface{} {
	// 获取obj的类型
	val := reflect.ValueOf(obj)
	if val.Kind() == reflect.Ptr {
		val = val.Elem()
	}

	// 确保obj是一个struct
	if val.Kind() != reflect.Struct {
		return nil
	}

	// 创建一个map来保存结果
	data := make(map[string]interface{})

	// 遍历struct的字段
	for i := 0; i < val.NumField(); i++ {
		// 获取字段的类型和值
		valueField := val.Field(i)
		typeField := val.Type().Field(i)
		jsonTag := typeField.Tag.Get("json")
		if idx := strings.Index(jsonTag, ","); idx != -1 {
			// 如果有逗号，则取逗号之前的部分
			jsonTag = jsonTag[:idx]
		}
		// 忽略未导出的字段（字段名首字母小写）
		if !typeField.IsExported() {
			continue
		}

		// 将字段名和值添加到map中
		data[jsonTag] = valueField.Interface()
	}

	return data
}

// MapInterfaceToMapString map[string]interface{} to map[string]string
func mapInterfaceToMapString(inputMap map[string]interface{}) map[string]string {
	var mapString = make(map[string]string)
	for key, value := range inputMap {
		mapString[key] = fmt.Sprintf("%v", value)
	}
	return mapString
}

// ChunkSlice 将一个切片分割成多个子切片，每个子切片最多包含 maxSize 个元素
func ChunkSlice[T any](slice []T, maxSize int) [][]T {
	var chunks [][]T
	length := len(slice)

	for i := 0; i < length; i += maxSize {
		end := i + maxSize
		if end > length {
			end = length
		}
		chunks = append(chunks, slice[i:end])
	}

	return chunks
}