fusenapi/server/render/consumer/assemble_render_data.go

package consumer

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"fusenapi/constants"
	"fusenapi/initalize"
	"fusenapi/model/gmodel"
	"fusenapi/utils/websocket_data"
	"github.com/zeromicro/go-zero/core/logx"
	"gorm.io/gorm"
	"io/ioutil"
	"net/http"
	"strconv"
	"time"
)

// 这里请求的py接口返回数据
type pythonApiRsp struct {
	Code int    `json:"code"`
	Msg  string `json:"msg"`
	Data []struct {
		Tid      int64  `json:"tid"`
		Imgurl   string `json:"imgurl"`
		Costtime int64  `json:"costtime"`
	} `json:"data"`
}

// 消费渲染需要组装的数据
type MqConsumerRenderAssemble struct {
}

func (m *MqConsumerRenderAssemble) Run(ctx context.Context, data []byte) error {
	logx.Info("收到需要组装的消息:", string(data))
	var parseInfo websocket_data.AssembleRenderData
	if err := json.Unmarshal(data, &parseInfo); err != nil {
		logx.Error("MqConsumerRenderAssemble数据格式错误:", err)
		return nil //不返回错误就删除消息
	}
	val := ctx.Value("allmodels")
	if val == nil {
		return errors.New("allmodels is nil")
	}
	allmodels, ok := val.(*gmodel.AllModelsGen)
	if !ok {
		return errors.New("allmodels is nil!!")
	}
	timeSearchBegin := time.Now().UnixMilli()
	//获取模板
	templateInfo, err := allmodels.FsProductTemplateV2.FindOneByProductIdTagIdWithSizeTable(ctx, parseInfo.RenderData.ProductId, fmt.Sprintf("%d", parseInfo.RenderData.TemplateTagId))
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logx.Error("template info is not found")
			return nil
		}
		logx.Error("failed to get template info:", err)
		return err
	}
	renderLogTime := time.Now().UnixMilli() - timeSearchBegin
	now := time.Now().Unix()
	title := "1-组装模板数据"
	//云渲染日志
	err = allmodels.FsCloudRenderLog.Create(ctx, &gmodel.FsCloudRenderLog{
		UserId: &parseInfo.RenderData.UserId,
		Title:  &title,
		Time:   &renderLogTime,
		Tag:    &parseInfo.RenderId,
		Ctime:  &now,
	})
	if err != nil {
		logx.Error(err)
	}
	pyapiBeginTime := time.Now().UnixMilli()
	//这里curl post请求数据。获取处理好的贴图数据，用于贴model的贴图
	pythonPostData := map[string]interface{}{
		"tids": templateInfo.Id,
		"data": parseInfo.RenderData.Data,
	}
	pyPostBytes, _ := json.Marshal(pythonPostData)
	url := "http://110.41.19.98:8867/imgRender"
	pyRsp, err := http.Post(url, "application/json;charset=UTF-8", bytes.NewReader(pyPostBytes))
	if err != nil {
		logx.Error("request python render api err:", err)
		return err
	}
	defer pyRsp.Body.Close()
	pyRspBytes, err := ioutil.ReadAll(pyRsp.Body)
	if err != nil {
		logx.Error("failed to read python api rsp body,err=", err)
		return err
	}
	var rspInfo pythonApiRsp
	if err = json.Unmarshal(pyRspBytes, &rspInfo); err != nil {
		logx.Error("failed to unmarshal python api rsp:", err)
		return err
	}
	if rspInfo.Code != 200 {
		logx.Error("python api 接口请求错误:", rspInfo.Msg)
		return err
	}
	if len(rspInfo.Data) == 0 {
		logx.Error("python api 接口没有数据:")
		return err
	}
	mapImageData := make(map[int64]int)
	for k, v := range rspInfo.Data {
		mapImageData[v.Tid] = k
	}
	//云渲染日志
	title = "2-请求->接收python合成刀版图接口"
	now = time.Now().Unix()
	pyRequestTime := time.Now().UnixMilli() - pyapiBeginTime
	err = allmodels.FsCloudRenderLog.Create(ctx, &gmodel.FsCloudRenderLog{
		UserId: &parseInfo.RenderData.UserId,
		Title:  &title,
		Time:   &pyRequestTime,
		Tag:    &parseInfo.RenderId,
		Ctime:  &now,
	})
	if err != nil {
		logx.Error(err)
	}
	incTime := int64(0)
	mapCurlData := make(map[int64]int)
	for k, v := range rspInfo.Data {
		mapCurlData[v.Tid] = k
		incTime += v.Costtime
	}
	//云渲染日志
	title = "3-python合成刀版图"
	now = time.Now().Unix()
	postData := string(pyPostBytes)
	pyRspStr := string(pyRspBytes)
	err = allmodels.FsCloudRenderLog.Create(ctx, &gmodel.FsCloudRenderLog{
		UserId:   &parseInfo.RenderData.UserId,
		PostUrl:  &url,
		PostData: &postData,
		Result:   &pyRspStr,
		Title:    &title,
		Time:     &incTime,
		Tag:      &parseInfo.RenderId,
		Ctime:    &now,
	})
	if err != nil {
		logx.Error(err)
	}
	timePinjieBegin := time.Now().UnixMilli()
	//获取渲染设置信息
	element, err := allmodels.FsProductTemplateElement.FindOneByModelId(ctx, *templateInfo.ModelId)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logx.Error("element info is not found,model_id = ?", *templateInfo.ModelId)
			return nil
		}
		logx.Error("failed to get element list,", err)
		return err
	}
	//组装数据
	refletion := -1
	if element.Refletion != nil && *element.Refletion != "" {
		refletion, err = strconv.Atoi(*element.Refletion)
	}
	//组装data数据
	var mode map[string]interface{}
	if element.Mode != nil && *element.Mode != "" {
		if err = json.Unmarshal([]byte(*element.Mode), &mode); err != nil {
			logx.Error("faile to parse element mode json:", err)
			return err
		}
	}
	baseImage := ""
	if index, ok := mapImageData[templateInfo.Id]; ok {
		baseImage = constants.H5_URL + "/storage" + rspInfo.Data[index].Imgurl
	}
	tempData := []map[string]interface{}{}
	if element.Base != nil && *element.Base != "" {
		tempData = append(tempData, map[string]interface{}{
			"name":      "model",
			"data":      "0," + baseImage + "," + *element.Base,
			"type":      "other",
			"layer":     "0",
			"is_update": 1,
			"mode":      mode["model"],
		})
	}
	if element.Shadow != nil && *element.Shadow != "" {
		tempData = append(tempData, map[string]interface{}{
			"name":      "shadow",
			"data":      *element.Shadow,
			"type":      "other",
			"layer":     "0",
			"is_update": 0,
			"mode":      mode["shadow"],
		})
	}
	if element.ModelP != nil && *element.ModelP != "" {
		tempData = append(tempData, map[string]interface{}{
			"name":      "model_P",
			"data":      "0," + *element.ModelP,
			"type":      "other",
			"layer":     "0",
			"is_update": 0,
			"mode":      mode["model_P"],
		})
	}
	result := []interface{}{
		map[string]interface{}{
			"light":     *element.Light,
			"refletion": refletion,
			"scale":     *element.Scale,
			"sku_id":    *templateInfo.ProductId,
			"tid":       *element.Title,
			"rotation":  *element.Rotation,
			"filePath":  "", //todo 文件路径,针对千人千面
			"data":      tempData,
		},
	}
	timePinjie := time.Now().UnixMilli() - timePinjieBegin
	//云渲染日志
	title = "接收到python刀版图 -> 3-组装MQ渲染任务队列"
	now = time.Now().Unix()
	err = allmodels.FsCloudRenderLog.Create(ctx, &gmodel.FsCloudRenderLog{
		UserId: &parseInfo.RenderData.UserId,
		Title:  &title,
		Time:   &timePinjie,
		Tag:    &parseInfo.RenderId,
		Ctime:  &now,
	})
	if err != nil {
		logx.Error(err)
	}
	sendData := map[string]interface{}{
		"id":               parseInfo.RenderId,
		"order_id":         0,
		"user_id":          parseInfo.RenderData.UserId,
		"sku_ids":          []int64{parseInfo.RenderData.ProductId},
		"tids":             []string{*element.Title},
		"data":             result,
		"is_thousand_face": 0,
		"folder":           "", //todo 千人千面需要使用
	}
	b, _ := json.Marshal(sendData)
	rabbitmq := initalize.RabbitMqHandle{}
	if err = rabbitmq.SendMsg(constants.RABBIT_MQ_TO_UNITY, b); err != nil {
		logx.Error("发送渲染组装数据到rabbitmq失败：", err)
		return err
	}
	logx.Info("发送渲染组装数据到rabbitmq 成功")
	return nil
}