fonchain-fiee/pkg/service/base2.go

// Package pkg -----------------------------
// @file      : base2.go
// @author    : JJXu
// @contact   : wavingbear@163.com
// @time      : 2023/3/6 17:00
// -------------------------------------------
package service

import (
	"context"
	"encoding/json"
	"fmt"
	artShow "github.com/fonchain_enterprise/fonchain-main/api/artShow"
	"reflect"
	"strings"

	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils"
	"github.com/gin-gonic/gin"
)

type ListData struct {
	Data any `json:"Data"`
}

func ErrorWithMark(c *gin.Context, code int, err error, mark string, msg ...string) {
	fmt.Println("!!!!!ERROR：", mark)
	errMsg := ""
	if err != nil {
		errMsg = err.Error()
	}
	c.JSON(e.Success, serializer.Response{
		Status: e.Failed,
		Code:   code,
		Err:    errMsg,
		Msg:    utils.If(msg != nil, strings.Join(msg, ";"), "").(string),
		Mark:   mark,
		Data:   struct{}{},
	})
	c.Abort()
}

// 返回单条数据
func ResponseData(c *gin.Context, data interface{}, opts ...ResponseOption) {
	var response = serializer.Response{
		Status: e.Ok,
		Code:   e.Ok,
		Data:   data,
		Msg:    "ok",
		Keys:   []string{"*"},
	}
	if opts != nil {
		for _, opt := range opts {
			opt(&response)
		}
	}
	if response.Data == nil {
		response.Data = struct{}{}
	}
	c.JSON(response.Status, response)
}

type ResponseOption func(*serializer.Response)

// 返回列表
func ResponseList(c *gin.Context, list any, opts ...ResponseOption) {
	var response = serializer.Response{
		Status: e.Ok,
		Code:   e.Ok,
		Data:   ListData{Data: list},
		Msg:    "ok",
		Keys:   []string{"*"},
	}
	if opts != nil {
		for _, opt := range opts {
			opt(&response)
		}
	}
	c.JSON(response.Status, response)
}

func OptionMark(mark string) ResponseOption {
	fmt.Println("!!!!!ERROR：", mark)
	return func(response *serializer.Response) {
		response.Mark = mark
	}
}
func OptionMsg(msg string) ResponseOption {
	return func(response *serializer.Response) {
		response.Msg = msg
	}
}

func OptionPage[T1 int | int32 | int64 | uint64, T2 int32 | int64 | int](page, pageSize T1, total T2) ResponseOption {
	return func(response *serializer.Response) {
		//优化返回值，使其不为空
		//t := reflect.TypeOf(response.Data)
		if response.Data == nil { //|| ((t.Kind() == reflect.Slice || t.Kind() == reflect.Array) && reflect.ValueOf(response.Data).Len() == 0)
			response.Data = ListData{Data: []struct{}{}}
		} else if list, ok := response.Data.(ListData); ok {
			//t := reflect.TypeOf(ListData)
			//fmt.Println(t.Kind() == reflect.Slice)
			//fmt.Println(t.Kind() == reflect.Array)
			//fmt.Println(reflect.ValueOf(ListData.Data).Len())
			if list.Data == nil || reflect.ValueOf(list.Data).Len() == 0 {
				response.Data = ListData{Data: []struct{}{}}
			}
		}
		response.Page = &serializer.PageInfo{
			Page:     int32(page),
			PageSize: int32(pageSize),
			Total:    int32(total),
		}
		//按前端需求，将total放在response.Data里面
		bytesData, _ := json.Marshal(response.Data)
		var mapData map[string]any
		_ = json.Unmarshal(bytesData, &mapData)
		mapData["Total"] = total
		response.Data = mapData
	}
}

// 在列表数据的每项中添加字段--画展数量统计
func OptionAddField_ArtshowCount(artistUidJsonField string) ResponseOption {
	return func(response *serializer.Response) {
		var tmplist = []map[string]any{}
		var listData ListData
		var mapData map[string]any
		var ok bool
		if response.Data == nil {
			fmt.Println("OptionAddField_ArtshowCount: response.Data is nil")
			return
		} else if listData, ok = response.Data.(ListData); ok {
			if listData.Data == nil || reflect.ValueOf(listData.Data).Len() == 0 {
				fmt.Println("OptionAddField_ArtshowCount: response.Data length is 0")
				return
			}
			bytesData, _ := json.Marshal(listData.Data)
			_ = json.Unmarshal(bytesData, &tmplist)
		} else if mapData, ok = response.Data.(map[string]any); ok {
			listInter, ok := mapData["Data"]
			if ok && listInter != nil {
				if listMap, ok := listInter.([]any); ok {
					//list解析到tmplist中
					bytesData, _ := json.Marshal(listMap)
					_ = json.Unmarshal(bytesData, &tmplist)
				}
			}
		}
		FillArtshowCount(tmplist, artistUidJsonField)
		if listData.Data != nil {
			listData.Data = tmplist
			response.Data = listData
		} else {
			mapData["Data"] = tmplist
			response.Data = mapData
		}
		fmt.Printf("OptionAddField_ArtshowCount:%+v\n", response.Data)
	}
}
func FillArtshowCount(tmpData []map[string]any, artistUidJsonField string) {
	var artistUids []string
	for _, v := range tmpData {
		artistUids = append(artistUids, v[artistUidJsonField].(string))
	}
	var artistNameFields = []string{"artistName", "realName", "ArtistName", "RealName"}
	countList, err := GrpcArtShowImpl.ArtistExhibitionCount(context.Background(), &artShow.ArtistExhibitionCountReq{ArtistUid: artistUids})
	if err != nil {
		fmt.Println("FillArtshowCount:GrpcArtShowImpl.ArtistExhibitionCount Error", err)
		for i := range tmpData {
			var artistName any
			var ok bool
			for _, filed := range artistNameFields {
				if artistName, ok = tmpData[i][filed]; ok {
					break
				}
			}
			tmpData[i]["artistShowCount"] = fmt.Sprintf("%s(0)", artistName)
		}
		return
	}

	for i, tmp := range tmpData {
		var found = false
		for _, v := range countList.ArtistShowCount {
			if tmp[artistUidJsonField] == v.ArtistUid {
				found = true
				var artistName any
				var ok bool
				for _, filed := range artistNameFields {
					if artistName, ok = tmpData[i][filed]; ok {
						break
					}
				}
				tmpData[i]["artistShowCount"] = fmt.Sprintf("%s(%d)", artistName, v.ShowCount)
				fmt.Printf("FillArtshowCount:artistShowCount:%s\n", tmpData[i]["artistShowCount"])
				break
			}
		}
		if !found {
			var artistName any
			var ok bool
			for _, filed := range artistNameFields {
				if artistName, ok = tmpData[i][filed]; ok {
					break
				}
			}
			tmpData[i]["artistShowCount"] = fmt.Sprintf("%s(0)", artistName)
			fmt.Printf("FillArtshowCount:artistName:%s notfound!!!!!!!\n", artistName)
		}
	}
}