fusen/fusenapi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'develop' of https://gitee.com/fusenpack/fusenapi into develop

Browse Source
This commit is contained in:
eson 2023-09-19 17:34:14 +08:00
commit 25903207dc
19 changed files with 522 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
server/home-user-auth/internal/handler/routes.go
View File

@ -92,6 +92,11 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
Path: "/api/user/logo-set",
Handler: UserLogoSetHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/api/user/logo-templatetag-set",
Handler: UserLogoTemplateTagSetHandler(serverCtx),
},
},
)
}

35
server/home-user-auth/internal/handler/userlogotemplatetagsethandler.go Normal file
View File

@ -0,0 +1,35 @@
package handler
import (
"net/http"
"reflect"
"fusenapi/utils/basic"
"fusenapi/server/home-user-auth/internal/logic"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
)
func UserLogoTemplateTagSetHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UserLogoTemplateTagSetReq
userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
if err != nil {
return
}
// 创建一个业务逻辑层实例
l := logic.NewUserLogoTemplateTagSetLogic(r.Context(), svcCtx)
rl := reflect.ValueOf(l)
basic.BeforeLogic(w, r, rl)
resp := l.UserLogoTemplateTagSet(&req, userinfo)
if !basic.AfterLogic(w, r, rl, resp) {
basic.NormalAfterLogic(w, r, resp)
}
}
}

46
server/home-user-auth/internal/logic/userlogosetlogic.go
View File

