397 lines
9.3 KiB
Go
397 lines
9.3 KiB
Go
package aiService
|
|
|
|
import (
|
|
"91porn-server/common"
|
|
"91porn-server/common/httputil"
|
|
"91porn-server/common/log"
|
|
"91porn-server/common/redis"
|
|
"encoding/json"
|
|
"errors"
|
|
"reflect"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/fatih/structs"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
)
|
|
|
|
type AiService struct {
|
|
c *Conf
|
|
}
|
|
|
|
type Conf struct {
|
|
AppId int
|
|
Url string
|
|
Redis *redis.Client
|
|
}
|
|
|
|
type Option func(c *Conf)
|
|
|
|
func NewAiService(opts ...Option) *AiService {
|
|
c := &Conf{}
|
|
for _, opt := range opts {
|
|
opt(c)
|
|
}
|
|
return &AiService{
|
|
c: c,
|
|
}
|
|
}
|
|
|
|
func Redis(r *redis.Client) Option {
|
|
return func(c *Conf) {
|
|
c.Redis = r
|
|
}
|
|
}
|
|
|
|
func AppId(appId int) Option {
|
|
return func(c *Conf) {
|
|
c.AppId = appId
|
|
}
|
|
}
|
|
|
|
func Url(url string) Option {
|
|
return func(c *Conf) {
|
|
c.Url = url
|
|
}
|
|
}
|
|
|
|
type msg struct {
|
|
Code int `json:"code"`
|
|
Msg string `json:"msg"`
|
|
Data interface{} `json:"data"`
|
|
}
|
|
|
|
func (m *AiService) getParams(p interface{}) (params map[string]interface{}) {
|
|
req := structs.New(p)
|
|
fields := req.Fields()
|
|
params = make(map[string]interface{})
|
|
for _, field := range fields {
|
|
jsonTag := field.Tag("json")
|
|
tagList := strings.Split(jsonTag, ",")
|
|
key := field.Name()
|
|
omitempty := ""
|
|
if len(tagList) > 0 {
|
|
key = tagList[0]
|
|
}
|
|
if len(tagList) > 1 {
|
|
omitempty = tagList[1]
|
|
}
|
|
kind := reflect.TypeOf(field.Value()).Kind()
|
|
// 如果是0值忽略或者空指针，不需要传
|
|
if field.IsZero() && (kind == reflect.Ptr || omitempty == "omitempty") {
|
|
continue
|
|
}
|
|
if kind == reflect.Ptr {
|
|
// 通过指针取值
|
|
params[key] = reflect.ValueOf(field.Value()).Elem().Interface()
|
|
} else {
|
|
params[key] = field.Value()
|
|
}
|
|
}
|
|
params["appId"] = m.c.AppId
|
|
return
|
|
}
|
|
|
|
func (s *AiService) getTemplateList(p *TemplateListReq) (result TemplateListResp, err error) {
|
|
var retMsg msg
|
|
path := "/api/ai/template/all"
|
|
params := s.getParams(p)
|
|
code, err := httputil.DefaultClientGetWithResp(&retMsg, common.BindUrl(s.c.Url, path), nil, params)
|
|
if err != nil {
|
|
log.Error("AiService GetTemplateList fail", log.Any("params", params), log.E(err))
|
|
err = errors.New("AiService GetTemplateList fail")
|
|
return
|
|
}
|
|
if code != 200 {
|
|
log.Error("AiService GetTemplateList fail", log.Any("params", params), log.Any("code", code))
|
|
err = errors.New("AiService GetTemplateList fail")
|
|
return
|
|
}
|
|
|
|
if retMsg.Code != 200 {
|
|
log.Error("AiService GetTemplateList fail", log.Any("params", params), log.Any("retMsg", retMsg))
|
|
err = errors.New("AiService GetTemplateList fail")
|
|
return
|
|
}
|
|
|
|
b, err := json.Marshal(retMsg.Data)
|
|
if err != nil {
|
|
log.Error("AiService GetTemplateList json.Marshal fail", log.Any("params", params), log.E(err))
|
|
err = errors.New("AiService GetTemplateList json.Marshal fail")
|
|
return
|
|
}
|
|
|
|
if err = json.Unmarshal(b, &result); err != nil {
|
|
log.Error("AiService GetTemplateList json.Unmarshal fail", log.Any("params", params), log.Any("data", string(b)), log.E(err))
|
|
err = errors.New("AiService GetTemplateList json.Unmarshal fail")
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
type TemplateDetailReq struct {
|
|
Ids []primitive.ObjectID `json:"ids" binding:"required"`
|
|
}
|
|
|
|
func (s *AiService) getTemplateDetail(p *TemplateDetailReq) (result TemplateDetailResp, err error) {
|
|
var retMsg msg
|
|
path := "/api/ai/template/detail"
|
|
params := s.getParams(p)
|
|
code, err := httputil.DefaultClientPostJsonWithResp(&retMsg, common.BindUrl(s.c.Url, path), nil, params)
|
|
if err != nil {
|
|
log.Error("AiService GetTemplateDetail fail", log.Any("params", params), log.E(err))
|
|
err = errors.New("AiService GetTemplateDetail fail")
|
|
return
|
|
}
|
|
if code != 200 {
|
|
log.Error("AiService GetTemplateDetail fail", log.Any("params", params), log.Any("code", code))
|
|
err = errors.New("AiService GetTemplateDetail fail")
|
|
return
|
|
}
|
|
|
|
if retMsg.Code != 200 {
|
|
log.Error("AiService GetTemplateDetail fail", log.Any("params", params), log.Any("retMsg", retMsg))
|
|
err = errors.New("AiService GetTemplateDetail fail")
|
|
return
|
|
}
|
|
|
|
b, err := json.Marshal(retMsg.Data)
|
|
if err != nil {
|
|
log.Error("AiService GetTemplateDetail json.Marshal fail", log.Any("params", params), log.E(err))
|
|
err = errors.New("AiService GetTemplateDetail json.Marshal fail")
|
|
return
|
|
}
|
|
|
|
if err = json.Unmarshal(b, &result); err != nil {
|
|
log.Error("AiService GetTemplateDetail json.Unmarshal fail", log.Any("params", params), log.Any("data", string(b)), log.E(err))
|
|
err = errors.New("AiService GetTemplateDetail json.Unmarshal fail")
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *AiService) Sync() (err error) {
|
|
if s.c.Redis == nil {
|
|
return errors.New("redis is nil")
|
|
}
|
|
resp, err := s.getTemplateList(&TemplateListReq{})
|
|
if err != nil {
|
|
log.Error("AI Template sync fail", log.E(err))
|
|
return
|
|
}
|
|
for _, template := range resp.TemplateList {
|
|
b, err := json.Marshal(template)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
// 将模版数据写入redis
|
|
s.c.Redis.Set(AiTemplateKey(template.ID), string(b), time.Hour*24*7)
|
|
}
|
|
var imageCategoryList []Category
|
|
var videoCategoryList []Category
|
|
for _, v := range resp.CategoryList {
|
|
if v.Type == 0 {
|
|
imageCategoryList = append(imageCategoryList, v)
|
|
} else {
|
|
videoCategoryList = append(videoCategoryList, v)
|
|
}
|
|
}
|
|
// 将数据写入写入redis
|
|
b0, err := json.Marshal(imageCategoryList)
|
|
if err != nil {
|
|
log.Error("AI Template json.Marshal(imageCategoryList) fail", log.E(err))
|
|
return
|
|
}
|
|
b1, err := json.Marshal(videoCategoryList)
|
|
if err != nil {
|
|
log.Error("AI Template json.Marshal(videoCategoryList) fail", log.E(err))
|
|
return
|
|
}
|
|
err = s.c.Redis.Set(AiCategoryKey(0), string(b0), time.Hour*24*7)
|
|
if err != nil {
|
|
log.Error("AI Template Redis.Set(AiCategoryKey(0) fail", log.E(err))
|
|
return
|
|
}
|
|
err = s.c.Redis.Set(AiCategoryKey(1), string(b1), time.Hour*24*7)
|
|
if err != nil {
|
|
log.Error("AI Template Redis.Set(AiCategoryKey(1) fail", log.E(err))
|
|
return
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *AiService) GetTemplateList(types int, categoryId string) (categoryList []*Category, queryCategoryId string, templateList []*Template, err error) {
|
|
if s.c.Redis == nil {
|
|
err = errors.New("redis nil")
|
|
return
|
|
}
|
|
// 获取分类列表
|
|
val, err := s.c.Redis.Get(AiCategoryKey(types))
|
|
if err != nil {
|
|
return
|
|
}
|
|
if val == nil {
|
|
return
|
|
}
|
|
err = json.Unmarshal([]byte(*val), &categoryList)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if len(categoryList) == 0 {
|
|
return
|
|
}
|
|
if categoryId == "" {
|
|
queryCategoryId = categoryList[0].ID.Hex()
|
|
} else {
|
|
queryCategoryId = categoryId
|
|
}
|
|
templateIds := []primitive.ObjectID{}
|
|
for _, v := range categoryList {
|
|
if v.ID.Hex() == queryCategoryId {
|
|
templateIds = v.TemplateIds
|
|
break
|
|
}
|
|
}
|
|
keys := []string{}
|
|
for _, templateId := range templateIds {
|
|
keys = append(keys, AiTemplateKey(templateId))
|
|
}
|
|
if len(keys) == 0 {
|
|
return
|
|
}
|
|
// 通过id查找这个模版
|
|
res, err := s.c.Redis.MGet(keys...)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for _, v := range res {
|
|
templateVal, ok := v.(string)
|
|
if !ok || templateVal == "" {
|
|
continue
|
|
}
|
|
item := Template{}
|
|
err = json.Unmarshal([]byte(templateVal), &item)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if item.ModuleType != types {
|
|
continue
|
|
}
|
|
templateList = append(templateList, &item)
|
|
}
|
|
return categoryList, queryCategoryId, templateList, nil
|
|
}
|
|
|
|
func (s *AiService) GetTemplate(id primitive.ObjectID) (template Template, err error) {
|
|
if id.IsZero() {
|
|
return
|
|
}
|
|
if s.c.Redis == nil {
|
|
err = errors.New("redis nil")
|
|
return
|
|
}
|
|
// 从缓存中获取数据
|
|
val, err := s.c.Redis.Get(AiTemplateKey(id))
|
|
if err != nil {
|
|
return
|
|
}
|
|
if val != nil && *val != "" {
|
|
err = json.Unmarshal([]byte(*val), &template)
|
|
if err == nil {
|
|
return template, nil
|
|
}
|
|
}
|
|
// 如果获取不到，尝试从ai服务获取
|
|
res, err := s.getTemplateDetail(&TemplateDetailReq{
|
|
Ids: []primitive.ObjectID{id},
|
|
})
|
|
if err != nil {
|
|
return
|
|
}
|
|
if len(res.List) == 0 {
|
|
return
|
|
}
|
|
template = res.List[0]
|
|
common.Go(func() {
|
|
b, err := json.Marshal(template)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// 将模版数据写入redis
|
|
s.c.Redis.Set(AiTemplateKey(template.ID), string(b), time.Hour*48)
|
|
})
|
|
return template, nil
|
|
}
|
|
|
|
func (s *AiService) GetTemplateByIds(ids []primitive.ObjectID) (templateList []Template, err error) {
|
|
if len(ids) == 0 {
|
|
return
|
|
}
|
|
if s.c.Redis == nil {
|
|
err = errors.New("redis nil")
|
|
return
|
|
}
|
|
|
|
keys := []string{}
|
|
for _, id := range ids {
|
|
keys = append(keys, AiTemplateKey(id))
|
|
}
|
|
// 从缓存中获取数据
|
|
list, err := s.c.Redis.MGet(keys...)
|
|
if err != nil {
|
|
return
|
|
}
|
|
noFoundKey := []int{}
|
|
for k, v := range list {
|
|
if v == nil {
|
|
noFoundKey = append(noFoundKey, k)
|
|
continue
|
|
}
|
|
val, ok := v.(string)
|
|
if !ok || val == "" {
|
|
noFoundKey = append(noFoundKey, k)
|
|
continue
|
|
}
|
|
item := Template{}
|
|
err = json.Unmarshal([]byte(val), &item)
|
|
if err != nil {
|
|
noFoundKey = append(noFoundKey, k)
|
|
continue
|
|
}
|
|
templateList = append(templateList, item)
|
|
}
|
|
noFoundIds := []primitive.ObjectID{}
|
|
for _, k := range noFoundKey {
|
|
noFoundIds = append(noFoundIds, ids[k])
|
|
}
|
|
if len(noFoundIds) == 0 {
|
|
return
|
|
}
|
|
// 如果获取不到，尝试从ai服务获取
|
|
res, err := s.getTemplateDetail(&TemplateDetailReq{
|
|
Ids: noFoundIds,
|
|
})
|
|
if err != nil {
|
|
return
|
|
}
|
|
if len(res.List) == 0 {
|
|
return
|
|
}
|
|
templateList = append(templateList, res.List...)
|
|
common.Go(func() {
|
|
// 将查到的写入redis
|
|
for _, template := range res.List {
|
|
b, err := json.Marshal(template)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// 将模版数据写入redis
|
|
s.c.Redis.Set(AiTemplateKey(template.ID), string(b), time.Hour*48)
|
|
}
|
|
|
|
})
|
|
return templateList, nil
|
|
}
|