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", Path: "/api/user/logo-set",
Handler: UserLogoSetHandler(serverCtx), 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)
}
}
}

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

@ -75,9 +75,6 @@ func (l *UserLogoSetLogic) UserLogoSet(req *types.UserLogoSetReq, userinfo *auth
var nowTime = time.Now().UTC() var nowTime = time.Now().UTC()
err = l.svcCtx.MysqlConn.WithContext(l.ctx).Transaction(func(tx *gorm.DB) error { err = l.svcCtx.MysqlConn.WithContext(l.ctx).Transaction(func(tx *gorm.DB) error {
// 更新merchant_category
if req.SetLogoCategory == 1 {
var metadataMapOldUserMaterial map[string]interface{} var metadataMapOldUserMaterial map[string]interface{}
if userMaterialInfo.Metadata != nil { if userMaterialInfo.Metadata != nil {
err = json.Unmarshal(*userMaterialInfo.Metadata, &metadataMapOldUserMaterial) err = json.Unmarshal(*userMaterialInfo.Metadata, &metadataMapOldUserMaterial)
@ -86,6 +83,8 @@ func (l *UserLogoSetLogic) UserLogoSet(req *types.UserLogoSetReq, userinfo *auth
return err return err
} }
} }
// 更新merchant_category
if req.SetLogoCategory == 1 {
var metadataChildUserMaterial = make(map[string]interface{}, 1) var metadataChildUserMaterial = make(map[string]interface{}, 1)
metadataChildUserMaterial["merchant_category"] = req.CategoryId metadataChildUserMaterial["merchant_category"] = req.CategoryId
metadataMapUserMaterial, err := metadata.SetMetadata(metadataChildUserMaterial, metadataMapOldUserMaterial) 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) 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) metadataMapUserInfo, err := metadata.SetMetadata(metadataChildUserInfo, metadataMapOldUserInfo)
if err != nil { if err != nil {
logc.Errorf(l.ctx, "userInfo Metadata SetMetadata err：%+v", err) 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" "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 { type UserLogoSetReq struct {
SetLogoSelected int64 `form:"set_logo_selected"` SetLogoSelected int64 `form:"set_logo_selected"`
LogoSelectedId int64 `form:"logo_selected_id"` LogoSelectedId int64 `form:"logo_selected_id"`

25
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)) list := make([]types.GetProductTemplateTagsRsp, 0, len(productTemplateTags))
for _, templateInfo := range productTemplateTags { for _, templateInfo := range productTemplateTags {
colors := make([]types.ColorsItem, 0, 10) colors := make([][]string, 0, 10)
SelectedIndex := 0 SelectedColorIndex := 0
for _, colorsSet := range mapTemplateTag[*templateInfo.TemplateTag] { isDefaultTemplateTag := false
if colorsSet, ok := mapTemplateTag[*templateInfo.TemplateTag]; ok {
if selectIndex, ok := mapSelectColor[*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{ list = append(list, types.GetProductTemplateTagsRsp{
Id: templateInfo.Id, Id: templateInfo.Id,
TemplateTag: *templateInfo.TemplateTag, TemplateTag: *templateInfo.TemplateTag,
IsDefaultTemplateTag: isDefaultTemplateTag,
TemplateTagGroups: templateTagGroups,
Cover: *templateInfo.Cover, Cover: *templateInfo.Cover,
CoverMetadata: mapResourceMetadata[*templateInfo.Cover], CoverMetadata: mapResourceMetadata[*templateInfo.Cover],
Colors: colors, Colors: colors,
SelectedIndex: SelectedIndex, SelectedColorIndex: SelectedColorIndex,
}) })
} }
return resp.SetStatusWithMessage(basic.CodeOK, "success", list) return resp.SetStatusWithMessage(basic.CodeOK, "success", list)

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

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

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

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

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

@ -28,13 +28,28 @@ type ResourceInfoReq struct {
} }
type LogoCombineReq struct { type LogoCombineReq struct {
TemplateId int64 `form:"template_id"` // 合图参数 TemplateId int64 `json:"template_id"` // 合图参数
TemplateTag string `form:"template_tag"` // 合图参数 TemplateTag string `json:"template_tag"` // 合图参数
Website string `form:"website,optional"` // 合图参数 Website string `json:"website,optional"` // 合图参数
Slogan string `form:"slogan,optional"` // 合图参数 Slogan string `json:"slogan,optional"` // 合图参数
Address string `form:"address,optional"` // 合图参数 Address string `json:"address,optional"` // 合图参数
Phone string `form:"phone,optional"` // 合图参数 Phone string `json:"phone,optional"` // 合图参数
Qrcode string `form:"qrcode,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 { type Request struct {
@ -60,10 +75,10 @@ type File struct {
} }
type Meta struct { type Meta struct {
TotalCount int64 `json:"totalCount"` TotalCount int64 `json:"total_count"`
PageCount int64 `json:"pageCount"` PageCount int64 `json:"page_count"`
CurrentPage int `json:"currentPage"` CurrentPage int `json:"current_page"`
PerPage int `json:"perPage"` PerPage int `json:"per_page"`
} }
// Set 设置Response的Code和Message值 // Set 设置Response的Code和Message值

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

@ -20,6 +20,7 @@ AWS:
Token: Token:
BLMService: BLMService:
Url: "http://18.119.109.254:8999" Url: "http://18.119.109.254:8999"
# Url: "http://192.168.1.9:8999"
ImageProcess: ImageProcess:
# Url: "http://192.168.1.7:8999/FeatureExtraction" # Url: "http://192.168.1.7:8999/FeatureExtraction"
Url: "http://18.119.109.254: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, userId: userInfo.UserId,
guestId: userInfo.GuestId, guestId: userInfo.GuestId,
extendRenderProperty: extendRenderProperty{ extendRenderProperty: extendRenderProperty{
//renderImageTask: make(map[string]*renderTask),
//renderImageTaskCtlChan: make(chan renderImageControlChanItem, renderImageTaskCtlChanLen),
renderChan: make(chan []byte, renderChanLen), renderChan: make(chan []byte, renderChanLen),
renderConsumeTickTime: 1, //默认1纳秒，后面需要根据不同用户不同触发速度 renderConsumeTickTime: 1, //默认1纳秒，后面需要根据不同用户不同触发速度
}, },

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

@ -11,7 +11,6 @@ import (
"fusenapi/service/repositories" "fusenapi/service/repositories"
"fusenapi/utils/curl" "fusenapi/utils/curl"
"fusenapi/utils/hash" "fusenapi/utils/hash"
"fusenapi/utils/template_switch_info"
"fusenapi/utils/websocket_data" "fusenapi/utils/websocket_data"
"github.com/zeromicro/go-zero/core/logx" "github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm" "gorm.io/gorm"
@ -20,8 +19,6 @@ import (
) )
var ( var (
//每个websocket连接渲染任务调度队列长度默认值（添加任务/删除任务/修改任务属性）缓冲队列长度（该队列用于避免map并发读写冲突）
renderImageTaskCtlChanLen = 100
//每个websocket渲染任务缓冲队列长度默认值 //每个websocket渲染任务缓冲队列长度默认值
renderChanLen = 500 renderChanLen = 500
) )
@ -32,29 +29,10 @@ type renderProcessor struct {
// 云渲染属性 // 云渲染属性
type extendRenderProperty struct { type extendRenderProperty struct {
//renderImageTask map[string]*renderTask //需要渲染的图片任务 key是taskId val 是renderId
//renderImageTaskCtlChan chan renderImageControlChanItem //渲染任务新增/回调结果移除任务/更新渲染耗时属性的控制通道（由于任务map无法读写并发）
renderChan chan []byte //渲染消息入口的缓冲队列 renderChan chan []byte //渲染消息入口的缓冲队列
renderConsumeTickTime time.Duration //消费渲染消息时钟间隔(纳秒)，用于后期控制不同类型用户渲染速度限制 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) { func (r *renderProcessor) allocationMessage(w *wsConnectItem, data []byte) {
//logx.Info("收到渲染任务消息:", string(data)) //logx.Info("收到渲染任务消息:", string(data))
@ -100,6 +78,19 @@ func (w *wsConnectItem) renderImage(data []byte) {
logx.Error("invalid format of websocket render image message", err) logx.Error("invalid format of websocket render image message", err)
return 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") productInfo, err := w.logic.svcCtx.AllModels.FsProduct.FindOne(w.logic.ctx, renderImageData.RenderData.ProductId, "id,is_customization")
if err != nil { 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) w.renderErrResponse(renderImageData.RenderId, renderImageData.RenderData.TemplateTag, "", "该产品不可定制", renderImageData.RenderData.ProductId, w.userId, w.guestId, 0, 0, 0, 0)
return 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赋值 //用户id赋值
renderImageData.RenderData.UserId = w.userId renderImageData.RenderData.UserId = w.userId
renderImageData.RenderData.GuestId = w.guestId renderImageData.RenderData.GuestId = w.guestId
@ -162,7 +138,7 @@ func (w *wsConnectItem) renderImage(data []byte) {
return return
} }
//获取模板开关信息并且对于没有默认值的给赋值默认值(但凡DIY有一个是空的就要请求默认数据) //获取模板开关信息并且对于没有默认值的给赋值默认值(但凡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) templateSwitchInfo := template_switch_info.GetTemplateSwitchInfo(productTemplate.Id, productTemplate.TemplateInfo, *productTemplate.MaterialImg)
if renderImageData.RenderData.Website == "" && templateSwitchInfo.MaterialData.Website.IfShow { if renderImageData.RenderData.Website == "" && templateSwitchInfo.MaterialData.Website.IfShow {
renderImageData.RenderData.Website = templateSwitchInfo.MaterialData.Website.DefaultValue renderImageData.RenderData.Website = templateSwitchInfo.MaterialData.Website.DefaultValue
@ -179,12 +155,13 @@ func (w *wsConnectItem) renderImage(data []byte) {
if renderImageData.RenderData.Slogan == "" && templateSwitchInfo.MaterialData.Slogan.IfShow { if renderImageData.RenderData.Slogan == "" && templateSwitchInfo.MaterialData.Slogan.IfShow {
renderImageData.RenderData.Slogan = templateSwitchInfo.MaterialData.Slogan.DefaultValue renderImageData.RenderData.Slogan = templateSwitchInfo.MaterialData.Slogan.DefaultValue
} }
} }*/
//获取刀版图 //获取刀版图
combineReq := repositories.LogoCombineReq{ combineReq := repositories.LogoCombineReq{
UserId: renderImageData.RenderData.UserId, UserId: renderImageData.RenderData.UserId,
GuestId: renderImageData.RenderData.GuestId, GuestId: renderImageData.RenderData.GuestId,
TemplateId: productTemplate.Id, ProductTemplateV2Info: productTemplate,
ProductTemplateTagGroups: renderImageData.RenderData.TemplateTagGroups,
TemplateTag: renderImageData.RenderData.TemplateTag, TemplateTag: renderImageData.RenderData.TemplateTag,
Website: renderImageData.RenderData.Website, Website: renderImageData.RenderData.Website,
Slogan: renderImageData.RenderData.Slogan, Slogan: renderImageData.RenderData.Slogan,
@ -192,6 +169,10 @@ func (w *wsConnectItem) renderImage(data []byte) {
Phone: renderImageData.RenderData.Phone, Phone: renderImageData.RenderData.Phone,
Qrcode: renderImageData.RenderData.Qrcode, Qrcode: renderImageData.RenderData.Qrcode,
LogoUrl: renderImageData.RenderData.Logo, 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) res, err := w.logic.svcCtx.Repositories.ImageHandle.LogoCombine(w.logic.ctx, &combineReq)
if err != nil { if err != nil {
@ -216,7 +197,7 @@ func (w *wsConnectItem) renderImage(data []byte) {
} }
//获取唯一id //获取唯一id
taskId := w.genRenderTaskId(combineImage, renderImageData, model3dInfo, productTemplate, element) taskId := w.genRenderTaskId(combineImage, renderImageData, model3dInfo, productTemplate, element)
//查询有没有缓存的资源,有就返回###################### //查询有没有缓存的资源,有就返回
resource, err := w.logic.svcCtx.AllModels.FsResource.FindOneById(w.logic.ctx, taskId) resource, err := w.logic.svcCtx.AllModels.FsResource.FindOneById(w.logic.ctx, taskId)
if err != nil { if err != nil {
if !errors.Is(err, gorm.ErrRecordNotFound) { if !errors.Is(err, gorm.ErrRecordNotFound) {
@ -236,9 +217,6 @@ func (w *wsConnectItem) renderImage(data []byte) {
}) })
return return
} }
//###########################################
//把需要渲染的图片任务加进去
//w.createRenderTask(taskId, renderImageData.RenderId)
//组装数据 //组装数据
if err = w.assembleRenderDataToUnity(taskId, combineImage, renderImageData, productTemplate, model3dInfo, element, productSize); err != nil { if err = w.assembleRenderDataToUnity(taskId, combineImage, renderImageData, productTemplate, model3dInfo, element, productSize); err != nil {
logx.Error("组装数据失败:", err) logx.Error("组装数据失败:", err)
@ -288,8 +266,8 @@ func (w *wsConnectItem) getProductRelateionInfoWithSizeId(renderImageData *webso
return nil, nil, nil, errors.New("模板未开启云渲染") return nil, nil, nil, errors.New("模板未开启云渲染")
} }
if productTemplate.TemplateInfo == nil || *productTemplate.TemplateInfo == "" { 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) 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("渲染模板的json设计信息是空的") return nil, nil, nil, errors.New("渲染模板的设计信息是空的")
} }
return return
} }
@ -430,15 +408,12 @@ func (w *wsConnectItem) assembleRenderDataToUnity(taskId string, combineImage st
"render_data": sendData, "render_data": sendData,
} }
postDataBytes, _ := json.Marshal(postData) postDataBytes, _ := json.Marshal(postData)
//unityRenderBeginTime := time.Now().UTC().UnixMilli()
_, err = curl.ApiCall(url, "POST", header, bytes.NewReader(postDataBytes), time.Second*10) _, err = curl.ApiCall(url, "POST", header, bytes.NewReader(postDataBytes), time.Second*10)
if err != nil { 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) 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") logx.Error("failed to send data to unity")
return err return err
} }
//记录发送到unity时间
//w.modifyRenderTaskProperty(taskId, renderTask{unityRenderBeginTime: unityRenderBeginTime})
//发送运行阶段消息 //发送运行阶段消息
w.sendRenderDataToUnityStepResponseMessage(info.RenderId) w.sendRenderDataToUnityStepResponseMessage(info.RenderId)
logx.Info("发送到unity成功,刀版图:", combineImage /*, " 请求unity的数据:", string(postDataBytes)*/) 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)) 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 // 组装渲染任务id
func (w *wsConnectItem) genRenderTaskId(combineImage string, renderImageData websocket_data.RenderImageReqMsg, model3dInfo *gmodel.FsProductModel3d, productTemplate *gmodel.FsProductTemplateV2, element *gmodel.FsProductTemplateElement) string { 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) //生成任务id(需要把user_id,guest_id设为0)
@ -578,78 +484,3 @@ func (w *wsConnectItem) genRenderTaskId(combineImage string, renderImageData web
} }
return hash.JsonHashKey(hashMap) 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设置当前 // 用户logo设置当前
@handler UserLogoSetHandler @handler UserLogoSetHandler
post /api/user/logo-set (UserLogoSetReq) returns (response); 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 ( type (
UserLogoSetReq { UserLogoSetReq {
SetLogoSelected int64 `form:"set_logo_selected"` SetLogoSelected int64 `form:"set_logo_selected"`

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

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

29
server_api/resource.api
View File

@ -55,12 +55,27 @@ type (
type ( type (
LogoCombineReq { LogoCombineReq {
TemplateId int64 `form:"template_id"` // 合图参数 TemplateId int64 `json:"template_id"` // 合图参数
TemplateTag string `form:"template_tag"` // 合图参数 TemplateTag string `json:"template_tag"` // 合图参数
Website string `form:"website,optional"` // 合图参数 Website string `json:"website,optional"` // 合图参数
Slogan string `form:"slogan,optional"` // 合图参数 Slogan string `json:"slogan,optional"` // 合图参数
Address string `form:"address,optional"` // 合图参数 Address string `json:"address,optional"` // 合图参数
Phone string `form:"phone,optional"` // 合图参数 Phone string `json:"phone,optional"` // 合图参数
Qrcode string `form:"qrcode,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"`
} }
) )

74
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 var userMaterialInfo gmodel.FsUserMaterial
userMaterialModel := gmodel.NewFsUserMaterialModel(l.MysqlConn) 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 { if userInfo.Id == 0 {
userMaterialInfo, err = userMaterialModel.FindLatestOne(ctx, in.UserId, in.GuestId) 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) logc.Errorf(ctx, "FsUserMaterial FindLatestOne err：%+v", err)
return nil, err return nil, err
} }
} else { } else {
if userInfo.Metadata != nil { if userInfo.Metadata != nil {
var metadata map[string]interface{} err = json.Unmarshal([]byte(*userInfo.Metadata), &metadataUserInfo)
err = json.Unmarshal([]byte(*userInfo.Metadata), &metadata)
if err != nil { if err != nil {
logc.Errorf(ctx, "userInfo.Metadata Unmarshal err：%+v", err) logc.Errorf(ctx, "userInfo.Metadata Unmarshal err：%+v", err)
return nil, err return nil, err
} }
logoSelectedId, isEx := metadata["logo_selected_id"]
if isEx { if metadataUserInfo.LogoSelected.LogoSelectedId != 0 {
var materialId int64 = int64(logoSelectedId.(float64)) userMaterialInfos, err := userMaterialModel.FindOneById(ctx, metadataUserInfo.LogoSelected.LogoSelectedId)
userMaterialInfos, err := userMaterialModel.FindOneById(ctx, materialId)
if err != nil { if err != nil {
if err != gorm.ErrRecordNotFound { if err != gorm.ErrRecordNotFound {
logc.Errorf(ctx, "FsUserInfo First err：%+v", err) logc.Errorf(ctx, "userMaterial findOneById err：%+v", err)
return nil, err return nil, err
} }
} }
@ -189,7 +197,8 @@ type (
LogoCombineReq struct { LogoCombineReq struct {
UserId int64 `json:"user_id"` UserId int64 `json:"user_id"`
GuestId int64 `json:"guest_id"` GuestId int64 `json:"guest_id"`
TemplateId int64 `json:"template_id"` ProductTemplateV2Info *gmodel.FsProductTemplateV2 `json:"product_template_v2_info"`
ProductTemplateTagGroups interface{} `json:"product_template_tag_groups"`
TemplateTag string `json:"template_tag"` TemplateTag string `json:"template_tag"`
Website string `json:"website"` // 合图参数 Website string `json:"website"` // 合图参数
Slogan string `json:"slogan"` // 合图参数 Slogan string `json:"slogan"` // 合图参数
@ -197,6 +206,7 @@ type (
Phone string `json:"phone"` // 合图参数 Phone string `json:"phone"` // 合图参数
Qrcode string `json:"qrcode"` // 合图参数 Qrcode string `json:"qrcode"` // 合图参数
LogoUrl string `json:"logo_url"` // 合图参数 LogoUrl string `json:"logo_url"` // 合图参数
TemplateTagColor TemplateTagColor `json:"template_tag_color"` //合图颜色
} }
LogoCombineRes struct { LogoCombineRes struct {
ResourceId string ResourceId string
@ -206,6 +216,10 @@ type (
DiffTimeUploadFile int64 DiffTimeUploadFile int64
} }
) )
type TemplateTagColor struct {
Color [][]string `json:"color"`
Index int `json:"index"`
}
func (l *defaultImageHandle) LogoCombine(ctx context.Context, in *LogoCombineReq) (*LogoCombineRes, error) { func (l *defaultImageHandle) LogoCombine(ctx context.Context, in *LogoCombineReq) (*LogoCombineRes, error) {
// 查询logo最新基础信息 // 查询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 groupOptions map[string]interface{}
var materialList []interface{} var materialList []interface{}
if productTemplateV2Info.TemplateInfo != nil { if in.ProductTemplateV2Info.TemplateInfo != nil {
var templateInfo map[string]interface{} var templateInfo map[string]interface{}
err = json.Unmarshal([]byte(*productTemplateV2Info.TemplateInfo), &templateInfo) err = json.Unmarshal([]byte(*in.ProductTemplateV2Info.TemplateInfo), &templateInfo)
if err != nil { if err != nil {
logx.Error(err) logx.Error(err)
@ -288,18 +286,11 @@ func (l *defaultImageHandle) LogoCombine(ctx context.Context, in *LogoCombineReq
} }
var moduleDataMap = make(map[string]interface{}, 4) var moduleDataMap = make(map[string]interface{}, 4)
moduleDataMap["id"] = productTemplateV2Info.Id moduleDataMap["id"] = in.ProductTemplateV2Info.Id
moduleDataMap["material"] = productTemplateV2Info.MaterialImg moduleDataMap["material"] = in.ProductTemplateV2Info.MaterialImg
moduleDataMap["groupOptions"] = groupOptions moduleDataMap["groupOptions"] = groupOptions
moduleDataMap["materialList"] = materialList 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{} var combineParam map[string]interface{}
json.Unmarshal([]byte(*resLogoInfo.Metadata), &combineParam) json.Unmarshal([]byte(*resLogoInfo.Metadata), &combineParam)
combineParam["template_tagid"] = in.TemplateTag combineParam["template_tagid"] = in.TemplateTag
@ -308,11 +299,14 @@ func (l *defaultImageHandle) LogoCombine(ctx context.Context, in *LogoCombineReq
combineParam["phone"] = in.Phone combineParam["phone"] = in.Phone
combineParam["address"] = in.Address combineParam["address"] = in.Address
combineParam["qrcode"] = in.Qrcode 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) var postMap = make(map[string]interface{}, 2)
postMap["module_data"] = moduleDataMap postMap["module_data"] = moduleDataMap
postMap["tag_data"] = tagDataMap postMap["tag_data"] = in.ProductTemplateTagGroups
postMap["param_data"] = combineParam postMap["param_data"] = combineParam
logc.Infof(ctx, "合图--算法请求--合图--开始时间：%v", time.Now().UTC()) 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") 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 { if err != nil {
panic(err) 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 { for k, v := range metadataChild {
switch val := v.(type) { switch val := v.(type) {
case map[string]interface{}: case map[string]interface{}:
oldResourceMetadataData := oldMetadata[k].(map[string]interface{}) kValue, kEx := oldMetadata[k]
for key, val1 := range val { var oldResourceMetadataData map[string]interface{}
oldResourceMetadataData[key] = val1 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 oldMetadata[k] = oldResourceMetadataData
default: default:
@ -20,11 +26,17 @@ func SetMetadata(metadataChild map[string]interface{}, oldMetadata map[string]in
for k, v := range metadataChild { for k, v := range metadataChild {
switch val := v.(type) { switch val := v.(type) {
case map[string]interface{}: case map[string]interface{}:
var resourceMetadataData = make(map[string]interface{}, len(val)) kValue, kEx := oldMetadata[k]
for key, val1 := range val { var oldResourceMetadataData map[string]interface{}
resourceMetadataData[key] = val1 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: default:
oldMetadata[k] = val oldMetadata[k] = val
} }

8
utils/websocket_data/render_data.go
View File

@ -16,6 +16,9 @@ type RenderImageReqMsg struct {
} }
type RenderData struct { type RenderData struct {
TemplateTag string `json:"template_tag"` //模板标签(必须) 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(必须) ProductId int64 `json:"product_id"` //产品id(必须)
Website string `json:"website"` //网站(可选) Website string `json:"website"` //网站(可选)
Slogan string `json:"slogan"` //slogan(可选) Slogan string `json:"slogan"` //slogan(可选)
@ -25,7 +28,10 @@ type RenderData struct {
ProductSizeId int64 `json:"product_size_id"` //尺寸id(可选) ProductSizeId int64 `json:"product_size_id"` //尺寸id(可选)
UserId int64 `json:"user_id"` //用户id(websocket连接建立再赋值) UserId int64 `json:"user_id"` //用户id(websocket连接建立再赋值)
GuestId int64 `json:"guest_id"` //游客id(websocket连接建立再赋值) GuestId int64 `json:"guest_id"` //游客id(websocket连接建立再赋值)
Logo string `json:"logo"` //log资源地址(websocket连接建立再赋值) }
type TemplateTagColor struct {
Color [][]string `json:"color"` //颜色组合
SelectedColorIndex int `json:"selected_color_index"` //主色的下标索引
} }
// websocket发送渲染完的数据 // websocket发送渲染完的数据