@ -75,17 +75,16 @@ func (l *UserLogoSetLogic) UserLogoSet(req *types.UserLogoSetReq, userinfo *auth
var nowTime = time.Now().UTC()
err = l.svcCtx.MysqlConn.WithContext(l.ctx).Transaction(func(tx *gorm.DB) error {
var metadataMapOldUserMaterial map[string]interface{}
if userMaterialInfo.Metadata != nil {
err = json.Unmarshal(*userMaterialInfo.Metadata, &metadataMapOldUserMaterial)
if err != nil {
logc.Errorf(l.ctx, "userMaterialInfo Metadata Unmarshal err：%+v", err)
return err
}
}
// 更新merchant_category
if req.SetLogoCategory == 1 {
var metadataMapOldUserMaterial map[string]interface{}
if userMaterialInfo.Metadata != nil {
err = json.Unmarshal(*userMaterialInfo.Metadata, &metadataMapOldUserMaterial)
if err != nil {
logc.Errorf(l.ctx, "userMaterialInfo Metadata Unmarshal err：%+v", err)
return err
}
}
var metadataChildUserMaterial = make(map[string]interface{}, 1)
metadataChildUserMaterial["merchant_category"] = req.CategoryId
metadataMapUserMaterial, err := metadata.SetMetadata(metadataChildUserMaterial, metadataMapOldUserMaterial)
@ -137,7 +136,34 @@ func (l *UserLogoSetLogic) UserLogoSet(req *types.UserLogoSetReq, userinfo *auth
}
var metadataChildUserInfo = make(map[string]interface{}, 1)
metadataChildUserInfo["logo_selected_id"] = req.LogoSelectedId
userMaterialTemplateTagData, userMaterialTemplateTagEx := metadataMapOldUserMaterial["template_tag"]
if !userMaterialTemplateTagEx {
logc.Errorf(l.ctx, "userMaterialInfo Metadata template_tag err：%+v", err)
return err
}
userMaterialTemplateIdTagIdData, userMaterialTemplateTagIdEx := metadataMapOldUserMaterial["template_tag_id"]
if !userMaterialTemplateTagIdEx {
logc.Errorf(l.ctx, "userMaterialInfo Metadata template_tag_id err：%+v", err)
return err
}
userMaterialTemplateIdTagIds := userMaterialTemplateIdTagIdData.([]interface{})
userMaterialTemplateIdTagId := userMaterialTemplateIdTagIds[0].(string)
userMaterialTemplateTag := userMaterialTemplateTagData.(map[string]interface{})
userMaterialTemplateTagIndex := userMaterialTemplateTag[userMaterialTemplateIdTagId]
templateTagSelected := make(map[string]interface{}, 3)
templateTagSelected["color"] = userMaterialTemplateTagIndex
templateTagSelected["template_tag"] = userMaterialTemplateIdTagId
templateTagSelected["selected_index"] = 0
metadataChildUserInfo["logo_selected"] = map[string]interface{}{
"logo_selected_id": req.LogoSelectedId,
"template_tag_selected": templateTagSelected,
}
metadataMapUserInfo, err := metadata.SetMetadata(metadataChildUserInfo, metadataMapOldUserInfo)
if err != nil {
logc.Errorf(l.ctx, "userInfo Metadata SetMetadata err：%+v", err)

187
server/home-user-auth/internal/logic/userlogotemplatetagsetlogic.go Normal file
View File

@ -0,0 +1,187 @@
package logic
import (
"encoding/json"
"errors"
"fusenapi/model/gmodel"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"fusenapi/utils/metadata"
"time"
"context"
"fusenapi/server/home-user-auth/internal/svc"
"fusenapi/server/home-user-auth/internal/types"
"github.com/zeromicro/go-zero/core/logc"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type UserLogoTemplateTagSetLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewUserLogoTemplateTagSetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLogoTemplateTagSetLogic {
return &UserLogoTemplateTagSetLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
// 处理进入前逻辑w,r
// func (l *UserLogoTemplateTagSetLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
// }
func (l *UserLogoTemplateTagSetLogic) UserLogoTemplateTagSet(req *types.UserLogoTemplateTagSetReq, userinfo *auth.UserInfo) (resp *basic.Response) {
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
// userinfo 传入值时, 一定不为null
if userinfo.IsOnlooker() {
// 如果是，返回未授权的错误码
return resp.SetStatus(basic.CodeUnAuth)
}
if req.LogoSelectedId == 0 {
return resp.SetStatus(basic.CodeApiErr, "logo logo_selected_id not null")
}
if req.TemplateTag == "" {
return resp.SetStatus(basic.CodeApiErr, "logo template tag not null")
}
var userId int64
var guestId int64
NewFsUserMaterialModel := gmodel.NewFsUserMaterialModel(l.svcCtx.MysqlConn)
NewFsUserMaterialModelRow := NewFsUserMaterialModel.RowSelectBuilder(nil).Where("id = ?", req.LogoSelectedId)
if userinfo.IsGuest() {
// 如果是，使用游客ID和游客键名格式
guestId = userinfo.GuestId
NewFsUserMaterialModelRow.Where("guest_id = ?", guestId)
} else {
// 否则，使用用户ID和用户键名格式
userId = userinfo.UserId
NewFsUserMaterialModelRow.Where("user_id = ?", userId)
}
userMaterialInfo, err := NewFsUserMaterialModel.FindOne(l.ctx, NewFsUserMaterialModelRow.Model(&gmodel.FsUserMaterial{}))
if err != nil {
logc.Errorf(l.ctx, "FsUserMaterial FindOne err：%+v", err)
return resp.SetStatus(basic.CodeLogoSetCategory, "logo not find")
}
var nowTime = time.Now().UTC()
err = l.svcCtx.MysqlConn.WithContext(l.ctx).Transaction(func(tx *gorm.DB) error {
var metadataMapOldUserMaterial map[string]interface{}
if userMaterialInfo.Metadata != nil {
err = json.Unmarshal(*userMaterialInfo.Metadata, &metadataMapOldUserMaterial)
if err != nil {
logc.Errorf(l.ctx, "userMaterialInfo Metadata Unmarshal err：%+v", err)
return err
}
}
var module = "profile"
var userInfo = &gmodel.FsUserInfo{}
BuilderDB := tx.Model(&gmodel.FsUserInfo{}).Where("module = ?", module)
if userId > 0 {
BuilderDB.Where("user_id=?", userId)
} else {
BuilderDB.Where("guest_id=?", guestId)
}
userInfoFirstRes := BuilderDB.First(userInfo)
err = userInfoFirstRes.Error
if err != nil {
if !errors.Is(err, gorm.ErrRecordNotFound) {
logc.Errorf(l.ctx, "userInfo First err：%+v", err)
return err
}
}
var metadataMapOldUserInfo map[string]interface{}
if userInfo.Metadata != nil {
err = json.Unmarshal(*userInfo.Metadata, &metadataMapOldUserInfo)
if err != nil {
logc.Errorf(l.ctx, "userInfo Metadata Unmarshal err：%+v", err)
return err
}
}
var metadataChildUserInfo = make(map[string]interface{}, 1)
_, userInfoLogoSelectedEx := metadataMapOldUserInfo["logo_selected"]
if userInfoLogoSelectedEx {
userMaterialTemplateTagData, userMaterialTemplateTagEx := metadataMapOldUserMaterial["template_tag"]
if !userMaterialTemplateTagEx {
logc.Errorf(l.ctx, "userMaterialInfo Metadata template_tag err：%+v", err)
return err
}
userMaterialTemplateTag := userMaterialTemplateTagData.(map[string]interface{})
userMaterialTemplateTagIndex := userMaterialTemplateTag[req.TemplateTag]
if userMaterialTemplateTagIndex == nil {
err = errors.New("TemplateTag not find")
logc.Errorf(l.ctx, "TemplateTag not find err：%+v", err)
return err
}
templateTagSelected := make(map[string]interface{}, 3)
templateTagSelected["color"] = userMaterialTemplateTagIndex
templateTagSelected["template_tag"] = req.TemplateTag
templateTagSelected["selected_index"] = req.TemplateTagColorIndex
metadataChildUserInfo["logo_selected"] = map[string]interface{}{
"template_tag_selected": templateTagSelected,
}
}
metadataMapUserInfo, err := metadata.SetMetadata(metadataChildUserInfo, metadataMapOldUserInfo)
if err != nil {
logc.Errorf(l.ctx, "userInfo Metadata SetMetadata err：%+v", err)
return err
}
metadataBUserInfo, err := json.Marshal(metadataMapUserInfo)
if err != nil {
logc.Errorf(l.ctx, "userInfo Metadata marshal err：%+v", err)
return err
}
userInfo.Metadata = &metadataBUserInfo
if userInfo.Id == 0 {
// 新增
userInfo.Module = &module
userInfo.Ctime = &nowTime
userInfo.Utime = &nowTime
userInfo.UserId = &userId
userInfo.GuestId = &guestId
resCreate := tx.Model(&userInfo).Create(&userInfo)
err = resCreate.Error
} else {
// 更新
userInfo.Utime = &nowTime
resUpdates := tx.Model(&userInfo).Select("metadata").Where("id = ?", userInfo.Id).Updates(&userInfo)
err = resUpdates.Error
}
if err != nil {
if err != gorm.ErrRecordNotFound {
logc.Errorf(l.ctx, "FsUserInfo Updates err：%+v", err)
return err
}
}
return nil
})
if err != nil {
logx.Error(err)
return resp.SetStatus(basic.CodeDbSqlErr, "set logo fail")
}
return resp.SetStatus(basic.CodeOK)
}
// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
// func (l *UserLogoTemplateTagSetLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
// // httpx.OkJsonCtx(r.Context(), w, resp)
// }

6
server/home-user-auth/internal/types/types.go
View File

@ -5,6 +5,12 @@ import (
"fusenapi/utils/basic"
)
type UserLogoTemplateTagSetReq struct {
LogoSelectedId int64 `form:"logo_selected_id"`
TemplateTag string `form:"template_tag"`
TemplateTagColorIndex int64 `form:"template_tag_color_index"`
}
type UserLogoSetReq struct {
SetLogoSelected int64 `form:"set_logo_selected"`
LogoSelectedId int64 `form:"logo_selected_id"`

35
server/product-template-tag/internal/logic/getproducttemplatetagslogic.go
View File

@ -124,23 +124,32 @@ func (l *GetProductTemplateTagsLogic) GetProductTemplateTags(req *types.GetProdu
}
list := make([]types.GetProductTemplateTagsRsp, 0, len(productTemplateTags))
for _, templateInfo := range productTemplateTags {
colors := make([]types.ColorsItem, 0, 10)
SelectedIndex := 0
for _, colorsSet := range mapTemplateTag[*templateInfo.TemplateTag] {
colors := make([][]string, 0, 10)
SelectedColorIndex := 0
isDefaultTemplateTag := false
if colorsSet, ok := mapTemplateTag[*templateInfo.TemplateTag]; ok {
if selectIndex, ok := mapSelectColor[*templateInfo.TemplateTag]; ok {
SelectedIndex = selectIndex
isDefaultTemplateTag = true
SelectedColorIndex = selectIndex
}
colors = colorsSet
}
var templateTagGroups []interface{}
if templateInfo.Groups != nil && *templateInfo.Groups != "" {
if err = json.Unmarshal([]byte(*templateInfo.Groups), &templateTagGroups); err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeJsonErr, "failed to parse groups")
}
colors = append(colors, types.ColorsItem{
Color: colorsSet,
})
}
list = append(list, types.GetProductTemplateTagsRsp{
Id: templateInfo.Id,
TemplateTag: *templateInfo.TemplateTag,
Cover: *templateInfo.Cover,
CoverMetadata: mapResourceMetadata[*templateInfo.Cover],
Colors: colors,
SelectedIndex: SelectedIndex,
Id: templateInfo.Id,
TemplateTag: *templateInfo.TemplateTag,
IsDefaultTemplateTag: isDefaultTemplateTag,
TemplateTagGroups: templateTagGroups,
Cover: *templateInfo.Cover,
CoverMetadata: mapResourceMetadata[*templateInfo.Cover],
Colors: colors,
SelectedColorIndex: SelectedColorIndex,
})
}
return resp.SetStatusWithMessage(basic.CodeOK, "success", list)

18
server/product-template-tag/internal/types/types.go
View File

@ -10,16 +10,14 @@ type GetProductTemplateTagsReq struct {
}
type GetProductTemplateTagsRsp struct {
Id int64 `json:"id"`
TemplateTag string `json:"template_tag"`
Cover string `json:"cover"`
CoverMetadata interface{} `json:"cover_metadata"`
Colors []ColorsItem `json:"colors"`
SelectedIndex int `json:"selected_index"`
}
type ColorsItem struct {
Color []string `json:"color"`
Id int64 `json:"id"`
TemplateTag string `json:"template_tag"`
IsDefaultTemplateTag bool `json:"is_default_template_tag"`
TemplateTagGroups interface{} `json:"template_tag_groups"`
Cover string `json:"cover"`
CoverMetadata interface{} `json:"cover_metadata"`
Colors [][]string `json:"colors"`
SelectedColorIndex int `json:"selected_color_index"`
}
type Request struct {

70
server/resource/internal/logic/logocombinelogic.go
View File

@ -6,7 +6,6 @@ import (
"fusenapi/service/repositories"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"fusenapi/utils/template_switch_info"
"context"
@ -64,45 +63,58 @@ func (l *LogoCombineLogic) LogoCombine(req *types.LogoCombineReq, userinfo *auth
// 否则，使用用户ID和用户键名格式
userId = userinfo.UserId
}
// 获取默认
if req.Address == "" || req.Phone == "" || req.Website == "" || req.Qrcode == "" || req.Slogan == "" {
// 没有查到，先根据模版id 查询模版数据 请求算法数据
productTemplateV2Model := gmodel.NewFsProductTemplateV2Model(l.svcCtx.MysqlConn)
productTemplateV2Info, err := productTemplateV2Model.FindOne(l.ctx, req.TemplateId)
// 没有查到，先根据模版id 查询模版数据 请求算法数据
productTemplateV2Model := gmodel.NewFsProductTemplateV2Model(l.svcCtx.MysqlConn)
productTemplateV2Info, err := productTemplateV2Model.FindOne(l.ctx, req.TemplateId)
if err != nil {
logc.Errorf(l.ctx, "productTemplateV2Model.FindOne：%v", err)
return resp.SetStatus(basic.CodeServiceErr, "模版不存在")
}
templateSwitchInfo := template_switch_info.GetTemplateSwitchInfo(req.TemplateId, productTemplateV2Info.TemplateInfo, *productTemplateV2Info.MaterialImg)
if req.Address == "" && templateSwitchInfo.MaterialData.Address.IfShow {
req.Address = templateSwitchInfo.MaterialData.Address.DefaultValue
}
if req.Phone == "" && templateSwitchInfo.MaterialData.Phone.IfShow {
req.Phone = templateSwitchInfo.MaterialData.Phone.DefaultValue
}
if req.Website == "" && templateSwitchInfo.MaterialData.Website.IfShow {
req.Website = templateSwitchInfo.MaterialData.Website.DefaultValue
}
if req.Qrcode == "" && templateSwitchInfo.MaterialData.QRcode.IfShow {
req.Qrcode = templateSwitchInfo.MaterialData.QRcode.DefaultValue
}
if req.Slogan == "" && templateSwitchInfo.MaterialData.Slogan.IfShow {
req.Slogan = templateSwitchInfo.MaterialData.Slogan.DefaultValue
}
if err != nil {
logc.Errorf(l.ctx, "productTemplateV2Model.FindOne：%v", err)
return resp.SetStatus(basic.CodeServiceErr, "模版不存在")
}
// // 获取默认
// if req.Address == "" || req.Phone == "" || req.Website == "" || req.Qrcode == "" || req.Slogan == "" {
// // 没有查到，先根据模版id 查询模版数据 请求算法数据
// productTemplateV2Model := gmodel.NewFsProductTemplateV2Model(l.svcCtx.MysqlConn)
// productTemplateV2Info, err := productTemplateV2Model.FindOne(l.ctx, req.TemplateId)
// if err != nil {
// logc.Errorf(l.ctx, "productTemplateV2Model.FindOne：%v", err)
// return resp.SetStatus(basic.CodeServiceErr, "模版不存在")
// }
// templateSwitchInfo := template_switch_info.GetTemplateSwitchInfo(req.TemplateId, productTemplateV2Info.TemplateInfo, *productTemplateV2Info.MaterialImg)
// if req.Address == "" && templateSwitchInfo.MaterialData.Address.IfShow {
// req.Address = templateSwitchInfo.MaterialData.Address.DefaultValue
// }
// if req.Phone == "" && templateSwitchInfo.MaterialData.Phone.IfShow {
// req.Phone = templateSwitchInfo.MaterialData.Phone.DefaultValue
// }
// if req.Website == "" && templateSwitchInfo.MaterialData.Website.IfShow {
// req.Website = templateSwitchInfo.MaterialData.Website.DefaultValue
// }
// if req.Qrcode == "" && templateSwitchInfo.MaterialData.QRcode.IfShow {
// req.Qrcode = templateSwitchInfo.MaterialData.QRcode.DefaultValue
// }
// if req.Slogan == "" && templateSwitchInfo.MaterialData.Slogan.IfShow {
// req.Slogan = templateSwitchInfo.MaterialData.Slogan.DefaultValue
// }
// }
res, err := l.svcCtx.Repositories.ImageHandle.LogoCombine(l.ctx, &repositories.LogoCombineReq{
UserId: userId,
GuestId: guestId,
TemplateId: req.TemplateId,
TemplateTag: req.TemplateTag,
Website: req.Website,
Slogan: req.Slogan,
Phone: req.Phone,
Address: req.Address,
Qrcode: req.Qrcode,
Qrcode: req.Qrcode,
LogoUrl: req.LogoUrl,
TemplateTagColor: repositories.TemplateTagColor{
Color: req.TemplateTagColor.Colors,
Index: req.TemplateTagColor.SelectedColorIndex,
},
ProductTemplateTagGroups: req.TemplateTagGroups,
ProductTemplateV2Info: productTemplateV2Info,
})
if err != nil {

37
server/resource/internal/types/types.go
View File

@ -28,13 +28,28 @@ type ResourceInfoReq struct {
}
type LogoCombineReq struct {
TemplateId int64 `form:"template_id"` // 合图参数
TemplateTag string `form:"template_tag"` // 合图参数
Website string `form:"website,optional"` // 合图参数
Slogan string `form:"slogan,optional"` // 合图参数
Address string `form:"address,optional"` // 合图参数
Phone string `form:"phone,optional"` // 合图参数
Qrcode string `form:"qrcode,optional"` // 合图参数
TemplateId int64 `json:"template_id"` // 合图参数
TemplateTag string `json:"template_tag"` // 合图参数
Website string `json:"website,optional"` // 合图参数
Slogan string `json:"slogan,optional"` // 合图参数
Address string `json:"address,optional"` // 合图参数
Phone string `json:"phone,optional"` // 合图参数
Qrcode string `json:"qrcode,optional"` // 合图参数
LogoUrl string `json:"logo_url"` // 合图参数
TemplateTagColor TemplateTagColor `json:"template_tag_color"`
TemplateTagGroups []TemplateTagGroups `json:"template_tag_groups"`
}
type TemplateTagColor struct {
Colors [][]string `json:"colors"` // 颜色组合
SelectedColorIndex int `json:"selected_color_index"` // 主色的下标索引
}
type TemplateTagGroups struct {
Tag string `json:"tag"`
Name string `json:"name"`
Value string `json:"value"`
Fixed int64 `json:"fixed"`
}
type Request struct {
@ -60,10 +75,10 @@ type File struct {
}
type Meta struct {
TotalCount int64 `json:"totalCount"`
PageCount int64 `json:"pageCount"`
CurrentPage int `json:"currentPage"`
PerPage int `json:"perPage"`
TotalCount int64 `json:"total_count"`
PageCount int64 `json:"page_count"`
CurrentPage int `json:"current_page"`
PerPage int `json:"per_page"`
}
// Set 设置Response的Code和Message值

1
server/upload/etc/upload.yaml
View File

@ -20,6 +20,7 @@ AWS:
Token:
BLMService:
Url: "http://18.119.109.254:8999"
# Url: "http://192.168.1.9:8999"
ImageProcess:
# Url: "http://192.168.1.7:8999/FeatureExtraction"
Url: "http://18.119.109.254:8999/FeatureExtraction"

2
server/websocket/internal/logic/datatransferlogic.go
View File

@ -194,8 +194,6 @@ func (l *DataTransferLogic) setConnPool(conn *websocket.Conn, userInfo *auth.Use
userId: userInfo.UserId,
guestId: userInfo.GuestId,
extendRenderProperty: extendRenderProperty{
//renderImageTask: make(map[string]*renderTask),
//renderImageTaskCtlChan: make(chan renderImageControlChanItem, renderImageTaskCtlChanLen),
renderChan: make(chan []byte, renderChanLen),
renderConsumeTickTime: 1, //默认1纳秒，后面需要根据不同用户不同触发速度
},

235
server/websocket/internal/logic/ws_render_image.go
View File

@ -11,7 +11,6 @@ import (
"fusenapi/service/repositories"
"fusenapi/utils/curl"
"fusenapi/utils/hash"
"fusenapi/utils/template_switch_info"
"fusenapi/utils/websocket_data"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
@ -20,8 +19,6 @@ import (
)
var (
//每个websocket连接渲染任务调度队列长度默认值（添加任务/删除任务/修改任务属性）缓冲队列长度（该队列用于避免map并发读写冲突）
renderImageTaskCtlChanLen = 100
//每个websocket渲染任务缓冲队列长度默认值
renderChanLen = 500
)
@ -32,29 +29,10 @@ type renderProcessor struct {
// 云渲染属性
type extendRenderProperty struct {
//renderImageTask map[string]*renderTask //需要渲染的图片任务 key是taskId val 是renderId
//renderImageTaskCtlChan chan renderImageControlChanItem //渲染任务新增/回调结果移除任务/更新渲染耗时属性的控制通道（由于任务map无法读写并发）
renderChan chan []byte //渲染消息入口的缓冲队列
renderConsumeTickTime time.Duration //消费渲染消息时钟间隔(纳秒)，用于后期控制不同类型用户渲染速度限制
}
// 渲染任务新增移除的控制通道的数据
/*type renderImageControlChanItem struct {
option int // 0删除 1添加 2修改耗时属性
taskId string //map的key(必须传)
renderId string // map的val(增加任务时候传)
renderNotifyImageUrl string //渲染回调数据(删除任务时候传)
taskProperty renderTask //渲染任务的属性
}*/
// 渲染任务属性
/*type renderTask struct {
renderId string //渲染id(新增任务传)
unityRenderBeginTime int64 //发送给unity时间
unityRenderEndTime int64 //unity回调结果时间
uploadUnityRenderImageTakesTime int64 //上传unity渲染结果图时间
}*/
// 处理分发到这里的数据
func (r *renderProcessor) allocationMessage(w *wsConnectItem, data []byte) {
//logx.Info("收到渲染任务消息:", string(data))
@ -100,6 +78,19 @@ func (w *wsConnectItem) renderImage(data []byte) {
logx.Error("invalid format of websocket render image message", err)
return
}
if renderImageData.RenderData.Logo == "" {
w.renderErrResponse(renderImageData.RenderId, renderImageData.RenderData.TemplateTag, "", "请传入logo", renderImageData.RenderData.ProductId, w.userId, w.guestId, 0, 0, 0, 0)
return
}
lenColor := len(renderImageData.RenderData.TemplateTagColor.Color)
if lenColor == 0 {
w.renderErrResponse(renderImageData.RenderId, renderImageData.RenderData.TemplateTag, "", "请传入模板标签选择的颜色", renderImageData.RenderData.ProductId, w.userId, w.guestId, 0, 0, 0, 0)
return
}
if renderImageData.RenderData.TemplateTagColor.SelectedColorIndex >= lenColor || renderImageData.RenderData.TemplateTagColor.SelectedColorIndex < 0 {
w.renderErrResponse(renderImageData.RenderId, renderImageData.RenderData.TemplateTag, "", "选择的模板标签颜色索引越界", renderImageData.RenderData.ProductId, w.userId, w.guestId, 0, 0, 0, 0)
return
}
//获取产品信息(部分字段)
productInfo, err := w.logic.svcCtx.AllModels.FsProduct.FindOne(w.logic.ctx, renderImageData.RenderData.ProductId, "id,is_customization")
if err != nil {
@ -116,21 +107,6 @@ func (w *wsConnectItem) renderImage(data []byte) {
w.renderErrResponse(renderImageData.RenderId, renderImageData.RenderData.TemplateTag, "", "该产品不可定制", renderImageData.RenderData.ProductId, w.userId, w.guestId, 0, 0, 0, 0)
return
}
//获取用户需要渲染logo
logoInfo, err := w.logic.svcCtx.Repositories.ImageHandle.LogoInfo(w.logic.ctx, &repositories.LogoInfoReq{
UserId: w.userId,
GuestId: w.guestId,
})
if err != nil {
w.renderErrResponse(renderImageData.RenderId, renderImageData.RenderData.TemplateTag, "", "获取用户logo素材错误", renderImageData.RenderData.ProductId, w.userId, w.guestId, 0, 0, 0, 0)
logx.Error(err)
return
}
if logoInfo == nil || logoInfo.LogoUrl == nil {
w.renderErrResponse(renderImageData.RenderId, renderImageData.RenderData.TemplateTag, "", "用户logo素材url是空的", renderImageData.RenderData.ProductId, w.userId, w.guestId, 0, 0, 0, 0)
return
}
renderImageData.RenderData.Logo = *logoInfo.LogoUrl
//用户id赋值
renderImageData.RenderData.UserId = w.userId
renderImageData.RenderData.GuestId = w.guestId
@ -162,7 +138,7 @@ func (w *wsConnectItem) renderImage(data []byte) {
return
}
//获取模板开关信息并且对于没有默认值的给赋值默认值(但凡DIY有一个是空的就要请求默认数据)
if renderImageData.RenderData.Website == "" || renderImageData.RenderData.Phone == "" || renderImageData.RenderData.Address == "" || renderImageData.RenderData.Qrcode == "" || renderImageData.RenderData.Slogan == "" {
/*if renderImageData.RenderData.Website == "" || renderImageData.RenderData.Phone == "" || renderImageData.RenderData.Address == "" || renderImageData.RenderData.Qrcode == "" || renderImageData.RenderData.Slogan == "" {
templateSwitchInfo := template_switch_info.GetTemplateSwitchInfo(productTemplate.Id, productTemplate.TemplateInfo, *productTemplate.MaterialImg)
if renderImageData.RenderData.Website == "" && templateSwitchInfo.MaterialData.Website.IfShow {
renderImageData.RenderData.Website = templateSwitchInfo.MaterialData.Website.DefaultValue
@ -179,19 +155,24 @@ func (w *wsConnectItem) renderImage(data []byte) {
if renderImageData.RenderData.Slogan == "" && templateSwitchInfo.MaterialData.Slogan.IfShow {
renderImageData.RenderData.Slogan = templateSwitchInfo.MaterialData.Slogan.DefaultValue
}
}
}*/
//获取刀版图
combineReq := repositories.LogoCombineReq{
UserId: renderImageData.RenderData.UserId,
GuestId: renderImageData.RenderData.GuestId,
TemplateId: productTemplate.Id,
TemplateTag: renderImageData.RenderData.TemplateTag,
Website: renderImageData.RenderData.Website,
Slogan: renderImageData.RenderData.Slogan,
Address: renderImageData.RenderData.Address,
Phone: renderImageData.RenderData.Phone,
Qrcode: renderImageData.RenderData.Qrcode,
LogoUrl: renderImageData.RenderData.Logo,
UserId: renderImageData.RenderData.UserId,
GuestId: renderImageData.RenderData.GuestId,
ProductTemplateV2Info: productTemplate,
ProductTemplateTagGroups: renderImageData.RenderData.TemplateTagGroups,
TemplateTag: renderImageData.RenderData.TemplateTag,
Website: renderImageData.RenderData.Website,
Slogan: renderImageData.RenderData.Slogan,
Address: renderImageData.RenderData.Address,
Phone: renderImageData.RenderData.Phone,
Qrcode: renderImageData.RenderData.Qrcode,
LogoUrl: renderImageData.RenderData.Logo,
TemplateTagColor: repositories.TemplateTagColor{
Color: renderImageData.RenderData.TemplateTagColor.Color,
Index: renderImageData.RenderData.TemplateTagColor.SelectedColorIndex,
},
}
res, err := w.logic.svcCtx.Repositories.ImageHandle.LogoCombine(w.logic.ctx, &combineReq)
if err != nil {
@ -216,7 +197,7 @@ func (w *wsConnectItem) renderImage(data []byte) {
}
//获取唯一id
taskId := w.genRenderTaskId(combineImage, renderImageData, model3dInfo, productTemplate, element)
//查询有没有缓存的资源,有就返回######################
//查询有没有缓存的资源,有就返回
resource, err := w.logic.svcCtx.AllModels.FsResource.FindOneById(w.logic.ctx, taskId)
if err != nil {
if !errors.Is(err, gorm.ErrRecordNotFound) {
@ -236,9 +217,6 @@ func (w *wsConnectItem) renderImage(data []byte) {
})
return
}
//###########################################
//把需要渲染的图片任务加进去
//w.createRenderTask(taskId, renderImageData.RenderId)
//组装数据
if err = w.assembleRenderDataToUnity(taskId, combineImage, renderImageData, productTemplate, model3dInfo, element, productSize); err != nil {
logx.Error("组装数据失败:", err)
@ -288,8 +266,8 @@ func (w *wsConnectItem) getProductRelateionInfoWithSizeId(renderImageData *webso
return nil, nil, nil, errors.New("模板未开启云渲染")
}
if productTemplate.TemplateInfo == nil || *productTemplate.TemplateInfo == "" {
w.renderErrResponse(renderImageData.RenderId, renderImageData.RenderData.TemplateTag, "", "渲染模板的json设计信息是空的", renderImageData.RenderData.ProductId, w.userId, w.guestId, productTemplate.Id, model3d.Id, productSize.Id, 0)
return nil, nil, nil, errors.New("渲染模板的json设计信息是空的")
w.renderErrResponse(renderImageData.RenderId, renderImageData.RenderData.TemplateTag, "", "渲染模板的设计信息是空的", renderImageData.RenderData.ProductId, w.userId, w.guestId, productTemplate.Id, model3d.Id, productSize.Id, 0)
return nil, nil, nil, errors.New("渲染模板的设计信息是空的")
}
return
}
@ -430,15 +408,12 @@ func (w *wsConnectItem) assembleRenderDataToUnity(taskId string, combineImage st
"render_data": sendData,
}
postDataBytes, _ := json.Marshal(postData)
//unityRenderBeginTime := time.Now().UTC().UnixMilli()
_, err = curl.ApiCall(url, "POST", header, bytes.NewReader(postDataBytes), time.Second*10)
if err != nil {
w.renderErrResponse(info.RenderId, info.RenderData.TemplateTag, taskId, "请求unity接口失败", info.RenderData.ProductId, w.userId, w.guestId, productTemplate.Id, model3dInfo.Id, productSize.Id, *productTemplate.ElementModelId)
logx.Error("failed to send data to unity")
return err
}
//记录发送到unity时间
//w.modifyRenderTaskProperty(taskId, renderTask{unityRenderBeginTime: unityRenderBeginTime})
//发送运行阶段消息
w.sendRenderDataToUnityStepResponseMessage(info.RenderId)
logx.Info("发送到unity成功,刀版图:", combineImage /*, " 请求unity的数据:", string(postDataBytes)*/)
@ -483,75 +458,6 @@ func (w *wsConnectItem) sendRenderResultData(data websocket_data.RenderImageRspM
w.sendToOutChan(w.respondDataFormat(constants.WEBSOCKET_RENDER_IMAGE, data))
}
/*// 增加渲染任务
func (w *wsConnectItem) createRenderTask(taskId, renderId string) {
if taskId == "" {
logx.Error("task_id不能为空")
return
}
if renderId == "" {
logx.Error("render_id不能为空")
return
}
data := renderImageControlChanItem{
option: 1,
taskId: taskId,
renderId: renderId,
}
select {
case <-w.closeChan: //关闭
return
case w.extendRenderProperty.renderImageTaskCtlChan <- data:
return
case <-time.After(time.Second * 3):
return
}
}
// 渲染回调处理并删除渲染任务
func (w *wsConnectItem) deleteRenderTask(taskId, renderId, renderNotifyImageUrl string) {
if taskId == "" {
logx.Error("task_id不能为空")
return
}
data := renderImageControlChanItem{
option: 0,
taskId: taskId,
renderId: renderId,
renderNotifyImageUrl: renderNotifyImageUrl,
}
select {
case <-w.closeChan: //关闭
return
case w.extendRenderProperty.renderImageTaskCtlChan <- data:
return
case <-time.After(time.Second * 3):
return
}
}
// 修改任务属性(只有耗时属性可以更新)
func (w *wsConnectItem) modifyRenderTaskProperty(taskId string, property renderTask) {
if taskId == "" {
logx.Error("task_id不能为空")
return
}
//强制设为修改任务属性
data := renderImageControlChanItem{
option: 2,
taskId: taskId,
taskProperty: property,
}
select {
case <-w.closeChan: //关闭
return
case w.extendRenderProperty.renderImageTaskCtlChan <- data:
return
case <-time.After(time.Second * 3):
return
}
}*/
// 组装渲染任务id
func (w *wsConnectItem) genRenderTaskId(combineImage string, renderImageData websocket_data.RenderImageReqMsg, model3dInfo *gmodel.FsProductModel3d, productTemplate *gmodel.FsProductTemplateV2, element *gmodel.FsProductTemplateElement) string {
//生成任务id(需要把user_id,guest_id设为0)
@ -578,78 +484,3 @@ func (w *wsConnectItem) genRenderTaskId(combineImage string, renderImageData web
}
return hash.JsonHashKey(hashMap)
}
// 处理渲染任务的增加/删除/修改耗时属性（任务map不能读写并发，所以放在chan里面串行执行）
/*func (w *wsConnectItem) operationRenderTask() {
defer func() {
if err := recover(); err != nil {
logx.Error("operation render task panic:", err)
}
}()
for {
select {
case <-w.closeChan:
return
case data := <-w.extendRenderProperty.renderImageTaskCtlChan:
switch data.option {
case 0: //渲染结果回调，删除任务
taskData, ok := w.extendRenderProperty.renderImageTask[data.taskId]
if !ok {
//发送到出口
w.sendRenderResultData(websocket_data.RenderImageRspMsg{
RenderId: data.renderId, //没有找到任务渲染id则用传进来的
Image: data.renderNotifyImageUrl,
RenderProcessTime: websocket_data.RenderProcessTime{
UnityRenderTakesTime: "unknown",
UploadUnityRenderImageTakesTime: "unknown",
},
})
continue
}
//删除任务
delete(w.extendRenderProperty.renderImageTask, data.taskId)
//存在任务，则发送渲染结果给前端
UnityRenderTakesTime := "cache"
uploadUnityRenderImageTakesTime := "cache"
//unity渲染时间
if taskData.unityRenderBeginTime > 0 && taskData.unityRenderEndTime > 0 {
UnityRenderTakesTime = fmt.Sprintf("%dms", taskData.unityRenderEndTime-taskData.unityRenderBeginTime)
}
//上传unity渲染图耗时
if taskData.uploadUnityRenderImageTakesTime > 0 {
uploadUnityRenderImageTakesTime = fmt.Sprintf("%dms", taskData.uploadUnityRenderImageTakesTime)
}
//发送到出口
w.sendRenderResultData(websocket_data.RenderImageRspMsg{
RenderId: taskData.renderId,
Image: data.renderNotifyImageUrl,
RenderProcessTime: websocket_data.RenderProcessTime{
UnityRenderTakesTime: UnityRenderTakesTime,
UploadUnityRenderImageTakesTime: uploadUnityRenderImageTakesTime,
},
})
case 1: //新增任务
w.extendRenderProperty.renderImageTask[data.taskId] = &renderTask{
renderId: data.renderId,
}
case 2: //修改任务属性
taskData, ok := w.extendRenderProperty.renderImageTask[data.taskId]
if !ok {
continue
}
//上传渲染结果图耗时
if data.taskProperty.uploadUnityRenderImageTakesTime != 0 {
taskData.uploadUnityRenderImageTakesTime = data.taskProperty.uploadUnityRenderImageTakesTime
}
//发送unity时间
if data.taskProperty.unityRenderBeginTime != 0 {
taskData.unityRenderBeginTime = data.taskProperty.unityRenderBeginTime
}
//收到unity返回的时间
if data.taskProperty.unityRenderEndTime != 0 {
taskData.unityRenderEndTime = data.taskProperty.unityRenderEndTime
}
}
}
}
}*/

12
server_api/home-user-auth.api
View File

@ -71,8 +71,20 @@ service home-user-auth {
// 用户logo设置当前
@handler UserLogoSetHandler
post /api/user/logo-set (UserLogoSetReq) returns (response);
// 用户logo模版信息
@handler UserLogoTemplateTagSetHandler
post /api/user/logo-templatetag-set (UserLogoTemplateTagSetReq) returns (response);
}
type (
UserLogoTemplateTagSetReq {
LogoSelectedId int64 `form:"logo_selected_id"`
TemplateTag string `form:"template_tag"`
TemplateTagColorIndex int64 `form:"template_tag_color_index"`
}
)
type (
UserLogoSetReq {
SetLogoSelected int64 `form:"set_logo_selected"`

17
server_api/product-template-tag.api
View File

@ -20,13 +20,12 @@ type GetProductTemplateTagsReq {
Limit int `form:"limit"`
}
type GetProductTemplateTagsRsp {
Id int64 `json:"id"`
TemplateTag string `json:"template_tag"`
Cover string `json:"cover"`
CoverMetadata interface{} `json:"cover_metadata"`
Colors []ColorsItem `json:"colors"`
SelectedIndex int `json:"selected_index"`
}
type ColorsItem {
Color []string `json:"color"`
Id int64 `json:"id"`
TemplateTag string `json:"template_tag"`
IsDefaultTemplateTag bool `json:"is_default_template_tag"`
TemplateTagGroups interface{} `json:"template_tag_groups"`
Cover string `json:"cover"`
CoverMetadata interface{} `json:"cover_metadata"`
Colors [][]string `json:"colors"`
SelectedColorIndex int `json:"selected_color_index"`
}

29
server_api/resource.api
View File

@ -55,12 +55,27 @@ type (
type (
LogoCombineReq {
TemplateId int64 `form:"template_id"` // 合图参数
TemplateTag string `form:"template_tag"` // 合图参数
Website string `form:"website,optional"` // 合图参数
Slogan string `form:"slogan,optional"` // 合图参数
Address string `form:"address,optional"` // 合图参数
Phone string `form:"phone,optional"` // 合图参数
Qrcode string `form:"qrcode,optional"` // 合图参数
TemplateId int64 `json:"template_id"` // 合图参数
TemplateTag string `json:"template_tag"` // 合图参数
Website string `json:"website,optional"` // 合图参数
Slogan string `json:"slogan,optional"` // 合图参数
Address string `json:"address,optional"` // 合图参数
Phone string `json:"phone,optional"` // 合图参数
Qrcode string `json:"qrcode,optional"` // 合图参数
LogoUrl string `json:"logo_url"` // 合图参数
TemplateTagColor TemplateTagColor `json:"template_tag_color"`
TemplateTagGroups []TemplateTagGroups `json:"template_tag_groups"`
}
TemplateTagColor {
Colors [][]string `json:"colors"` // 颜色组合
SelectedColorIndex int `json:"selected_color_index"` // 主色的下标索引
}
TemplateTagGroups {
Tag string `json:"tag"`
Name string `json:"name"`
Value string `json:"value"`
Fixed int64 `json:"fixed"`
}
)

92
service/repositories/image_handle.go
View File

@ -89,28 +89,36 @@ func (l *defaultImageHandle) LogoInfo(ctx context.Context, in *LogoInfoReq) (*Lo
}
var userMaterialInfo gmodel.FsUserMaterial
userMaterialModel := gmodel.NewFsUserMaterialModel(l.MysqlConn)
var metadataUserInfo struct {
LogoSelected struct {
TemplateTagSelected *struct {
Color [][]string `json:"color"`
TemplateTag string `json:"template_tag"`
SelectedIndex int64 `json:"selected_index"`
} `json:"template_tag_selected"`
LogoSelectedId int64 `json:"logo_selected_id"`
} `json:"logo_selected"`
}
userInfo.Id = 0
if userInfo.Id == 0 {
userMaterialInfo, err = userMaterialModel.FindLatestOne(ctx, in.UserId, in.GuestId)
if err != gorm.ErrRecordNotFound {
if err != nil && err != gorm.ErrRecordNotFound {
logc.Errorf(ctx, "FsUserMaterial FindLatestOne err：%+v", err)
return nil, err
}
} else {
if userInfo.Metadata != nil {
var metadata map[string]interface{}
err = json.Unmarshal([]byte(*userInfo.Metadata), &metadata)
err = json.Unmarshal([]byte(*userInfo.Metadata), &metadataUserInfo)
if err != nil {
logc.Errorf(ctx, "userInfo.Metadata Unmarshal err：%+v", err)
return nil, err
}
logoSelectedId, isEx := metadata["logo_selected_id"]
if isEx {
var materialId int64 = int64(logoSelectedId.(float64))
userMaterialInfos, err := userMaterialModel.FindOneById(ctx, materialId)
if metadataUserInfo.LogoSelected.LogoSelectedId != 0 {
userMaterialInfos, err := userMaterialModel.FindOneById(ctx, metadataUserInfo.LogoSelected.LogoSelectedId)
if err != nil {
if err != gorm.ErrRecordNotFound {
logc.Errorf(ctx, "FsUserInfo First err：%+v", err)
logc.Errorf(ctx, "userMaterial findOneById err：%+v", err)
return nil, err
}
}
@ -187,16 +195,18 @@ func (l *defaultImageHandle) LogoInfoSet(ctx context.Context, in *LogoInfoSetReq
/* logo合图 */
type (
LogoCombineReq struct {
UserId int64 `json:"user_id"`
GuestId int64 `json:"guest_id"`
TemplateId int64 `json:"template_id"`
TemplateTag string `json:"template_tag"`
Website string `json:"website"` // 合图参数
Slogan string `json:"slogan"` // 合图参数
Address string `json:"address"` // 合图参数
Phone string `json:"phone"` // 合图参数
Qrcode string `json:"qrcode"` // 合图参数
LogoUrl string `json:"logo_url"` // 合图参数
UserId int64 `json:"user_id"`
GuestId int64 `json:"guest_id"`
ProductTemplateV2Info *gmodel.FsProductTemplateV2 `json:"product_template_v2_info"`
ProductTemplateTagGroups interface{} `json:"product_template_tag_groups"`
TemplateTag string `json:"template_tag"`
Website string `json:"website"` // 合图参数
Slogan string `json:"slogan"` // 合图参数
Address string `json:"address"` // 合图参数
Phone string `json:"phone"` // 合图参数
Qrcode string `json:"qrcode"` // 合图参数
LogoUrl string `json:"logo_url"` // 合图参数
TemplateTagColor TemplateTagColor `json:"template_tag_color"` //合图颜色
}
LogoCombineRes struct {
ResourceId string
@ -206,6 +216,10 @@ type (
DiffTimeUploadFile int64
}
)
type TemplateTagColor struct {
Color [][]string `json:"color"`
Index int `json:"index"`
}
func (l *defaultImageHandle) LogoCombine(ctx context.Context, in *LogoCombineReq) (*LogoCombineRes, error) {
// 查询logo最新基础信息
@ -244,27 +258,11 @@ func (l *defaultImageHandle) LogoCombine(ctx context.Context, in *LogoCombineReq
}
}
// 没有查到，先根据模版id 查询模版数据 请求算法数据
productTemplateV2Model := gmodel.NewFsProductTemplateV2Model(l.MysqlConn)
productTemplateV2Info, err := productTemplateV2Model.FindOne(ctx, in.TemplateId)
if err != nil {
logc.Errorf(ctx, "productTemplateV2Model.FindOne：%v", err)
return nil, err
}
productTemplateTagInfo, err := gmodel.NewFsProductTemplateTagsModel(l.MysqlConn).FindOneByTagName(ctx, in.TemplateTag, "groups")
if err != nil {
logc.Errorf(ctx, "NewFsProductTemplateTagsModel.FindOneByTagName：%v", err)
return nil, err
}
var groupOptions map[string]interface{}
var materialList []interface{}
if productTemplateV2Info.TemplateInfo != nil {
if in.ProductTemplateV2Info.TemplateInfo != nil {
var templateInfo map[string]interface{}
err = json.Unmarshal([]byte(*productTemplateV2Info.TemplateInfo), &templateInfo)
err = json.Unmarshal([]byte(*in.ProductTemplateV2Info.TemplateInfo), &templateInfo)
if err != nil {
logx.Error(err)
@ -288,18 +286,11 @@ func (l *defaultImageHandle) LogoCombine(ctx context.Context, in *LogoCombineReq
}
var moduleDataMap = make(map[string]interface{}, 4)
moduleDataMap["id"] = productTemplateV2Info.Id
moduleDataMap["material"] = productTemplateV2Info.MaterialImg
moduleDataMap["id"] = in.ProductTemplateV2Info.Id
moduleDataMap["material"] = in.ProductTemplateV2Info.MaterialImg
moduleDataMap["groupOptions"] = groupOptions
moduleDataMap["materialList"] = materialList
var tagDataMap []interface{}
err = json.Unmarshal([]byte(*productTemplateTagInfo.Groups), &tagDataMap)
if err != nil {
logc.Errorf(ctx, "Unmarshal tagDataMap：%v", err)
return nil, err
}
var combineParam map[string]interface{}
json.Unmarshal([]byte(*resLogoInfo.Metadata), &combineParam)
combineParam["template_tagid"] = in.TemplateTag
@ -308,11 +299,14 @@ func (l *defaultImageHandle) LogoCombine(ctx context.Context, in *LogoCombineReq
combineParam["phone"] = in.Phone
combineParam["address"] = in.Address
combineParam["qrcode"] = in.Qrcode
//combineParam["template_tag_selected"] =
combineParam["template_tag_selected"] = map[string]interface{}{
"template_tag": in.TemplateTag,
"color": in.TemplateTagColor.Color,
"index": in.TemplateTagColor.Index,
}
var postMap = make(map[string]interface{}, 2)
postMap["module_data"] = moduleDataMap
postMap["tag_data"] = tagDataMap
postMap["tag_data"] = in.ProductTemplateTagGroups
postMap["param_data"] = combineParam
logc.Infof(ctx, "合图--算法请求--合图--开始时间：%v", time.Now().UTC())

8
utils/fssql/metadata_test.go
View File

@ -14,15 +14,9 @@ func TestCase1(t *testing.T) {
}
conn := initalize.InitMysql("fsreaderwriter:XErSYmLELKMnf3Dh@tcp(fusen.cdmigcvz3rle.us-east-2.rds.amazonaws.com:3306)/fusen")
err := fssql.MetadataModulePATCH(conn, "logo", gmodel.FsChangeCode{}, u, "id = ?", 6)
err := fssql.MetadataModulePATCH(conn, "profile", gmodel.FsUserInfo{}, u, "id = ?", 90)
if err != nil {
panic(err)
}
err = fssql.MetadataResourcePATCH(conn,
"f8932c0379fa5aa3397dc0a963696ca90536cc273ea10119b0137fd15ecfe673", u)
if err != nil {
panic(err)
}
}

26
utils/metadata/metadata.go
View File

@ -5,9 +5,15 @@ func SetMetadata(metadataChild map[string]interface{}, oldMetadata map[string]in
for k, v := range metadataChild {
switch val := v.(type) {
case map[string]interface{}:
oldResourceMetadataData := oldMetadata[k].(map[string]interface{})
for key, val1 := range val {
oldResourceMetadataData[key] = val1
kValue, kEx := oldMetadata[k]
var oldResourceMetadataData map[string]interface{}
if kEx {
oldResourceMetadataData = kValue.(map[string]interface{})
} else {
oldResourceMetadataData = make(map[string]interface{}, len(val))
}
for key1, val1 := range val {
oldResourceMetadataData[key1] = val1
}
oldMetadata[k] = oldResourceMetadataData
default:
@ -20,11 +26,17 @@ func SetMetadata(metadataChild map[string]interface{}, oldMetadata map[string]in
for k, v := range metadataChild {
switch val := v.(type) {
case map[string]interface{}:
var resourceMetadataData = make(map[string]interface{}, len(val))
for key, val1 := range val {
resourceMetadataData[key] = val1
kValue, kEx := oldMetadata[k]
var oldResourceMetadataData map[string]interface{}
if kEx {
oldResourceMetadataData = kValue.(map[string]interface{})
} else {
oldResourceMetadataData = make(map[string]interface{}, len(val))
}
oldMetadata[k] = resourceMetadataData
for key, val1 := range val {
oldResourceMetadataData[key] = val1
}
oldMetadata[k] = oldResourceMetadataData
default:
oldMetadata[k] = val
}

28
utils/websocket_data/render_data.go
View File

@ -15,17 +15,23 @@ type RenderImageReqMsg struct {
RenderData RenderData `json:"render_data"`
}
type RenderData struct {
TemplateTag string `json:"template_tag"` //模板标签(必须)
ProductId int64 `json:"product_id"` //产品id(必须)
Website string `json:"website"` //网站(可选)
Slogan string `json:"slogan"` //slogan(可选)
Address string `json:"address"` //地址(可选)
Phone string `json:"phone"` //电话(可选)
Qrcode string `json:"qrcode"` //二维码(可选)
ProductSizeId int64 `json:"product_size_id"` //尺寸id(可选)
UserId int64 `json:"user_id"` //用户id(websocket连接建立再赋值)
GuestId int64 `json:"guest_id"` //游客id(websocket连接建立再赋值)
Logo string `json:"logo"` //log资源地址(websocket连接建立再赋值)
TemplateTag string `json:"template_tag"` //模板标签(必须)
TemplateTagColor TemplateTagColor `json:"template_tag_color"` //模板标签组合颜色(必须)
TemplateTagGroups interface{} `json:"template_tag_groups"` //模板标签分组信息数组(必须)
Logo string `json:"logo"` //log资源地址(必须)
ProductId int64 `json:"product_id"` //产品id(必须)
Website string `json:"website"` //网站(可选)
Slogan string `json:"slogan"` //slogan(可选)
Address string `json:"address"` //地址(可选)
Phone string `json:"phone"` //电话(可选)
Qrcode string `json:"qrcode"` //二维码(可选)
ProductSizeId int64 `json:"product_size_id"` //尺寸id(可选)
UserId int64 `json:"user_id"` //用户id(websocket连接建立再赋值)
GuestId int64 `json:"guest_id"` //游客id(websocket连接建立再赋值)
}
type TemplateTagColor struct {
Color [][]string `json:"color"` //颜色组合
SelectedColorIndex int `json:"selected_color_index"` //主色的下标索引
}
// websocket发送渲染完的数据